cocoindex 0.1.43__cp311-cp311-macosx_11_0_arm64.whl → 0.1.45__cp311-cp311-macosx_11_0_arm64.whl

cocoindex/typing.py

@@ -5,14 +5,28 @@ import datetime
 import types
 import inspect
 import uuid
-from typing import Annotated, NamedTuple, Any, TypeVar, TYPE_CHECKING, overload, Sequence, Protocol, Generic, Literal
+from typing import (
+    Annotated,
+    NamedTuple,
+    Any,
+    TypeVar,
+    TYPE_CHECKING,
+    overload,
+    Sequence,
+    Generic,
+    Literal,
+    Protocol,
+)
+
 
 class VectorInfo(NamedTuple):
     dim: int | None
 
+
 class TypeKind(NamedTuple):
     kind: str
 
+
 class TypeAttr:
     key: str
     value: Any
@@ -21,24 +35,31 @@ class TypeAttr:
         self.key = key
         self.value = value
 
+
 Annotation = TypeKind | TypeAttr | VectorInfo
 
-Float32 = Annotated[float, TypeKind('Float32')]
-Float64 = Annotated[float, TypeKind('Float64')]
-Range = Annotated[tuple[int, int], TypeKind('Range')]
-Json = Annotated[Any, TypeKind('Json')]
-LocalDateTime = Annotated[datetime.datetime, TypeKind('LocalDateTime')]
-OffsetDateTime = Annotated[datetime.datetime, TypeKind('OffsetDateTime')]
+Float32 = Annotated[float, TypeKind("Float32")]
+Float64 = Annotated[float, TypeKind("Float64")]
+Range = Annotated[tuple[int, int], TypeKind("Range")]
+Json = Annotated[Any, TypeKind("Json")]
+LocalDateTime = Annotated[datetime.datetime, TypeKind("LocalDateTime")]
+OffsetDateTime = Annotated[datetime.datetime, TypeKind("OffsetDateTime")]
 
 if TYPE_CHECKING:
-    T_co = TypeVar('T_co', covariant=True)
-    Dim_co = TypeVar('Dim_co', bound=int, covariant=True)
+    T_co = TypeVar("T_co", covariant=True)
+    Dim_co = TypeVar("Dim_co", bound=int, covariant=True)
 
-    class Vector(Sequence[T_co], Generic[T_co, Dim_co], Protocol):
+    class Vector(Protocol, Generic[T_co, Dim_co]):
         """Vector[T, Dim] is a special typing alias for a list[T] with optional dimension info"""
+
+        def __getitem__(self, index: int) -> T_co: ...
+        def __len__(self) -> int: ...
+
 else:
+
     class Vector:  # type: ignore[unreachable]
-        """ A special typing alias for a list[T] with optional dimension info """
+        """A special typing alias for a list[T] with optional dimension info"""
+
         def __class_getitem__(self, params):
             if not isinstance(params, tuple):
                 # Only element type provided
@@ -51,40 +72,48 @@ else:
                     dim = typing.get_args(dim)[0]  # Extract the literal value
                 return Annotated[list[elem_type], VectorInfo(dim=dim)]
 
-TABLE_TYPES = ('KTable', 'LTable')
-KEY_FIELD_NAME = '_key'
+
+TABLE_TYPES: tuple[str, str] = ("KTable", "LTable")
+KEY_FIELD_NAME: str = "_key"
 
 ElementType = type | tuple[type, type]
 
-def is_namedtuple_type(t) -> bool:
+
+def is_namedtuple_type(t: type) -> bool:
     return isinstance(t, type) and issubclass(t, tuple) and hasattr(t, "_fields")
 
-def _is_struct_type(t) -> bool:
-    return isinstance(t, type) and (dataclasses.is_dataclass(t) or is_namedtuple_type(t))
+
+def _is_struct_type(t: ElementType | None) -> bool:
+    return isinstance(t, type) and (
+        dataclasses.is_dataclass(t) or is_namedtuple_type(t)
+    )
+
 
 @dataclasses.dataclass
 class AnalyzedTypeInfo:
     """
     Analyzed info of a Python type.
     """
+
     kind: str
     vector_info: VectorInfo | None  # For Vector
-    elem_type: ElementType | None   # For Vector and Table
+    elem_type: ElementType | None  # For Vector and Table
 
-    key_type: type | None           # For element of KTable
-    struct_type: type | None        # For Struct, a dataclass or namedtuple
+    key_type: type | None  # For element of KTable
+    struct_type: type | None  # For Struct, a dataclass or namedtuple
 
     attrs: dict[str, Any] | None
     nullable: bool = False
 
-def analyze_type_info(t) -> AnalyzedTypeInfo:
+
+def analyze_type_info(t: Any) -> AnalyzedTypeInfo:
     """
     Analyze a Python type and return the analyzed info.
     """
     if isinstance(t, tuple) and len(t) == 2:
-        key_type, value_type = t
-        result = analyze_type_info(value_type)
-        result.key_type = key_type
+        kt, vt = t
+        result = analyze_type_info(vt)
+        result.key_type = kt
         return result
 
     annotations: tuple[Annotation, ...] = ()
@@ -97,19 +126,22 @@ def analyze_type_info(t) -> AnalyzedTypeInfo:
             t = t.__origin__
         elif base_type is types.UnionType:
             possible_types = typing.get_args(t)
-            non_none_types = [arg for arg in possible_types if arg not in (None, types.NoneType)]
+            non_none_types = [
+                arg for arg in possible_types if arg not in (None, types.NoneType)
+            ]
             if len(non_none_types) != 1:
                 raise ValueError(
-                    f"Expect exactly one non-None choice for Union type, but got {len(non_none_types)}: {t}")
+                    f"Expect exactly one non-None choice for Union type, but got {len(non_none_types)}: {t}"
+                )
             t = non_none_types[0]
             if len(possible_types) > 1:
                 nullable = True
         else:
             break
 
-    attrs = None
-    vector_info = None
-    kind = None
+    attrs: dict[str, Any] | None = None
+    vector_info: VectorInfo | None = None
+    kind: str | None = None
     for attr in annotations:
         if isinstance(attr, TypeAttr):
             if attrs is None:
@@ -120,15 +152,15 @@ def analyze_type_info(t) -> AnalyzedTypeInfo:
         elif isinstance(attr, TypeKind):
             kind = attr.kind
 
-    struct_type = None
-    elem_type = None
-    key_type = None
+    struct_type: type | None = None
+    elem_type: ElementType | None = None
+    key_type: type | None = None
     if _is_struct_type(t):
         struct_type = t
 
         if kind is None:
-            kind = 'Struct'
-        elif kind != 'Struct':
+            kind = "Struct"
+        elif kind != "Struct":
             raise ValueError(f"Unexpected type kind for struct: {kind}")
     elif base_type is collections.abc.Sequence or base_type is list:
         args = typing.get_args(t)
@@ -136,40 +168,42 @@ def analyze_type_info(t) -> AnalyzedTypeInfo:
 
         if kind is None:
             if _is_struct_type(elem_type):
-                kind = 'LTable'
+                kind = "LTable"
                 if vector_info is not None:
-                    raise ValueError("Vector element must be a simple type, not a struct")
+                    raise ValueError(
+                        "Vector element must be a simple type, not a struct"
+                    )
             else:
-                kind = 'Vector'
+                kind = "Vector"
                 if vector_info is None:
                     vector_info = VectorInfo(dim=None)
-        elif not (kind == 'Vector' or kind in TABLE_TYPES):
+        elif not (kind == "Vector" or kind in TABLE_TYPES):
             raise ValueError(f"Unexpected type kind for list: {kind}")
     elif base_type is collections.abc.Mapping or base_type is dict:
         args = typing.get_args(t)
         elem_type = (args[0], args[1])
-        kind = 'KTable'
+        kind = "KTable"
     elif kind is None:
         if t is bytes:
-            kind = 'Bytes'
+            kind = "Bytes"
         elif t is str:
-            kind = 'Str'
+            kind = "Str"
         elif t is bool:
-            kind = 'Bool'
+            kind = "Bool"
         elif t is int:
-            kind = 'Int64'
+            kind = "Int64"
         elif t is float:
-            kind = 'Float64'
+            kind = "Float64"
         elif t is uuid.UUID:
-            kind = 'Uuid'
+            kind = "Uuid"
         elif t is datetime.date:
-            kind = 'Date'
+            kind = "Date"
         elif t is datetime.time:
-            kind = 'Time'
+            kind = "Time"
         elif t is datetime.datetime:
-            kind = 'OffsetDateTime'
+            kind = "OffsetDateTime"
         elif t is datetime.timedelta:
-            kind = 'TimeDelta'
+            kind = "TimeDelta"
         else:
             raise ValueError(f"type unsupported yet: {t}")
 
@@ -183,9 +217,13 @@ def analyze_type_info(t) -> AnalyzedTypeInfo:
         nullable=nullable,
     )
 
-def _encode_fields_schema(struct_type: type, key_type: type | None = None) -> list[dict[str, Any]]:
+
+def _encode_fields_schema(
+    struct_type: type, key_type: type | None = None
+) -> list[dict[str, Any]]:
     result = []
-    def add_field(name: str, t) -> None:
+
+    def add_field(name: str, t: Any) -> None:
         try:
             type_info = encode_enriched_type_info(analyze_type_info(t))
         except ValueError as e:
@@ -194,7 +232,7 @@ def _encode_fields_schema(struct_type: type, key_type: type | None = None) -> li
                 f"{struct_type.__name__}.{name}: {t}"
             )
             raise
-        type_info['name'] = name
+        type_info["name"] = name
         result.append(type_info)
 
     if key_type is not None:
@@ -209,55 +247,62 @@ def _encode_fields_schema(struct_type: type, key_type: type | None = None) -> li
 
     return result
 
+
 def _encode_type(type_info: AnalyzedTypeInfo) -> dict[str, Any]:
-    encoded_type: dict[str, Any] = { 'kind': type_info.kind }
+    encoded_type: dict[str, Any] = {"kind": type_info.kind}
 
-    if type_info.kind == 'Struct':
+    if type_info.kind == "Struct":
         if type_info.struct_type is None:
             raise ValueError("Struct type must have a dataclass or namedtuple type")
-        encoded_type['fields'] = _encode_fields_schema(type_info.struct_type, type_info.key_type)
+        encoded_type["fields"] = _encode_fields_schema(
+            type_info.struct_type, type_info.key_type
+        )
         if doc := inspect.getdoc(type_info.struct_type):
-            encoded_type['description'] = doc
+            encoded_type["description"] = doc
 
-    elif type_info.kind == 'Vector':
+    elif type_info.kind == "Vector":
         if type_info.vector_info is None:
             raise ValueError("Vector type must have a vector info")
         if type_info.elem_type is None:
             raise ValueError("Vector type must have an element type")
-        encoded_type['element_type'] = _encode_type(analyze_type_info(type_info.elem_type))
-        encoded_type['dimension'] = type_info.vector_info.dim
+        encoded_type["element_type"] = _encode_type(
+            analyze_type_info(type_info.elem_type)
+        )
+        encoded_type["dimension"] = type_info.vector_info.dim
 
     elif type_info.kind in TABLE_TYPES:
         if type_info.elem_type is None:
             raise ValueError(f"{type_info.kind} type must have an element type")
         row_type_info = analyze_type_info(type_info.elem_type)
-        encoded_type['row'] = _encode_type(row_type_info)
+        encoded_type["row"] = _encode_type(row_type_info)
 
     return encoded_type
 
+
 def encode_enriched_type_info(enriched_type_info: AnalyzedTypeInfo) -> dict[str, Any]:
     """
     Encode an enriched type info to a CocoIndex engine's type representation
     """
-    encoded: dict[str, Any] = {'type': _encode_type(enriched_type_info)}
+    encoded: dict[str, Any] = {"type": _encode_type(enriched_type_info)}
 
     if enriched_type_info.attrs is not None:
-        encoded['attrs'] = enriched_type_info.attrs
+        encoded["attrs"] = enriched_type_info.attrs
 
     if enriched_type_info.nullable:
-        encoded['nullable'] = True
+        encoded["nullable"] = True
 
     return encoded
 
+
 @overload
-def encode_enriched_type(t: None) -> None:
-    ...
+def encode_enriched_type(t: None) -> None: ...
+
 
 @overload
-def encode_enriched_type(t: Any) -> dict[str, Any]:
-    ...
+def encode_enriched_type(t: Any) -> dict[str, Any]: ...
 
-def encode_enriched_type(t) -> dict[str, Any] | None:
+
+def encode_enriched_type(t: Any) -> dict[str, Any] | None:
     """
     Convert a Python type to a CocoIndex engine's type representation
     """
@@ -266,7 +311,8 @@ def encode_enriched_type(t) -> dict[str, Any] | None:
 
     return encode_enriched_type_info(analyze_type_info(t))
 
-def resolve_forward_ref(t):
-    if t is str:
-        return eval(t) # pylint: disable=eval-used
+
+def resolve_forward_ref(t: Any) -> Any:
+    if isinstance(t, str):
+        return eval(t)  # pylint: disable=eval-used
     return t

cocoindex/utils.py

@@ -1,9 +1,17 @@
 from .flow import Flow
 from .setting import get_app_namespace
 
-def get_target_storage_default_name(flow: Flow, target_name: str, delimiter: str = "__") -> str:
+
+def get_target_storage_default_name(
+    flow: Flow, target_name: str, delimiter: str = "__"
+) -> str:
     """
     Get the default name for a target.
     It's used as the underlying storage name (e.g. a table, a collection, etc.) followed by most storage backends, if not explicitly specified.
     """
-    return get_app_namespace(trailing_delimiter=delimiter) + flow.name + delimiter + target_name
+    return (
+        get_app_namespace(trailing_delimiter=delimiter)
+        + flow.name
+        + delimiter
+        + target_name
+    )

{cocoindex-0.1.43.dist-info → cocoindex-0.1.45.dist-info}/METADATA

@@ -1,12 +1,14 @@
 Metadata-Version: 2.4
 Name: cocoindex
-Version: 0.1.43
+Version: 0.1.45
 Requires-Dist: sentence-transformers>=3.3.1
 Requires-Dist: click>=8.1.8
 Requires-Dist: rich>=14.0.0
 Requires-Dist: python-dotenv>=1.1.0
 Requires-Dist: pytest ; extra == 'test'
+Requires-Dist: ruff ; extra == 'dev'
 Provides-Extra: test
+Provides-Extra: dev
 License-File: LICENSE
 Summary: With CocoIndex, users declare the transformation, CocoIndex creates & maintains an index, and keeps the derived index up to date based on source update, with minimal computation and changes.
 Author-email: CocoIndex <cocoindex.io@gmail.com>

cocoindex-0.1.45.dist-info/RECORD

@@ -0,0 +1,27 @@
+cocoindex-0.1.45.dist-info/METADATA,sha256=P5VaQGACoY6m-WQesaWvt5r3bIyolevTxnuCLtJqomY,9875
+cocoindex-0.1.45.dist-info/WHEEL,sha256=p_tvkyHH2UmMBrR2Gemb1ahXJMM2SXUIsCLrWZgJvB8,104
+cocoindex-0.1.45.dist-info/entry_points.txt,sha256=_NretjYVzBdNTn7dK-zgwr7YfG2afz1u1uSE-5bZXF8,46
+cocoindex-0.1.45.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+cocoindex/__init__.py,sha256=TkfOR-7upXpzETEvBQUhcnYVuI_A3sqjOdXYeTPAwO0,818
+cocoindex/_engine.cpython-311-darwin.so,sha256=Es24pgfBaRIMVjOUSa1AeJEXf19cCJB9M3uQRqaXLwY,57128576
+cocoindex/auth_registry.py,sha256=1XqO7ibjmBBd8i11XSJTvTgdz8p1ptW-ZpuSgo_5zzk,716
+cocoindex/cli.py,sha256=p92s-Ya6VpT4EY5xfbl-R0yyIJv8ySK-2eyxnwC8KqA,17853
+cocoindex/convert.py,sha256=CfsZDRs1kwMeNCeJ3-gifHQm_9GzyqySpUmZyCyWXMo,7316
+cocoindex/flow.py,sha256=sC7eg0L9MkZuo7MlvGA4eYe-mEReIyPjKIILFtkWm-Y,30017
+cocoindex/functions.py,sha256=rjULmc14tL8-eU-tSmgyc867C_nySS2hktyj8NgofI8,1972
+cocoindex/index.py,sha256=j93B9jEvvLXHtpzKWL88SY6wCGEoPgpsQhEGHlyYGFg,540
+cocoindex/lib.py,sha256=W3hPh0QQIjLRRe2tpyLCvL_6ajzXhGGSNJubikkS27s,2985
+cocoindex/llm.py,sha256=KO-R4mrAWtxXD82-Yv5ixpkKMVfkwpbdWwqPVZygLu4,352
+cocoindex/op.py,sha256=hOJoHC8elhLHMNVRTGTBWNSK5uYrQb-FfRV-qt08j8g,11815
+cocoindex/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cocoindex/query.py,sha256=UswtEp0wZwwNPeR9x9lRokFpNNZOHkyt5tYfCmGIWWU,3450
+cocoindex/runtime.py,sha256=bAdHYaXFWiiUWyAgzmKTeaAaRR0D_AmaqVCIdPO-v00,1056
+cocoindex/setting.py,sha256=ePqHw1i95rVtqYYRVqzVwtBifRO4SfH1rlMW_AG3Zek,3418
+cocoindex/setup.py,sha256=u5dYZFKfz4yZLiGHD0guNaR0s4zY9JAoZWrWHpAHw_0,773
+cocoindex/sources.py,sha256=JCnOhv1w4o28e03i7yvo4ESicWYAhckkBg5bQlxNH4U,1330
+cocoindex/storages.py,sha256=RCS1YrtSIKjkWX5JHF38hK85SNn5BhsRU1gqyzbHn30,2688
+cocoindex/tests/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+cocoindex/tests/test_convert.py,sha256=tTsDveMCgflhcYmDq-fQq3MRGAmN2xlbtFIEDYlRpGw,17095
+cocoindex/typing.py,sha256=0WQ4F04kFhXwHphv9AHJqc1cThYmLe27eqqGEuGWHAU,9462
+cocoindex/utils.py,sha256=5a3ubVzDowJUJyUl8ecd75Th_OzON3G-MV2vXf0dQSk,503
+cocoindex-0.1.45.dist-info/RECORD,,

cocoindex-0.1.43.dist-info/RECORD

@@ -1,27 +0,0 @@
-cocoindex-0.1.43.dist-info/METADATA,sha256=2n3yADdVbrbv-m-x7qtZX8l8D_2h37MEP2tY5OqTyBo,9818
-cocoindex-0.1.43.dist-info/WHEEL,sha256=p_tvkyHH2UmMBrR2Gemb1ahXJMM2SXUIsCLrWZgJvB8,104
-cocoindex-0.1.43.dist-info/entry_points.txt,sha256=_NretjYVzBdNTn7dK-zgwr7YfG2afz1u1uSE-5bZXF8,46
-cocoindex-0.1.43.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-cocoindex/__init__.py,sha256=ztuMoVHbGsyhgnN_CHBnY4yQtcsHi4O-u-Q3eUFaB5Y,816
-cocoindex/_engine.cpython-311-darwin.so,sha256=yTewruRgB6wQCP00OjCDNCILMVk0dEInGPHF3jhCrRg,56886416
-cocoindex/auth_registry.py,sha256=NsALZ3SKsDG9cPdrlTlalIqUvgbgFOaFGAbWJNedtJE,692
-cocoindex/cli.py,sha256=Gbn6vz37Gi5ckZYdRdJkcbNcokLbtDhH9wrZswISeRc,16554
-cocoindex/convert.py,sha256=75HSBie7DokM0RJyUBqeveZRl5y_Fl8lzByoRF0yb2M,6915
-cocoindex/flow.py,sha256=0otFFqO8XVv-uc1Qbya9BBCK1orv7CGI52TiB5v63xk,28409
-cocoindex/functions.py,sha256=F79dNmGE127LaU67kF5Oqtf_tIzebFQH7MkyceMX4-s,1830
-cocoindex/index.py,sha256=LssEOuZi6AqhwKtZM3QFeQpa9T-0ELi8G5DsrYKECvc,534
-cocoindex/lib.py,sha256=JiLIV5Fi-FNKMlH-6JMoe-UQsvirnFkkOLcoEQk9WkE,2903
-cocoindex/llm.py,sha256=_3rtahuKcqcEHPkFSwhXOSrekZyGxVApPoYtlU_chcA,348
-cocoindex/op.py,sha256=yyB3gYYj6uIeoGW9FXuj9Ludaz50QYDeqGgi3dKG1_I,10739
-cocoindex/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cocoindex/query.py,sha256=As-6xIEyr27dN8txF9CsCA9KeL6lyKR7bU6PW4RMBl0,3205
-cocoindex/runtime.py,sha256=jqRnWkkIlAhE04gi4y0Y5bzuq9FX4j0aVNU-nengLJk,980
-cocoindex/setting.py,sha256=5sywzYWnUNv80lNDwFlkFkUOoW0wo4n4DEuhFZxryxA,3265
-cocoindex/setup.py,sha256=ErNtX08NfFOFKehp5qGUvCx8Wiz9f3gmzvfBhAqrQyI,745
-cocoindex/sources.py,sha256=7lpwYLsFCRfbURKf79Vu0JZZoXjAYY0DxNHzUb-VHBY,1327
-cocoindex/storages.py,sha256=MFMsfyOCYMggTWeWrOi82miqOXQmiUuqq828x5htBr0,2207
-cocoindex/tests/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-cocoindex/tests/test_convert.py,sha256=7jc--I3frrg7DB5MPr4JFzE7DSCznJuWyHdlDLQJ_fM,15516
-cocoindex/typing.py,sha256=RMJXdey5_vd7JbPTEdUw1DeQ4Uu4MicdiaXjzQHFNRA,9031
-cocoindex/utils.py,sha256=eClhMdjBjcXaDkah-rPUmE7Y5Ncd7S1goUe2qTETR08,456
-cocoindex-0.1.43.dist-info/RECORD,,