cocoindex 0.2.10__cp311-abi3-win_amd64.whl → 0.2.12__cp311-abi3-win_amd64.whl

cocoindex/tests/test_load_convert.py

@@ -0,0 +1,118 @@
+import dataclasses
+import datetime
+from typing import TypedDict, NamedTuple
+
+import numpy as np
+from numpy.typing import NDArray
+
+from cocoindex.convert import dump_engine_object, load_engine_object
+
+
+@dataclasses.dataclass
+class LocalTargetFieldMapping:
+    source: str
+    target: str | None = None
+
+
+@dataclasses.dataclass
+class LocalNodeFromFields:
+    label: str
+    fields: list[LocalTargetFieldMapping]
+
+
+@dataclasses.dataclass
+class LocalNodes:
+    kind = "Node"
+    label: str
+
+
+@dataclasses.dataclass
+class LocalRelationships:
+    kind = "Relationship"
+    rel_type: str
+    source: LocalNodeFromFields
+    target: LocalNodeFromFields
+
+
+class LocalPoint(NamedTuple):
+    x: int
+    y: int
+
+
+class UserInfo(TypedDict):
+    id: str
+    age: int
+
+
+def test_timedelta_roundtrip_via_dump_load() -> None:
+    td = datetime.timedelta(days=1, hours=2, minutes=3, seconds=4, microseconds=500)
+    dumped = dump_engine_object(td)
+    loaded = load_engine_object(datetime.timedelta, dumped)
+    assert isinstance(loaded, datetime.timedelta)
+    assert loaded == td
+
+
+def test_ndarray_roundtrip_via_dump_load() -> None:
+    value: NDArray[np.float32] = np.array([1.0, 2.0, 3.0], dtype=np.float32)
+    dumped = dump_engine_object(value)
+    assert dumped == [1.0, 2.0, 3.0]
+    loaded = load_engine_object(NDArray[np.float32], dumped)
+    assert isinstance(loaded, np.ndarray)
+    assert loaded.dtype == np.float32
+    assert np.array_equal(loaded, value)
+
+
+def test_nodes_kind_is_carried() -> None:
+    node = LocalNodes(label="User")
+    dumped = dump_engine_object(node)
+    # dumped should include discriminator
+    assert dumped.get("kind") == "Node"
+    # load back
+    loaded = load_engine_object(LocalNodes, dumped)
+    assert isinstance(loaded, LocalNodes)
+    # class-level attribute is preserved
+    assert getattr(loaded, "kind", None) == "Node"
+    assert loaded.label == "User"
+
+
+def test_relationships_union_discriminator() -> None:
+    rel = LocalRelationships(
+        rel_type="LIKES",
+        source=LocalNodeFromFields(
+            label="User", fields=[LocalTargetFieldMapping("id")]
+        ),
+        target=LocalNodeFromFields(
+            label="Item", fields=[LocalTargetFieldMapping("id")]
+        ),
+    )
+    dumped = dump_engine_object(rel)
+    assert dumped.get("kind") == "Relationship"
+    loaded = load_engine_object(LocalNodes | LocalRelationships, dumped)
+    assert isinstance(loaded, LocalRelationships)
+    assert getattr(loaded, "kind", None) == "Relationship"
+    assert loaded.rel_type == "LIKES"
+    assert dataclasses.asdict(loaded.source) == {
+        "label": "User",
+        "fields": [{"source": "id", "target": None}],
+    }
+    assert dataclasses.asdict(loaded.target) == {
+        "label": "Item",
+        "fields": [{"source": "id", "target": None}],
+    }
+
+
+def test_typed_dict_roundtrip_via_dump_load() -> None:
+    user: UserInfo = {"id": "u1", "age": 30}
+    dumped = dump_engine_object(user)
+    assert dumped == {"id": "u1", "age": 30}
+    loaded = load_engine_object(UserInfo, dumped)
+    assert loaded == user
+
+
+def test_namedtuple_roundtrip_via_dump_load() -> None:
+    p = LocalPoint(1, 2)
+    dumped = dump_engine_object(p)
+    assert dumped == {"x": 1, "y": 2}
+    loaded = load_engine_object(LocalPoint, dumped)
+    assert isinstance(loaded, LocalPoint)
+    assert loaded == p

cocoindex/tests/test_typing.py

@@ -5,7 +5,6 @@ from collections.abc import Mapping, Sequence
 from typing import Annotated, Any, Literal, NamedTuple, get_args, get_origin
 
 import numpy as np
-import pytest
 from numpy.typing import NDArray
 
 from cocoindex.typing import (
@@ -20,7 +19,10 @@ from cocoindex.typing import (
     Vector,
     VectorInfo,
     analyze_type_info,
+    decode_engine_value_type,
     encode_enriched_type,
+    encode_enriched_type_info,
+    encode_engine_value_type,
 )
 
 
@@ -32,7 +34,7 @@ class SimpleDataclass:
 
 class SimpleNamedTuple(NamedTuple):
     name: str
-    value: Any
+    value: int
 
 
 def test_ndarray_float32_no_dim() -> None:
@@ -427,3 +429,125 @@ def test_unknown_type() -> None:
     typ = set
     result = analyze_type_info(typ)
     assert isinstance(result.variant, AnalyzedUnknownType)
+
+
+# ========================= Encode/Decode Tests =========================
+
+
+def encode_type_from_annotation(t: Any) -> dict[str, Any]:
+    """Helper function to encode a Python type annotation to its dictionary representation."""
+    return encode_enriched_type_info(analyze_type_info(t))
+
+
+def test_basic_types_encode_decode() -> None:
+    """Test encode/decode roundtrip for basic Python types."""
+    test_cases = [
+        str,
+        int,
+        float,
+        bool,
+        bytes,
+        uuid.UUID,
+        datetime.date,
+        datetime.time,
+        datetime.datetime,
+        datetime.timedelta,
+    ]
+
+    for typ in test_cases:
+        encoded = encode_type_from_annotation(typ)
+        decoded = decode_engine_value_type(encoded["type"])
+        reencoded = encode_engine_value_type(decoded)
+        assert reencoded == encoded["type"]
+
+
+def test_vector_types_encode_decode() -> None:
+    """Test encode/decode roundtrip for vector types."""
+    test_cases = [
+        NDArray[np.float32],
+        NDArray[np.float64],
+        NDArray[np.int64],
+        Vector[np.float32],
+        Vector[np.float32, Literal[128]],
+        Vector[str],
+    ]
+
+    for typ in test_cases:
+        encoded = encode_type_from_annotation(typ)
+        decoded = decode_engine_value_type(encoded["type"])
+        reencoded = encode_engine_value_type(decoded)
+        assert reencoded == encoded["type"]
+
+
+def test_struct_types_encode_decode() -> None:
+    """Test encode/decode roundtrip for struct types."""
+    test_cases = [
+        SimpleDataclass,
+        SimpleNamedTuple,
+    ]
+
+    for typ in test_cases:
+        encoded = encode_type_from_annotation(typ)
+        decoded = decode_engine_value_type(encoded["type"])
+        reencoded = encode_engine_value_type(decoded)
+        assert reencoded == encoded["type"]
+
+
+def test_table_types_encode_decode() -> None:
+    """Test encode/decode roundtrip for table types."""
+    test_cases = [
+        list[SimpleDataclass],  # LTable
+        dict[str, SimpleDataclass],  # KTable
+    ]
+
+    for typ in test_cases:
+        encoded = encode_type_from_annotation(typ)
+        decoded = decode_engine_value_type(encoded["type"])
+        reencoded = encode_engine_value_type(decoded)
+        assert reencoded == encoded["type"]
+
+
+def test_nullable_types_encode_decode() -> None:
+    """Test encode/decode roundtrip for nullable types."""
+    test_cases = [
+        str | None,
+        int | None,
+        NDArray[np.float32] | None,
+    ]
+
+    for typ in test_cases:
+        encoded = encode_type_from_annotation(typ)
+        decoded = decode_engine_value_type(encoded["type"])
+        reencoded = encode_engine_value_type(decoded)
+        assert reencoded == encoded["type"]
+
+
+def test_annotated_types_encode_decode() -> None:
+    """Test encode/decode roundtrip for annotated types."""
+    test_cases = [
+        Annotated[str, TypeAttr("key", "value")],
+        Annotated[NDArray[np.float32], VectorInfo(dim=256)],
+        Annotated[list[int], VectorInfo(dim=10)],
+    ]
+
+    for typ in test_cases:
+        encoded = encode_type_from_annotation(typ)
+        decoded = decode_engine_value_type(encoded["type"])
+        reencoded = encode_engine_value_type(decoded)
+        assert reencoded == encoded["type"]
+
+
+def test_complex_nested_encode_decode() -> None:
+    """Test complex nested structure encode/decode roundtrip."""
+
+    # Create a complex nested structure using Python type annotations
+    @dataclasses.dataclass
+    class ComplexStruct:
+        embedding: NDArray[np.float32]
+        metadata: str | None
+        score: Annotated[float, TypeAttr("indexed", True)]
+
+    encoded = encode_type_from_annotation(ComplexStruct)
+    decoded = decode_engine_value_type(encoded["type"])
+    reencoded = encode_engine_value_type(decoded)
+    assert reencoded == encoded["type"]

cocoindex/typing.py

@@ -15,6 +15,7 @@ from typing import (
     Protocol,
     TypeVar,
     overload,
+    Self,
 )
 
 import numpy as np
@@ -471,3 +472,209 @@ def resolve_forward_ref(t: Any) -> Any:
     if isinstance(t, str):
         return eval(t)  # pylint: disable=eval-used
     return t
+
+
+# ========================= Engine Schema Types (Python mirror of Rust) =========================
+
+
+@dataclasses.dataclass
+class VectorTypeSchema:
+    element_type: "BasicValueType"
+    dimension: int | None
+
+    @staticmethod
+    def decode(obj: dict[str, Any]) -> "VectorTypeSchema":
+        return VectorTypeSchema(
+            element_type=BasicValueType.decode(obj["element_type"]),
+            dimension=obj.get("dimension"),
+        )
+
+    def encode(self) -> dict[str, Any]:
+        return {
+            "element_type": self.element_type.encode(),
+            "dimension": self.dimension,
+        }
+
+
+@dataclasses.dataclass
+class UnionTypeSchema:
+    variants: list["BasicValueType"]
+
+    @staticmethod
+    def decode(obj: dict[str, Any]) -> "UnionTypeSchema":
+        return UnionTypeSchema(
+            variants=[BasicValueType.decode(t) for t in obj["types"]]
+        )
+
+    def encode(self) -> dict[str, Any]:
+        return {"types": [variant.encode() for variant in self.variants]}
+
+
+@dataclasses.dataclass
+class BasicValueType:
+    """
+    Mirror of Rust BasicValueType in JSON form.
+
+    For Vector and Union kinds, extra fields are populated accordingly.
+    """
+
+    kind: Literal[
+        "Bytes",
+        "Str",
+        "Bool",
+        "Int64",
+        "Float32",
+        "Float64",
+        "Range",
+        "Uuid",
+        "Date",
+        "Time",
+        "LocalDateTime",
+        "OffsetDateTime",
+        "TimeDelta",
+        "Json",
+        "Vector",
+        "Union",
+    ]
+    vector: VectorTypeSchema | None = None
+    union: UnionTypeSchema | None = None
+
+    @staticmethod
+    def decode(obj: dict[str, Any]) -> "BasicValueType":
+        kind = obj["kind"]
+        if kind == "Vector":
+            return BasicValueType(
+                kind=kind,  # type: ignore[arg-type]
+                vector=VectorTypeSchema.decode(obj),
+            )
+        if kind == "Union":
+            return BasicValueType(
+                kind=kind,  # type: ignore[arg-type]
+                union=UnionTypeSchema.decode(obj),
+            )
+        return BasicValueType(kind=kind)  # type: ignore[arg-type]
+
+    def encode(self) -> dict[str, Any]:
+        result = {"kind": self.kind}
+        if self.kind == "Vector" and self.vector is not None:
+            result.update(self.vector.encode())
+        elif self.kind == "Union" and self.union is not None:
+            result.update(self.union.encode())
+        return result
+
+
+@dataclasses.dataclass
+class EnrichedValueType:
+    type: "ValueType"
+    nullable: bool = False
+    attrs: dict[str, Any] | None = None
+
+    @staticmethod
+    def decode(obj: dict[str, Any]) -> "EnrichedValueType":
+        return EnrichedValueType(
+            type=decode_engine_value_type(obj["type"]),
+            nullable=obj.get("nullable", False),
+            attrs=obj.get("attrs"),
+        )
+
+    def encode(self) -> dict[str, Any]:
+        result: dict[str, Any] = {"type": self.type.encode()}
+        if self.nullable:
+            result["nullable"] = True
+        if self.attrs is not None:
+            result["attrs"] = self.attrs
+        return result
+
+
+@dataclasses.dataclass
+class FieldSchema:
+    name: str
+    value_type: EnrichedValueType
+
+    @staticmethod
+    def decode(obj: dict[str, Any]) -> "FieldSchema":
+        return FieldSchema(name=obj["name"], value_type=EnrichedValueType.decode(obj))
+
+    def encode(self) -> dict[str, Any]:
+        result = self.value_type.encode()
+        result["name"] = self.name
+        return result
+
+
+@dataclasses.dataclass
+class StructSchema:
+    fields: list[FieldSchema]
+    description: str | None = None
+
+    @classmethod
+    def decode(cls, obj: dict[str, Any]) -> Self:
+        return cls(
+            fields=[FieldSchema.decode(f) for f in obj["fields"]],
+            description=obj.get("description"),
+        )
+
+    def encode(self) -> dict[str, Any]:
+        result: dict[str, Any] = {"fields": [field.encode() for field in self.fields]}
+        if self.description is not None:
+            result["description"] = self.description
+        return result
+
+
+@dataclasses.dataclass
+class StructType(StructSchema):
+    kind: Literal["Struct"] = "Struct"
+
+    def encode(self) -> dict[str, Any]:
+        result = super().encode()
+        result["kind"] = self.kind
+        return result
+
+
+@dataclasses.dataclass
+class TableType:
+    kind: Literal["KTable", "LTable"]
+    row: StructSchema
+    num_key_parts: int | None = None  # Only for KTable
+
+    @staticmethod
+    def decode(obj: dict[str, Any]) -> "TableType":
+        row_obj = obj["row"]
+        row = StructSchema(
+            fields=[FieldSchema.decode(f) for f in row_obj["fields"]],
+            description=row_obj.get("description"),
+        )
+        return TableType(
+            kind=obj["kind"],  # type: ignore[arg-type]
+            row=row,
+            num_key_parts=obj.get("num_key_parts"),
+        )
+
+    def encode(self) -> dict[str, Any]:
+        result: dict[str, Any] = {"kind": self.kind, "row": self.row.encode()}
+        if self.num_key_parts is not None:
+            result["num_key_parts"] = self.num_key_parts
+        return result
+
+
+ValueType = BasicValueType | StructType | TableType
+
+
+def decode_engine_field_schemas(objs: list[dict[str, Any]]) -> list[FieldSchema]:
+    return [FieldSchema.decode(o) for o in objs]
+
+
+def decode_engine_value_type(obj: dict[str, Any]) -> ValueType:
+    kind = obj["kind"]
+    if kind == "Struct":
+        return StructType.decode(obj)
+
+    if kind in TABLE_TYPES:
+        return TableType.decode(obj)
+
+    # Otherwise it's a basic value
+    return BasicValueType.decode(obj)
+
+
+def encode_engine_value_type(value_type: ValueType) -> dict[str, Any]:
+    """Encode a ValueType to its dictionary representation."""
+    return value_type.encode()

{cocoindex-0.2.10.dist-info → cocoindex-0.2.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cocoindex
-Version: 0.2.10
+Version: 0.2.12
 Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
@@ -29,11 +29,14 @@ Requires-Dist: mypy ; extra == 'dev'
 Requires-Dist: pre-commit ; extra == 'dev'
 Requires-Dist: sentence-transformers>=3.3.1 ; extra == 'embeddings'
 Requires-Dist: colpali-engine ; extra == 'colpali'
+Requires-Dist: lancedb>=0.25.0 ; extra == 'lancedb'
 Requires-Dist: sentence-transformers>=3.3.1 ; extra == 'all'
 Requires-Dist: colpali-engine ; extra == 'all'
+Requires-Dist: lancedb>=0.25.0 ; extra == 'all'
 Provides-Extra: dev
 Provides-Extra: embeddings
 Provides-Extra: colpali
+Provides-Extra: lancedb
 Provides-Extra: all
 License-File: THIRD_PARTY_NOTICES.html
 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.

cocoindex-0.2.12.dist-info/RECORD

@@ -0,0 +1,37 @@
+cocoindex-0.2.12.dist-info/METADATA,sha256=hBfaSdpKdDII6yXbSOwRMgo0rOBBHD3T0QCGC_vQ0Jk,13339
+cocoindex-0.2.12.dist-info/WHEEL,sha256=8hEf8NzM1FnmM77AjVt5h8nDuYkN3UqZ79LoIAHXeRE,95
+cocoindex-0.2.12.dist-info/entry_points.txt,sha256=_NretjYVzBdNTn7dK-zgwr7YfG2afz1u1uSE-5bZXF8,46
+cocoindex-0.2.12.dist-info/licenses/THIRD_PARTY_NOTICES.html,sha256=YC54G1cI3WNqex30C-fCKHC_BXqXMt614D2fvXRtQtg,717804
+cocoindex/__init__.py,sha256=7FXm4Q_I_aLgVxY2nd5PTWQ6Z92mTjJ1B5WxTHpj6p8,2531
+cocoindex/_engine.pyd,sha256=ee-0w-kwBCzfsHQw7aq4og78MURgfcjtvbX-0C-sIEs,73064448
+cocoindex/auth_registry.py,sha256=Rl2L3W9BHuJ5bZF2f1el-nRuhRpYz7_5F4gI7EF-jGI,1378
+cocoindex/cli.py,sha256=Wt8wUjWqHEBoR3gDnHqIplLaL_tbStMCHAOuYhYq84A,22338
+cocoindex/convert.py,sha256=sr4jvCkqn_L-Jo_O-GzinfhFD7eFvrd_DpqwPRA65Mc,29474
+cocoindex/flow.py,sha256=X1rm2LGJpUlVWW4bRSOpEkeM9G8wkYHkK4bp5jhI_O4,41118
+cocoindex/functions.py,sha256=CtiwTVW6g4BtO5_EvVcij7Si4Bx-axnM1hsdU43aM4g,12617
+cocoindex/index.py,sha256=GrqTm1rLwICQ8hadtNvJAxVg7GWMvtMmFcbiNtNzmP0,569
+cocoindex/lib.py,sha256=-Ys4a7BdDOW_ctz9vEBA5fSOqwsY_IKLHxaDwxvoXRg,2359
+cocoindex/llm.py,sha256=JM5EPup7FZojynCI0rg4gnMBYmdPZpaHJbVBz3f7BAI,897
+cocoindex/op.py,sha256=34PnWY2I5WRxN8S4IOLjV0QZZyVxK0yyYTAKHu64He8,27295
+cocoindex/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cocoindex/query_handler.py,sha256=iC4_j0yiQrW1izHDJUgaQyNrTpyfTvYIOwoshYNclKk,1243
+cocoindex/runtime.py,sha256=ZjyPmohIWGFDRaOdS0MgeVuf4Ra2Ggbp6xraxwvHFBo,1386
+cocoindex/setting.py,sha256=oohs7H52_h1AulDcp96cS9SVAAm_uFaQyJYog9EvCj0,5131
+cocoindex/setup.py,sha256=KbJvmeFu0NbeoH-5iDmHZP86f26HIId8kHmGUNZAePI,3160
+cocoindex/sources.py,sha256=Ij8LyYbM49zjPg-pJHMbas8sdLquEcgvmuYfv7wCdjI,3290
+cocoindex/subprocess_exec.py,sha256=u_kF4C8dToPg-9a7NeFroR8pJCOFag_NT0icLe184QQ,10391
+cocoindex/targets/__init__.py,sha256=6cO57jLhBloC1o-sBHG6OXfIgBdRQtz5RDi6FLqlQhU,83
+cocoindex/targets/_engine_builtin_specs.py,sha256=GJnKTP55A-GIMc2Z-Lhr_hE6vvsv6Iw-9cdz40qjAkU,2935
+cocoindex/targets/lancedb.py,sha256=lu9FFSq8sDXudyYxyoHfJ7AKSzaruA6zXUnIhgoBgnU,15900
+cocoindex/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cocoindex/tests/test_convert.py,sha256=Gk44bHNr639c8QzVY1ctCyL5PmnfvQwAi7dgM8Xujrk,52359
+cocoindex/tests/test_load_convert.py,sha256=WU7euC7bes3R_a4tcOkzRbdzb36Ef5JK1-2ZlFF_uWs,3457
+cocoindex/tests/test_optional_database.py,sha256=dnzmTgaJf37D3q8fQsjP5UDER6FYETaUokDnFBMLtIk,8755
+cocoindex/tests/test_transform_flow.py,sha256=DxM-7_kWeU-QzOpH77Vd5Jehbbq00xCBBgRK7mRn0kI,6237
+cocoindex/tests/test_typing.py,sha256=d75mjzAk9dDklC3llwSfPJI91d9GO_6WsgYwELGIPso,16844
+cocoindex/tests/test_validation.py,sha256=I4wr8lAMAjmy5xgG5N_OJKveXt8XIa96MsQTXhw5AnA,4677
+cocoindex/typing.py,sha256=ezjTozTH64ehqYWp00JWOsP3D-ytEFD4UE5WKUUPkOU,20654
+cocoindex/user_app_loader.py,sha256=ZkvUG9aJNNECAjwTY0ZYtNpFd9dNBPVoPKGTtB7dSZg,1926
+cocoindex/utils.py,sha256=U3W39zD2uZpXX8v84tJD7sRmbC5ar3z_ljAP1cJrYXI,618
+cocoindex/validation.py,sha256=4ZjsW-SZT8X_TEEhEE6QG6D-8Oq_TkPAhTqP0mdFYSE,3194
+cocoindex-0.2.12.dist-info/RECORD,,

{cocoindex-0.2.10.dist-info → cocoindex-0.2.12.dist-info}/licenses/THIRD_PARTY_NOTICES.html

@@ -2428,7 +2428,7 @@ Software.
                 <h3 id="Apache-2.0">Apache License 2.0</h3>
                 <h4>Used by:</h4>
                 <ul class="license-used-by">
-                    <li><a href=" https://crates.io/crates/cocoindex ">cocoindex 0.2.10</a></li>
+                    <li><a href=" https://crates.io/crates/cocoindex ">cocoindex 0.2.12</a></li>
                     <li><a href=" https://github.com/awesomized/crc-fast-rust ">crc-fast 1.3.0</a></li>
                     <li><a href=" https://github.com/qdrant/rust-client ">qdrant-client 1.15.0</a></li>
                 </ul>

cocoindex-0.2.10.dist-info/RECORD

@@ -1,33 +0,0 @@
-cocoindex-0.2.10.dist-info/METADATA,sha256=KQcBWfVM6cEl93NcnSCeaPZx3pQSmkQr030zQZ2vvAw,13215
-cocoindex-0.2.10.dist-info/WHEEL,sha256=8hEf8NzM1FnmM77AjVt5h8nDuYkN3UqZ79LoIAHXeRE,95
-cocoindex-0.2.10.dist-info/entry_points.txt,sha256=_NretjYVzBdNTn7dK-zgwr7YfG2afz1u1uSE-5bZXF8,46
-cocoindex-0.2.10.dist-info/licenses/THIRD_PARTY_NOTICES.html,sha256=s4PFFZPP5i9n3Gw4VuPYKYYU5pc2bK9W9ipjRkQoygw,717804
-cocoindex/__init__.py,sha256=5QfLfEQ3NpWzhLCbOCLFcvNd-tvCgp_d9_MZjksSFqE,2362
-cocoindex/_engine.pyd,sha256=PuMNCJ6Oax64wTR7hDa4bP_3RxgsRSxQrdSDinbyaxk,72942592
-cocoindex/auth_registry.py,sha256=Qq1IVZb-7K4luRrQSDlOPbISnGEZ4kIDsrCU8H2ARw0,1529
-cocoindex/cli.py,sha256=Wt8wUjWqHEBoR3gDnHqIplLaL_tbStMCHAOuYhYq84A,22338
-cocoindex/convert.py,sha256=iKVufQXjsrvS8psKKZZYxuLohJvBIVctgKaRLLt8jK0,22711
-cocoindex/flow.py,sha256=w6FimPK4Nll9nYccbX-vjDMXzYb2lV66GmgikAMR5UQ,38802
-cocoindex/functions.py,sha256=CtiwTVW6g4BtO5_EvVcij7Si4Bx-axnM1hsdU43aM4g,12617
-cocoindex/index.py,sha256=GrqTm1rLwICQ8hadtNvJAxVg7GWMvtMmFcbiNtNzmP0,569
-cocoindex/lib.py,sha256=-Ys4a7BdDOW_ctz9vEBA5fSOqwsY_IKLHxaDwxvoXRg,2359
-cocoindex/llm.py,sha256=JM5EPup7FZojynCI0rg4gnMBYmdPZpaHJbVBz3f7BAI,897
-cocoindex/op.py,sha256=yO8QdfauUEe-3n1xZmhHhyr0EHqYEokcJRxtd3OtMo8,22255
-cocoindex/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cocoindex/runtime.py,sha256=6mE-jR1Kh5c4GETDvBgwjXZq69TK5rh1qNpaseRDZnw,1117
-cocoindex/setting.py,sha256=oohs7H52_h1AulDcp96cS9SVAAm_uFaQyJYog9EvCj0,5131
-cocoindex/setup.py,sha256=KbJvmeFu0NbeoH-5iDmHZP86f26HIId8kHmGUNZAePI,3160
-cocoindex/sources.py,sha256=Ij8LyYbM49zjPg-pJHMbas8sdLquEcgvmuYfv7wCdjI,3290
-cocoindex/subprocess_exec.py,sha256=u_kF4C8dToPg-9a7NeFroR8pJCOFag_NT0icLe184QQ,10391
-cocoindex/targets.py,sha256=7FfG9kuEf5KTXtLwXMFaPFIut3PsIbpb3XIEjjeF7Bg,2931
-cocoindex/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cocoindex/tests/test_convert.py,sha256=kngLt9p2BXo3D7_OZNnnSS1w_Ew8966IuaDpHcfd9Go,51750
-cocoindex/tests/test_optional_database.py,sha256=dnzmTgaJf37D3q8fQsjP5UDER6FYETaUokDnFBMLtIk,8755
-cocoindex/tests/test_transform_flow.py,sha256=DxM-7_kWeU-QzOpH77Vd5Jehbbq00xCBBgRK7mRn0kI,6237
-cocoindex/tests/test_typing.py,sha256=WqR1M11dSVYXZj1DnXnOvwH6VNQpiv5lCEO-FqA_by0,12820
-cocoindex/tests/test_validation.py,sha256=I4wr8lAMAjmy5xgG5N_OJKveXt8XIa96MsQTXhw5AnA,4677
-cocoindex/typing.py,sha256=bkKcp4G_xQODwQn92sfeNi-kXSWnbtlwTpFbrMGCnj4,14673
-cocoindex/user_app_loader.py,sha256=ZkvUG9aJNNECAjwTY0ZYtNpFd9dNBPVoPKGTtB7dSZg,1926
-cocoindex/utils.py,sha256=U3W39zD2uZpXX8v84tJD7sRmbC5ar3z_ljAP1cJrYXI,618
-cocoindex/validation.py,sha256=4ZjsW-SZT8X_TEEhEE6QG6D-8Oq_TkPAhTqP0mdFYSE,3194
-cocoindex-0.2.10.dist-info/RECORD,,