cocoindex 0.1.71__cp311-cp311-win_amd64.whl → 0.1.73__cp311-cp311-win_amd64.whl

cocoindex/tests/test_typing.py

@@ -9,6 +9,10 @@ import pytest
 from numpy.typing import NDArray
 
 from cocoindex.typing import (
+    AnalyzedBasicType,
+    AnalyzedDictType,
+    AnalyzedListType,
+    AnalyzedStructType,
     AnalyzedTypeInfo,
     TypeAttr,
     TypeKind,
@@ -33,83 +37,67 @@ class SimpleNamedTuple(NamedTuple):
 def test_ndarray_float32_no_dim() -> None:
     typ = NDArray[np.float32]
     result = analyze_type_info(typ)
-    assert result.kind == "Vector"
-    assert result.vector_info == VectorInfo(dim=None)
-    assert result.elem_type == np.float32
-    assert result.key_type is None
-    assert result.struct_type is None
+    assert isinstance(result.variant, AnalyzedListType)
+    assert result.variant.vector_info is None
+    assert result.variant.elem_type == np.float32
     assert result.nullable is False
-    assert result.np_number_type is not None
-    assert get_origin(result.np_number_type) == np.ndarray
-    assert get_args(result.np_number_type)[1] == np.dtype[np.float32]
+    assert get_origin(result.core_type) == np.ndarray
+    assert get_args(result.core_type)[1] == np.dtype[np.float32]
 
 
 def test_vector_float32_no_dim() -> None:
     typ = Vector[np.float32]
     result = analyze_type_info(typ)
-    assert result.kind == "Vector"
-    assert result.vector_info == VectorInfo(dim=None)
-    assert result.elem_type == np.float32
-    assert result.key_type is None
-    assert result.struct_type is None
+    assert isinstance(result.variant, AnalyzedListType)
+    assert result.variant.vector_info == VectorInfo(dim=None)
+    assert result.variant.elem_type == np.float32
     assert result.nullable is False
-    assert result.np_number_type is not None
-    assert get_origin(result.np_number_type) == np.ndarray
-    assert get_args(result.np_number_type)[1] == np.dtype[np.float32]
+    assert get_origin(result.core_type) == np.ndarray
+    assert get_args(result.core_type)[1] == np.dtype[np.float32]
 
 
 def test_ndarray_float64_with_dim() -> None:
     typ = Annotated[NDArray[np.float64], VectorInfo(dim=128)]
     result = analyze_type_info(typ)
-    assert result.kind == "Vector"
-    assert result.vector_info == VectorInfo(dim=128)
-    assert result.elem_type == np.float64
-    assert result.key_type is None
-    assert result.struct_type is None
+    assert isinstance(result.variant, AnalyzedListType)
+    assert result.variant.vector_info == VectorInfo(dim=128)
+    assert result.variant.elem_type == np.float64
     assert result.nullable is False
-    assert result.np_number_type is not None
-    assert get_origin(result.np_number_type) == np.ndarray
-    assert get_args(result.np_number_type)[1] == np.dtype[np.float64]
+    assert get_origin(result.core_type) == np.ndarray
+    assert get_args(result.core_type)[1] == np.dtype[np.float64]
 
 
 def test_vector_float32_with_dim() -> None:
     typ = Vector[np.float32, Literal[384]]
     result = analyze_type_info(typ)
-    assert result.kind == "Vector"
-    assert result.vector_info == VectorInfo(dim=384)
-    assert result.elem_type == np.float32
-    assert result.key_type is None
-    assert result.struct_type is None
+    assert isinstance(result.variant, AnalyzedListType)
+    assert result.variant.vector_info == VectorInfo(dim=384)
+    assert result.variant.elem_type == np.float32
     assert result.nullable is False
-    assert result.np_number_type is not None
-    assert get_origin(result.np_number_type) == np.ndarray
-    assert get_args(result.np_number_type)[1] == np.dtype[np.float32]
+    assert get_origin(result.core_type) == np.ndarray
+    assert get_args(result.core_type)[1] == np.dtype[np.float32]
 
 
 def test_ndarray_int64_no_dim() -> None:
     typ = NDArray[np.int64]
     result = analyze_type_info(typ)
-    assert result.kind == "Vector"
-    assert result.vector_info == VectorInfo(dim=None)
-    assert result.elem_type == np.int64
+    assert isinstance(result.variant, AnalyzedListType)
+    assert result.variant.vector_info is None
+    assert result.variant.elem_type == np.int64
     assert result.nullable is False
-    assert result.np_number_type is not None
-    assert get_origin(result.np_number_type) == np.ndarray
-    assert get_args(result.np_number_type)[1] == np.dtype[np.int64]
+    assert get_origin(result.core_type) == np.ndarray
+    assert get_args(result.core_type)[1] == np.dtype[np.int64]
 
 
 def test_nullable_ndarray() -> None:
     typ = NDArray[np.float32] | None
     result = analyze_type_info(typ)
-    assert result.kind == "Vector"
-    assert result.vector_info == VectorInfo(dim=None)
-    assert result.elem_type == np.float32
-    assert result.key_type is None
-    assert result.struct_type is None
+    assert isinstance(result.variant, AnalyzedListType)
+    assert result.variant.vector_info is None
+    assert result.variant.elem_type == np.float32
     assert result.nullable is True
-    assert result.np_number_type is not None
-    assert get_origin(result.np_number_type) == np.ndarray
-    assert get_args(result.np_number_type)[1] == np.dtype[np.float32]
+    assert get_origin(result.core_type) == np.ndarray
+    assert get_args(result.core_type)[1] == np.dtype[np.float32]
 
 
 def test_scalar_numpy_types() -> None:
@@ -119,59 +107,38 @@ def test_scalar_numpy_types() -> None:
         (np.float64, "Float64"),
     ]:
         type_info = analyze_type_info(np_type)
-        assert type_info.kind == expected_kind, (
-            f"Expected {expected_kind} for {np_type}, got {type_info.kind}"
+        assert isinstance(type_info.variant, AnalyzedBasicType)
+        assert type_info.variant.kind == expected_kind, (
+            f"Expected {expected_kind} for {np_type}, got {type_info.variant.kind}"
         )
-        assert type_info.np_number_type == np_type, (
-            f"Expected {np_type}, got {type_info.np_number_type}"
+        assert type_info.core_type == np_type, (
+            f"Expected {np_type}, got {type_info.core_type}"
         )
-        assert type_info.elem_type is None
-        assert type_info.vector_info is None
 
 
 def test_vector_str() -> None:
     typ = Vector[str]
     result = analyze_type_info(typ)
-    assert result.kind == "Vector"
-    assert result.elem_type is str
-    assert result.vector_info == VectorInfo(dim=None)
-
-
-def test_vector_complex64() -> None:
-    typ = Vector[np.complex64]
-    result = analyze_type_info(typ)
-    assert result.kind == "Vector"
-    assert result.elem_type == np.complex64
-    assert result.vector_info == VectorInfo(dim=None)
+    assert isinstance(result.variant, AnalyzedListType)
+    assert result.variant.elem_type is str
+    assert result.variant.vector_info == VectorInfo(dim=None)
 
 
 def test_non_numpy_vector() -> None:
     typ = Vector[float, Literal[3]]
     result = analyze_type_info(typ)
-    assert result.kind == "Vector"
-    assert result.elem_type is float
-    assert result.vector_info == VectorInfo(dim=3)
-
-
-def test_ndarray_any_dtype() -> None:
-    typ = NDArray[Any]
-    with pytest.raises(
-        TypeError, match="NDArray for Vector must use a concrete numpy dtype"
-    ):
-        analyze_type_info(typ)
+    assert isinstance(result.variant, AnalyzedListType)
+    assert result.variant.elem_type is float
+    assert result.variant.vector_info == VectorInfo(dim=3)
 
 
 def test_list_of_primitives() -> None:
     typ = list[str]
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
-        kind="Vector",
         core_type=list[str],
-        vector_info=VectorInfo(dim=None),
-        elem_type=str,
-        key_type=None,
-        struct_type=None,
-        np_number_type=None,
+        base_type=list,
+        variant=AnalyzedListType(elem_type=str, vector_info=None),
         attrs=None,
         nullable=False,
     )
@@ -181,13 +148,9 @@ def test_list_of_structs() -> None:
     typ = list[SimpleDataclass]
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
-        kind="LTable",
         core_type=list[SimpleDataclass],
-        vector_info=None,
-        elem_type=SimpleDataclass,
-        key_type=None,
-        struct_type=None,
-        np_number_type=None,
+        base_type=list,
+        variant=AnalyzedListType(elem_type=SimpleDataclass, vector_info=None),
         attrs=None,
         nullable=False,
     )
@@ -197,13 +160,9 @@ def test_sequence_of_int() -> None:
     typ = Sequence[int]
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
-        kind="Vector",
         core_type=Sequence[int],
-        vector_info=VectorInfo(dim=None),
-        elem_type=int,
-        key_type=None,
-        struct_type=None,
-        np_number_type=None,
+        base_type=Sequence,
+        variant=AnalyzedListType(elem_type=int, vector_info=None),
         attrs=None,
         nullable=False,
     )
@@ -213,13 +172,9 @@ def test_list_with_vector_info() -> None:
     typ = Annotated[list[int], VectorInfo(dim=5)]
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
-        kind="Vector",
         core_type=list[int],
-        vector_info=VectorInfo(dim=5),
-        elem_type=int,
-        key_type=None,
-        struct_type=None,
-        np_number_type=None,
+        base_type=list,
+        variant=AnalyzedListType(elem_type=int, vector_info=VectorInfo(dim=5)),
         attrs=None,
         nullable=False,
     )
@@ -229,13 +184,9 @@ def test_dict_str_int() -> None:
     typ = dict[str, int]
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
-        kind="KTable",
         core_type=dict[str, int],
-        vector_info=None,
-        elem_type=(str, int),
-        key_type=None,
-        struct_type=None,
-        np_number_type=None,
+        base_type=dict,
+        variant=AnalyzedDictType(key_type=str, value_type=int),
         attrs=None,
         nullable=False,
     )
@@ -245,13 +196,9 @@ def test_mapping_str_dataclass() -> None:
     typ = Mapping[str, SimpleDataclass]
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
-        kind="KTable",
         core_type=Mapping[str, SimpleDataclass],
-        vector_info=None,
-        elem_type=(str, SimpleDataclass),
-        key_type=None,
-        struct_type=None,
-        np_number_type=None,
+        base_type=Mapping,
+        variant=AnalyzedDictType(key_type=str, value_type=SimpleDataclass),
         attrs=None,
         nullable=False,
     )
@@ -261,13 +208,9 @@ def test_dataclass() -> None:
     typ = SimpleDataclass
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
-        kind="Struct",
         core_type=SimpleDataclass,
-        vector_info=None,
-        elem_type=None,
-        key_type=None,
-        struct_type=SimpleDataclass,
-        np_number_type=None,
+        base_type=SimpleDataclass,
+        variant=AnalyzedStructType(struct_type=SimpleDataclass),
         attrs=None,
         nullable=False,
     )
@@ -277,29 +220,9 @@ def test_named_tuple() -> None:
     typ = SimpleNamedTuple
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
-        kind="Struct",
         core_type=SimpleNamedTuple,
-        vector_info=None,
-        elem_type=None,
-        key_type=None,
-        struct_type=SimpleNamedTuple,
-        np_number_type=None,
-        attrs=None,
-        nullable=False,
-    )
-
-
-def test_tuple_key_value() -> None:
-    typ = (str, int)
-    result = analyze_type_info(typ)
-    assert result == AnalyzedTypeInfo(
-        kind="Int64",
-        core_type=int,
-        vector_info=None,
-        elem_type=None,
-        key_type=str,
-        struct_type=None,
-        np_number_type=None,
+        base_type=SimpleNamedTuple,
+        variant=AnalyzedStructType(struct_type=SimpleNamedTuple),
         attrs=None,
         nullable=False,
     )
@@ -309,13 +232,9 @@ def test_str() -> None:
     typ = str
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
-        kind="Str",
         core_type=str,
-        vector_info=None,
-        elem_type=None,
-        key_type=None,
-        struct_type=None,
-        np_number_type=None,
+        base_type=str,
+        variant=AnalyzedBasicType(kind="Str"),
         attrs=None,
         nullable=False,
     )
@@ -325,13 +244,9 @@ def test_bool() -> None:
     typ = bool
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
-        kind="Bool",
         core_type=bool,
-        vector_info=None,
-        elem_type=None,
-        key_type=None,
-        struct_type=None,
-        np_number_type=None,
+        base_type=bool,
+        variant=AnalyzedBasicType(kind="Bool"),
         attrs=None,
         nullable=False,
     )
@@ -341,13 +256,9 @@ def test_bytes() -> None:
     typ = bytes
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
-        kind="Bytes",
         core_type=bytes,
-        vector_info=None,
-        elem_type=None,
-        key_type=None,
-        struct_type=None,
-        np_number_type=None,
+        base_type=bytes,
+        variant=AnalyzedBasicType(kind="Bytes"),
         attrs=None,
         nullable=False,
     )
@@ -357,13 +268,9 @@ def test_uuid() -> None:
     typ = uuid.UUID
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
-        kind="Uuid",
         core_type=uuid.UUID,
-        vector_info=None,
-        elem_type=None,
-        key_type=None,
-        struct_type=None,
-        np_number_type=None,
+        base_type=uuid.UUID,
+        variant=AnalyzedBasicType(kind="Uuid"),
         attrs=None,
         nullable=False,
     )
@@ -373,13 +280,9 @@ def test_date() -> None:
     typ = datetime.date
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
-        kind="Date",
         core_type=datetime.date,
-        vector_info=None,
-        elem_type=None,
-        key_type=None,
-        struct_type=None,
-        np_number_type=None,
+        base_type=datetime.date,
+        variant=AnalyzedBasicType(kind="Date"),
         attrs=None,
         nullable=False,
     )
@@ -389,13 +292,9 @@ def test_time() -> None:
     typ = datetime.time
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
-        kind="Time",
         core_type=datetime.time,
-        vector_info=None,
-        elem_type=None,
-        key_type=None,
-        struct_type=None,
-        np_number_type=None,
+        base_type=datetime.time,
+        variant=AnalyzedBasicType(kind="Time"),
         attrs=None,
         nullable=False,
     )
@@ -405,13 +304,9 @@ def test_timedelta() -> None:
     typ = datetime.timedelta
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
-        kind="TimeDelta",
         core_type=datetime.timedelta,
-        vector_info=None,
-        elem_type=None,
-        key_type=None,
-        struct_type=None,
-        np_number_type=None,
+        base_type=datetime.timedelta,
+        variant=AnalyzedBasicType(kind="TimeDelta"),
         attrs=None,
         nullable=False,
     )
@@ -421,13 +316,9 @@ def test_float() -> None:
     typ = float
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
-        kind="Float64",
         core_type=float,
-        vector_info=None,
-        elem_type=None,
-        key_type=None,
-        struct_type=None,
-        np_number_type=None,
+        base_type=float,
+        variant=AnalyzedBasicType(kind="Float64"),
         attrs=None,
         nullable=False,
     )
@@ -437,13 +328,9 @@ def test_int() -> None:
     typ = int
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
-        kind="Int64",
         core_type=int,
-        vector_info=None,
-        elem_type=None,
-        key_type=None,
-        struct_type=None,
-        np_number_type=None,
+        base_type=int,
+        variant=AnalyzedBasicType(kind="Int64"),
         attrs=None,
         nullable=False,
     )
@@ -453,13 +340,9 @@ def test_type_with_attributes() -> None:
     typ = Annotated[str, TypeAttr("key", "value")]
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
-        kind="Str",
         core_type=str,
-        vector_info=None,
-        elem_type=None,
-        key_type=None,
-        struct_type=None,
-        np_number_type=None,
+        base_type=str,
+        variant=AnalyzedBasicType(kind="Str"),
         attrs={"key": "value"},
         nullable=False,
     )
@@ -494,7 +377,7 @@ def test_encode_enriched_type_ltable() -> None:
     typ = list[SimpleDataclass]
     result = encode_enriched_type(typ)
     assert result["type"]["kind"] == "LTable"
-    assert result["type"]["row"]["kind"] == "Struct"
+    assert "fields" in result["type"]["row"]
     assert len(result["type"]["row"]["fields"]) == 2
 
 
@@ -525,22 +408,29 @@ def test_encode_scalar_numpy_types_schema() -> None:
         assert not schema.get("nullable", False)
 
 
-def test_invalid_struct_kind() -> None:
+def test_annotated_struct_with_type_kind() -> None:
     typ = Annotated[SimpleDataclass, TypeKind("Vector")]
-    with pytest.raises(ValueError, match="Unexpected type kind for struct: Vector"):
-        analyze_type_info(typ)
+    result = analyze_type_info(typ)
+    assert isinstance(result.variant, AnalyzedBasicType)
+    assert result.variant.kind == "Vector"
 
 
-def test_invalid_list_kind() -> None:
+def test_annotated_list_with_type_kind() -> None:
     typ = Annotated[list[int], TypeKind("Struct")]
-    with pytest.raises(ValueError, match="Unexpected type kind for list: Struct"):
-        analyze_type_info(typ)
+    result = analyze_type_info(typ)
+    assert isinstance(result.variant, AnalyzedBasicType)
+    assert result.variant.kind == "Struct"
 
 
 def test_unsupported_type() -> None:
-    typ = set
     with pytest.raises(
         ValueError,
         match="Unsupported as a specific type annotation for CocoIndex data type.*: <class 'set'>",
     ):
-        analyze_type_info(typ)
+        analyze_type_info(set)
+
+    with pytest.raises(
+        ValueError,
+        match="Unsupported as a specific type annotation for CocoIndex data type.*: <class 'numpy.complex64'>",
+    ):
+        Vector[np.complex64]

cocoindex/tests/test_validation.py

@@ -0,0 +1,134 @@
+"""Tests for naming validation functionality."""
+
+import pytest
+from cocoindex.validation import (
+    validate_field_name,
+    validate_flow_name,
+    validate_full_flow_name,
+    validate_app_namespace_name,
+    validate_target_name,
+    NamingError,
+    validate_identifier_name,
+)
+
+
+class TestValidateIdentifierName:
+    """Test the core validation function."""
+
+    def test_valid_names(self) -> None:
+        """Test that valid names pass validation."""
+        valid_names = [
+            "field1",
+            "field_name",
+            "_private",
+            "a",
+            "field123",
+            "FIELD_NAME",
+            "MyField",
+            "field_123_test",
+        ]
+
+        for name in valid_names:
+            result = validate_identifier_name(name)
+            assert result is None, f"Valid name '{name}' failed validation: {result}"
+
+    def test_valid_names_with_dots(self) -> None:
+        """Test that valid names with dots pass validation when allowed."""
+        valid_names = ["app.flow", "my_app.my_flow", "namespace.sub.flow", "a.b.c.d"]
+
+        for name in valid_names:
+            result = validate_identifier_name(name, allow_dots=True)
+            assert result is None, (
+                f"Valid dotted name '{name}' failed validation: {result}"
+            )
+
+    def test_invalid_starting_characters(self) -> None:
+        """Test names with invalid starting characters."""
+        invalid_names = [
+            "123field",  # starts with digit
+            ".field",  # starts with dot
+            "-field",  # starts with dash
+            " field",  # starts with space
+        ]
+
+        for name in invalid_names:
+            result = validate_identifier_name(name)
+            assert result is not None, (
+                f"Invalid name '{name}' should have failed validation"
+            )
+
+    def test_double_underscore_restriction(self) -> None:
+        """Test double underscore restriction."""
+        invalid_names = ["__reserved", "__internal", "__test"]
+
+        for name in invalid_names:
+            result = validate_identifier_name(name)
+            assert result is not None
+            assert "double underscores" in result.lower()
+
+    def test_length_restriction(self) -> None:
+        """Test maximum length restriction."""
+        long_name = "a" * 65
+        result = validate_identifier_name(long_name, max_length=64)
+        assert result is not None
+        assert "maximum length" in result.lower()
+
+
+class TestSpecificValidators:
+    """Test the specific validation functions."""
+
+    def test_valid_field_names(self) -> None:
+        """Test valid field names."""
+        valid_names = ["field1", "field_name", "_private", "FIELD"]
+        for name in valid_names:
+            validate_field_name(name)  # Should not raise
+
+    def test_invalid_field_names(self) -> None:
+        """Test invalid field names raise NamingError."""
+        invalid_names = ["123field", "field-name", "__reserved", "a" * 65]
+
+        for name in invalid_names:
+            with pytest.raises(NamingError):
+                validate_field_name(name)
+
+    def test_flow_validation(self) -> None:
+        """Test flow name validation."""
+        # Valid flow names
+        validate_flow_name("MyFlow")
+        validate_flow_name("my_flow_123")
+
+        # Invalid flow names
+        with pytest.raises(NamingError):
+            validate_flow_name("123flow")
+
+        with pytest.raises(NamingError):
+            validate_flow_name("__reserved_flow")
+
+    def test_full_flow_name_allows_dots(self) -> None:
+        """Test that full flow names allow dots."""
+        validate_full_flow_name("app.my_flow")
+        validate_full_flow_name("namespace.subnamespace.flow")
+
+        # But still reject invalid patterns
+        with pytest.raises(NamingError):
+            validate_full_flow_name("123.invalid")
+
+    def test_target_validation(self) -> None:
+        """Test target name validation."""
+        validate_target_name("my_target")
+        validate_target_name("output_table")
+
+        with pytest.raises(NamingError):
+            validate_target_name("123target")
+
+    def test_app_namespace_validation(self) -> None:
+        """Test app namespace validation."""
+        validate_app_namespace_name("myapp")
+        validate_app_namespace_name("my_app_123")
+
+        # Should not allow dots in app namespace
+        with pytest.raises(NamingError):
+            validate_app_namespace_name("my.app")
+
+        with pytest.raises(NamingError):
+            validate_app_namespace_name("123app")