cocoindex 0.2.11__cp311-abi3-macosx_11_0_arm64.whl → 0.2.12__cp311-abi3-macosx_11_0_arm64.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.11.dist-info → cocoindex-0.2.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cocoindex
-Version: 0.2.11
+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.11.dist-info → cocoindex-0.2.12.dist-info}/RECORD

@@ -1,18 +1,18 @@
-cocoindex-0.2.11.dist-info/METADATA,sha256=u-dE4rSfVStoZHzhM01B2D0N-8AqLGiV3NAYs1zs19U,12999
-cocoindex-0.2.11.dist-info/WHEEL,sha256=cVaoL47Ex1FxzwnkO_WCjy3a1Wl6mtZbBPTvTiNCHdY,103
-cocoindex-0.2.11.dist-info/entry_points.txt,sha256=_NretjYVzBdNTn7dK-zgwr7YfG2afz1u1uSE-5bZXF8,46
-cocoindex-0.2.11.dist-info/licenses/THIRD_PARTY_NOTICES.html,sha256=o8g8gIN-zaK02_7ZMPlqompannwA2SwEB0e30CKRN1E,717804
+cocoindex-0.2.12.dist-info/METADATA,sha256=KLqMka9qkcyGzgf3HWNNv_nwRCugoGHMJdyTP2JFI1Y,13123
+cocoindex-0.2.12.dist-info/WHEEL,sha256=cVaoL47Ex1FxzwnkO_WCjy3a1Wl6mtZbBPTvTiNCHdY,103
+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=AsoNLBgjJ-1AEKtwTnENJM9dEilHTq6rJ4qWUzGKSdc,2428
-cocoindex/_engine.abi3.so,sha256=hgan9EVrBN2EuKUoId6TSI5_DmkbKgWHqiwbOkj6rYo,67154672
-cocoindex/auth_registry.py,sha256=9GgeuyE48vYhsJQJgI-uRjUviZkrQE63MUenP3OREko,1145
+cocoindex/_engine.abi3.so,sha256=SwjkVuKMJpZv4ac1jBCW-Zioxy7Bkc7udliIY4XSRS0,67172784
+cocoindex/auth_registry.py,sha256=_DOIY42C79joLCY_XczHwP5uebkmSavweoAHc0L3hQY,1334
 cocoindex/cli.py,sha256=69X30bFTFdM7c0_6lgIHR19CeQ7UEkobEQYihy8IdOQ,21599
-cocoindex/convert.py,sha256=Apk5PU4XGnSvEE2HMRN2W9H4ApBIHnkupegv_-TaVfA,22152
-cocoindex/flow.py,sha256=u_ta8wW5oGTDINs2dY4d_1hybySp3wuX79VJ4BDXZDc,39767
+cocoindex/convert.py,sha256=itkUBCriOk8fdauahHRqJ-L8mnHehNZsBe_FouN0K1Q,28695
+cocoindex/flow.py,sha256=Vk72dX_svfpinvsolQ11aw6YDqbzaafrAi7xrQHo1i0,39844
 cocoindex/functions.py,sha256=09erNt3WbzY9l1KER-akBF2O5-6xEahV2ORBECaL6yk,12260
 cocoindex/index.py,sha256=j93B9jEvvLXHtpzKWL88SY6wCGEoPgpsQhEGHlyYGFg,540
 cocoindex/lib.py,sha256=0XheDF7fiFdqExpdqzU-VKun_Zll6DwZ5JfTm7u42aY,2284
 cocoindex/llm.py,sha256=Pv_cdnRngTLtuLU9AUmS8izIHhcKVnuBNolC33f9BDI,851
-cocoindex/op.py,sha256=SRtI5ApgRQJHNsljd9Z2qNdS68_pYYQj9oVg3Bqc8W4,21416
+cocoindex/op.py,sha256=c1xzoiWoPb6PYiCQAUsyzMRJwPvWaC3o5emPk38oY-4,26551
 cocoindex/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cocoindex/query_handler.py,sha256=o9XFnpXWa00pAFImJ9oq-_kjI7w69dgCalkq63H9mA8,1192
 cocoindex/runtime.py,sha256=4NxcltaDZvA3RR3Pnt6gH_f99jcWSyMH_1Xi5BjbtwY,1342
@@ -20,15 +20,18 @@ cocoindex/setting.py,sha256=1Dx8ktjwf-8BiXrbsmfn5Mzudb2SQYqFdRnSNGVKaLk,4960
 cocoindex/setup.py,sha256=7uIHKN4FOCuoidPXcKyGTrkqpkl9luL49-6UcnMxYzw,3068
 cocoindex/sources.py,sha256=FYz7cWYasLGDaYoIEQ1dF2uprgUETHWsTIrIS7n6pQE,3188
 cocoindex/subprocess_exec.py,sha256=r1xO84uek4VP4I6i87JMwsH5xFm3vKW0ABvgn0jskt4,10088
-cocoindex/targets.py,sha256=Nfh_tpFd1goTnS_cxBjIs4j9zl3Z4Z1JomAQ1dl3Sic,2796
+cocoindex/targets/__init__.py,sha256=HQG7I4U0xQhHiYctiUvwEBLxT2727oHP3xwrqotjmhk,78
+cocoindex/targets/_engine_builtin_specs.py,sha256=DM7vyO0pkoukA-aBbvm_J4irgXhXIEqWdp-hwVpVRU4,2800
+cocoindex/targets/lancedb.py,sha256=pEHEBCOEe358e14cqAI1SytUTBCgRkYCsv9fJE7biTA,15440
 cocoindex/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cocoindex/tests/test_convert.py,sha256=UsQDuz7qukT9UAU5LBv3atNTqdUVc6uW8lrmLA7ys_w,50207
+cocoindex/tests/test_convert.py,sha256=pG1AkEdIKSRE0trMV2dQ6VSQEqQJnPTJzfQCVrZSz8w,50791
+cocoindex/tests/test_load_convert.py,sha256=XHuXhgLcazniEYrhoz_L5RFvgUwu-iy3EB9zgR6p95A,3339
 cocoindex/tests/test_optional_database.py,sha256=snAmkNa6wtOSaxoZE1HgjvL5v_ylitt3Jt_9df4Cgdc,8506
 cocoindex/tests/test_transform_flow.py,sha256=G69w-n-vnCTo3r9hVIk2lJNAQEkGUA7PZfHsXna3oS0,6030
-cocoindex/tests/test_typing.py,sha256=9OF3lO2uSpZBefkEJx7WRbnkXjwQtvlQIeeARYQID68,12391
+cocoindex/tests/test_typing.py,sha256=JoR-oMK-ZWjOGQi0pH5Etg5jp4oL_JSIreGBH247GCg,16291
 cocoindex/tests/test_validation.py,sha256=X6AQzVs-hVKIXcrHMEMQnhfUE8at7iXQnPq8nHNhZ2Q,4543
-cocoindex/typing.py,sha256=lEQYIzAGVKQp6RnhyeopY9Q7xEED7yQj3ZMxvTPblV8,14200
+cocoindex/typing.py,sha256=jZO3meRVL_RsFdhj8Sx6gWF-Z207VhoPtb1ZmqzAnH0,19974
 cocoindex/user_app_loader.py,sha256=bc3Af-gYRxJ9GpObtpjegZY855oQBCv5FGkrkWV2yGY,1873
 cocoindex/utils.py,sha256=hUhX-XV6XGCtJSEIpBOuDv6VvqImwPlgBxztBTw7u0U,598
 cocoindex/validation.py,sha256=PZnJoby4sLbsmPv9fOjOQXuefjfZ7gmtsiTGU8SH-tc,3090
-cocoindex-0.2.11.dist-info/RECORD,,
+cocoindex-0.2.12.dist-info/RECORD,,

{cocoindex-0.2.11.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.11</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>