feat(vector) Add automatic type inference from items during init

Author: protocolstardust

docs/docs/content/documentation/data-types/vector.md

@@ -5,47 +5,45 @@ The `Vector` type represents a collection of elements of a specific type. All el
 
 ## Usage
 
+The type is automatically inferred from the first item. You can also specify `ray_type` explicitly to cast items to a specific type.
+
 ```python
->>> from rayforce import Vector, I64, Symbol
+>>> from rayforce import Vector, I64, F64, Symbol
 
->>> int_vector = Vector(ray_type=I64, length=3)
+# Type is inferred from items
+>>> int_vector = Vector([1, 2, 3])
 >>> int_vector
-Vector(5)  # 5 represents a type code of I64
+[I64(1), I64(2), I64(3)]
+
+>>> float_vector = Vector([1.5, 2.5, 3.5])
+>>> float_vector
+[F64(1.5), F64(2.5), F64(3.5)]
 
->>> symbol_vector = Vector(ray_type=Symbol, items=["apple", "banana", "cherry"])
+>>> symbol_vector = Vector(["apple", "banana", "cherry"])
 >>> symbol_vector
-Vector(5)  # 6 represents a type code of Symbol
-
->>> timestamp_vector = Vector(
-    ray_type=Timestamp,
-    items=[
-        "2025-05-10T14:30:45+00:00",
-        "2025-05-10T14:30:45+00:00",
-        "2025-05-10T14:30:45+00:00",
-    ]
-)
-```
+[Symbol('apple'), Symbol('banana'), Symbol('cherry')]
 
-### Accessing the values
-```python
->>> [i for i in int_vector]
-[I64(0), I64(0), I64(0), I64(0), I64(0)]
+# Explicit ray_type for casting
+>>> Vector([1, 2, 3], ray_type=F64)
+[F64(1.0), F64(2.0), F64(3.0)]
 
->>> [i for i in symbol_vector]
-[Symbol('apple'), Symbol('banana'), Symbol('cherry')]
+# Pre-allocate empty vector with specific type and length
+>>> Vector(ray_type=I64, length=3)
+[I64(0), I64(0), I64(0)]
 ```
 
-### Setting the values
+### Accessing and Setting Values
 ```python
->>> int_vector[0] = 999
-[I64(999), I64(0), I64(0), I64(0), I64(0)]
->>> int_vector
+>>> v = Vector([10, 20, 30])
+>>> v[0]
+I64(10)
 
->>> symbol_vector[0] = "pineapple"
->>> [i for i in symbol_vector]
-[Symbol('pineapple'), Symbol('banana'), Symbol('cherry')]
+>>> v[0] = 999
+>>> v
+[I64(999), I64(20), I64(30)]
 
-# TODO: Add push object to vector outside of it's length
+>>> [i for i in v]
+[I64(999), I64(20), I64(30)]
 ```
 
 ## Operations
@@ -55,55 +53,55 @@ Vectors support a wide range of operations through mixins.
 ### Arithmetic Operations
 
 ```python
->>> v1 = Vector(ray_type=I64, items=[1, 2, 3])
->>> v2 = Vector(ray_type=I64, items=[4, 5, 6])
+>>> v1 = Vector([1, 2, 3])
+>>> v2 = Vector([4, 5, 6])
 
 >>> v1 + v2
-Vector([I64(5), I64(7), I64(9)])
+[I64(5), I64(7), I64(9)]
 
 >>> v1 * 2
-Vector([I64(2), I64(4), I64(6)])
+[I64(2), I64(4), I64(6)]
 
 >>> v1 - v2
-Vector([I64(-3), I64(-3), I64(-3)])
+[I64(-3), I64(-3), I64(-3)]
 ```
 
 ### Comparison Operations
 
 ```python
->>> v1 = Vector(ray_type=I64, items=[1, 5, 10])
->>> v2 = Vector(ray_type=I64, items=[2, 5, 8])
+>>> v1 = Vector([1, 5, 10])
+>>> v2 = Vector([2, 5, 8])
 
 >>> v1 < v2
-Vector([B8(True), B8(False), B8(False)])
+[B8(True), B8(False), B8(False)]
 
 >>> v1 >= v2
-Vector([B8(False), B8(True), B8(True)])
+[B8(False), B8(True), B8(True)]
 
 >>> v1.eq(v2)
-Vector([B8(False), B8(True), B8(False)])
+[B8(False), B8(True), B8(False)]
 ```
 
 ### Logical Operations
 
 ```python
->>> v1 = Vector(ray_type=B8, items=[True, False, True])
->>> v2 = Vector(ray_type=B8, items=[True, True, False])
+>>> v1 = Vector([True, False, True])
+>>> v2 = Vector([True, True, False])
 
 >>> v1.and_(v2)
-Vector([B8(True), B8(False), B8(False)])
+[B8(True), B8(False), B8(False)]
 
 >>> v1.or_(v2)
-Vector([B8(True), B8(True), B8(True)])
+[B8(True), B8(True), B8(True)]
 
 >>> v1.not_()
-Vector([B8(False), B8(True), B8(False)])
+[B8(False), B8(True), B8(False)]
 ```
 
 ### Aggregation Operations
 
 ```python
->>> v = Vector(ray_type=I64, items=[1, 2, 3, 4, 5])
+>>> v = Vector([1, 2, 3, 4, 5])
 
 >>> v.sum()
 I64(15)
@@ -121,7 +119,7 @@ F64(3.0)
 ### Element Access
 
 ```python
->>> v = Vector(ray_type=I64, items=[10, 20, 30, 40, 50])
+>>> v = Vector([10, 20, 30, 40, 50])
 
 >>> v.first()
 I64(10)
@@ -130,7 +128,7 @@ I64(10)
 I64(50)
 
 >>> v.take(3)
-Vector([I64(10), I64(20), I64(30)])
+[I64(10), I64(20), I64(30)]
 
 >>> v.at(2)
 I64(30)
@@ -139,65 +137,65 @@ I64(30)
 ### Set Operations
 
 ```python
->>> v1 = Vector(ray_type=I64, items=[1, 2, 3, 4])
->>> v2 = Vector(ray_type=I64, items=[3, 4, 5, 6])
+>>> v1 = Vector([1, 2, 3, 4])
+>>> v2 = Vector([3, 4, 5, 6])
 
 >>> v1.union(v2)
-Vector([I64(1), I64(2), I64(3), I64(4), I64(5), I64(6)])
+[I64(1), I64(2), I64(3), I64(4), I64(5), I64(6)]
 
 >>> v1.sect(v2)
-Vector([I64(3), I64(4)])
+[I64(3), I64(4)]
 
 >>> v1.except_(v2)
-Vector([I64(1), I64(2)])
+[I64(1), I64(2)]
 ```
 
 ### Search Operations
 
 ```python
->>> v = Vector(ray_type=I64, items=[10, 20, 30, 40])
+>>> v = Vector([10, 20, 30, 40])
 
 >>> v.find(30)
 I64(2)
 
->>> v.within(Vector(ray_type=I64, items=[15, 35]))
-Vector([B8(False), B8(True), B8(True), B8(False)])
+>>> v.within(Vector([15, 35]))
+[B8(False), B8(True), B8(True), B8(False)]
 
->>> mask = Vector(ray_type=B8, items=[True, False, True, False])
+>>> mask = Vector([True, False, True, False])
 >>> v.filter(mask)
-Vector([I64(10), I64(30)])
+[I64(10), I64(30)]
 ```
 
 ### Sort Operations
 
 ```python
->>> v = Vector(ray_type=I64, items=[3, 1, 4, 1, 5])
+>>> v = Vector([3, 1, 4, 1, 5])
 
 >>> v.asc()
-Vector([I64(1), I64(1), I64(3), I64(4), I64(5)])
+[I64(1), I64(1), I64(3), I64(4), I64(5)]
 
 >>> v.desc()
-Vector([I64(5), I64(4), I64(3), I64(1), I64(1)])
+[I64(5), I64(4), I64(3), I64(1), I64(1)]
 
 >>> v.iasc()  # indices for ascending sort
-Vector([I64(1), I64(3), I64(0), I64(2), I64(4)])
+[I64(1), I64(3), I64(0), I64(2), I64(4)]
 
 >>> v.rank()
-Vector([I64(2), I64(0), I64(3), I64(1), I64(4)])
+[I64(2), I64(0), I64(3), I64(1), I64(4)]
 
 >>> v.reverse()
-Vector([I64(5), I64(1), I64(4), I64(1), I64(3)])
+[I64(5), I64(1), I64(4), I64(1), I64(3)]
 
 >>> v.negate()
-Vector([I64(-3), I64(-1), I64(-4), I64(-1), I64(-5)])
+[I64(-3), I64(-1), I64(-4), I64(-1), I64(-5)]
 ```
 
 ### Functional Operations
 
 ```python
 >>> from rayforce import Operation
 
->>> v = Vector(ray_type=I64, items=[1, 2, 3])
+>>> v = Vector([1, 2, 3])
 >>> v.map(Operation.NEGATE)
-Vector([I64(-1), I64(-2), I64(-3)])
+[I64(-1), I64(-2), I64(-3)]
 ```

rayforce/types/containers/vector.py

@@ -46,26 +46,23 @@ def __init__(
 
         elif items is not None:
             if ray_type is None:
-                raise errors.RayforceInitError("ray_type required when creating Vector from value")
-            self.ptr = self._create_from_value(items, ray_type)
+                if not items:
+                    raise errors.RayforceInitError("Cannot infer vector type for empty items")
+                ray_type = FFI.get_obj_type(utils.python_to_ray(items[0]))
+            self.ptr = self._create_from_value(value=items, ray_type=ray_type)
 
         elif length is not None and ray_type is not None:
             type_code = abs(ray_type if isinstance(ray_type, int) else ray_type.type_code)
             self.ptr = FFI.init_vector(type_code, length)
 
         else:
             raise errors.RayforceInitError(
-                "Vector requires either value, ptr, or (ray_type + length)",
+                "Vector requires either items, ptr, or (ray_type + length)",
             )
 
-    def _create_from_value(
-        self,
-        value: t.Sequence[t.Any],
-        ray_type: type[RayObject] | int | None = None,
+    def _create_from_value(  # type: ignore[override]
+        self, value: t.Sequence[t.Any], ray_type: type[RayObject] | int
     ) -> r.RayObject:
-        if ray_type is None:
-            raise errors.RayforceInitError("Element ray_type must be specified for Vector")
-
         type_code = abs(ray_type if isinstance(ray_type, int) else ray_type.type_code)
         return FFI.init_vector(type_code, list(value))
 

tests/types/containers/test_vector.py

@@ -1,3 +1,9 @@
+import datetime as dt
+import uuid
+
+import pytest
+
+from rayforce import errors
 from rayforce import types as t
 
 
@@ -17,3 +23,67 @@ def test_vector():
     assert v2[0].value == 100
     assert v2[1].value == 200
     assert v2[2].value == 300
+
+
+class TestVectorTypeInference:
+    def test_infer_int_to_i64(self):
+        v = t.Vector([1, 2, 3])
+        assert len(v) == 3
+        assert isinstance(v[0], t.I64)
+        assert v[0].value == 1
+
+    def test_infer_float_to_f64(self):
+        v = t.Vector([1.5, 2.5, 3.5])
+        assert len(v) == 3
+        assert isinstance(v[0], t.F64)
+        assert v[0].value == 1.5
+
+    def test_infer_bool_to_b8(self):
+        v = t.Vector([True, False, True])
+        assert len(v) == 3
+        assert isinstance(v[0], t.B8)
+        assert v[0].value is True
+
+    def test_infer_str_to_symbol(self):
+        v = t.Vector(["apple", "banana", "cherry"])
+        assert len(v) == 3
+        assert isinstance(v[0], t.Symbol)
+        assert v[0].value == "apple"
+
+    def test_infer_datetime_to_timestamp(self):
+        dates = [dt.datetime(2025, 1, 1), dt.datetime(2025, 1, 2)]
+        v = t.Vector(dates)
+        assert len(v) == 2
+        assert isinstance(v[0], t.Timestamp)
+
+    def test_infer_date_to_date(self):
+        dates = [dt.date(2025, 1, 1), dt.date(2025, 1, 2)]
+        v = t.Vector(dates)
+        assert len(v) == 2
+        assert isinstance(v[0], t.Date)
+
+    def test_infer_time_to_time(self):
+        times = [dt.time(12, 30), dt.time(14, 45)]
+        v = t.Vector(times)
+        assert len(v) == 2
+        assert isinstance(v[0], t.Time)
+
+    def test_infer_uuid_to_guid(self):
+        uuids = [uuid.uuid4(), uuid.uuid4()]
+        v = t.Vector(uuids)
+        assert len(v) == 2
+        assert isinstance(v[0], t.GUID)
+
+    def test_explicit_ray_type_overrides_inference(self):
+        v = t.Vector([1, 2, 3], ray_type=t.F64)
+        assert len(v) == 3
+        assert isinstance(v[0], t.F64)
+        assert v[0].value == 1.0
+
+    def test_empty_items_raises_error(self):
+        with pytest.raises(errors.RayforceInitError, match="Cannot infer vector"):
+            t.Vector([])
+
+    def test_none_items_creates_null_vector(self):
+        v = t.Vector([None, None, None])
+        assert len(v) == 3