cocoindex 0.1.25__cp311-cp311-win_amd64.whl → 0.1.27__cp311-cp311-win_amd64.whl

cocoindex/__init__.py

@@ -9,4 +9,5 @@ from .llm import LlmSpec, LlmApiType
 from .index import VectorSimilarityMetric, VectorIndexDef, IndexOptions
 from .auth_registry import AuthEntryReference, add_auth_entry, ref_auth_entry
 from .lib import *
-from ._engine import OpArgSchema
+from ._engine import OpArgSchema
+from .typing import Float32, Float64, LocalDateTime, OffsetDateTime, Range, Vector, Json

cocoindex/cli.py

@@ -4,6 +4,7 @@ import datetime
 
 from . import flow, lib
 from .setup import sync_setup, drop_setup, flow_names_with_setup, apply_setup_changes
+from .runtime import execution_context
 
 @click.group()
 def cli():
@@ -113,11 +114,13 @@ def update(flow_name: str | None, live: bool, quiet: bool):
     Update the index to reflect the latest data from data sources.
     """
     options = flow.FlowLiveUpdaterOptions(live_mode=live, print_stats=not quiet)
-    if flow_name is None:
-        asyncio.run(flow.update_all_flows(options))
-    else:
-        updater = flow.FlowLiveUpdater(_flow_by_name(flow_name), options)
-        asyncio.run(updater.wait())
+    async def _update():
+        if flow_name is None:
+            await flow.update_all_flows(options)
+        else:
+            updater = await flow.FlowLiveUpdater.create(_flow_by_name(flow_name), options)
+            await updater.wait()
+    execution_context.run(_update())
 
 @cli.command()
 @click.argument("flow_name", type=str, required=False)
@@ -167,7 +170,7 @@ def server(address: str, live_update: bool, quiet: bool, cors_origin: str | None
     lib.start_server(lib.ServerSettings(address=address, cors_origin=cors_origin))
     if live_update:
         options = flow.FlowLiveUpdaterOptions(live_mode=True, print_stats=not quiet)
-        asyncio.run(flow.update_all_flows(options))
+        execution_context.run(flow.update_all_flows(options))
     input("Press Enter to stop...")
 
 

cocoindex/convert.py

@@ -8,25 +8,28 @@ import uuid
 
 from enum import Enum
 from typing import Any, Callable, get_origin
-from .typing import analyze_type_info, encode_enriched_type, COLLECTION_TYPES
+from .typing import analyze_type_info, encode_enriched_type, TABLE_TYPES, KEY_FIELD_NAME
 
-def to_engine_value(value: Any) -> Any:
-    """Convert a Python value to an engine value."""
+
+def encode_engine_value(value: Any) -> Any:
+    """Encode a Python value to an engine value."""
     if dataclasses.is_dataclass(value):
-        return [to_engine_value(getattr(value, f.name)) for f in dataclasses.fields(value)]
+        return [encode_engine_value(getattr(value, f.name)) for f in dataclasses.fields(value)]
     if isinstance(value, (list, tuple)):
-        return [to_engine_value(v) for v in value]
+        return [encode_engine_value(v) for v in value]
+    if isinstance(value, dict):
+        return [[encode_engine_value(k)] + encode_engine_value(v) for k, v in value.items()]
     if isinstance(value, uuid.UUID):
         return value.bytes
     return value
 
-def make_engine_value_converter(
+def make_engine_value_decoder(
         field_path: list[str],
         src_type: dict[str, Any],
         dst_annotation,
     ) -> Callable[[Any], Any]:
     """
-    Make a converter from an engine value to a Python value.
+    Make a decoder from an engine value to a Python value.
 
     Args:
         field_path: The path to the field in the engine value. For error messages.
@@ -34,13 +37,13 @@ def make_engine_value_converter(
         dst_annotation: The type annotation of the Python value.
 
     Returns:
-        A converter from an engine value to a Python value.
+        A decoder from an engine value to a Python value.
     """
 
     src_type_kind = src_type['kind']
 
     if dst_annotation is inspect.Parameter.empty:
-        if src_type_kind == 'Struct' or src_type_kind in COLLECTION_TYPES:
+        if src_type_kind == 'Struct' or src_type_kind in TABLE_TYPES:
             raise ValueError(f"Missing type annotation for `{''.join(field_path)}`."
                              f"It's required for {src_type_kind} type.")
         return lambda value: value
@@ -53,41 +56,59 @@ def make_engine_value_converter(
             f"passed in {src_type_kind}, declared {dst_annotation} ({dst_type_info.kind})")
 
     if dst_type_info.dataclass_type is not None:
-        return _make_engine_struct_value_converter(
+        return _make_engine_struct_value_decoder(
             field_path, src_type['fields'], dst_type_info.dataclass_type)
 
-    if src_type_kind in COLLECTION_TYPES:
+    if src_type_kind in TABLE_TYPES:
         field_path.append('[*]')
         elem_type_info = analyze_type_info(dst_type_info.elem_type)
         if elem_type_info.dataclass_type is None:
             raise ValueError(f"Type mismatch for `{''.join(field_path)}`: "
-                             f"declared `{dst_type_info.kind}`, a dataclass type expected")
-        elem_converter = _make_engine_struct_value_converter(
-            field_path, src_type['row']['fields'], elem_type_info.dataclass_type)
+                            f"declared `{dst_type_info.kind}`, a dataclass type expected")
+        engine_fields_schema = src_type['row']['fields']
+        if elem_type_info.key_type is not None:
+            key_field_schema = engine_fields_schema[0]
+            field_path.append(f".{key_field_schema.get('name', KEY_FIELD_NAME)}")
+            key_decoder = make_engine_value_decoder(
+                field_path, key_field_schema['type'], elem_type_info.key_type)
+            field_path.pop()
+            value_decoder = _make_engine_struct_value_decoder(
+                field_path, engine_fields_schema[1:], elem_type_info.dataclass_type)
+            def decode(value):
+                if value is None:
+                    return None
+                return {key_decoder(v[0]): value_decoder(v[1:]) for v in value}
+        else:
+            elem_decoder = _make_engine_struct_value_decoder(
+                field_path, engine_fields_schema, elem_type_info.dataclass_type)
+            def decode(value):
+                if value is None:
+                    return None
+                return [elem_decoder(v) for v in value]
         field_path.pop()
-        return lambda value: [elem_converter(v) for v in value] if value is not None else None
+        return decode
 
     if src_type_kind == 'Uuid':
         return lambda value: uuid.UUID(bytes=value)
 
     return lambda value: value
 
-def _make_engine_struct_value_converter(
+def _make_engine_struct_value_decoder(
         field_path: list[str],
         src_fields: list[dict[str, Any]],
         dst_dataclass_type: type,
     ) -> Callable[[list], Any]:
-    """Make a converter from an engine field values to a Python value."""
+    """Make a decoder from an engine field values to a Python value."""
 
     src_name_to_idx = {f['name']: i for i, f in enumerate(src_fields)}
     def make_closure_for_value(name: str, param: inspect.Parameter) -> Callable[[list], Any]:
         src_idx = src_name_to_idx.get(name)
         if src_idx is not None:
             field_path.append(f'.{name}')
-            field_converter = make_engine_value_converter(
+            field_decoder = make_engine_value_decoder(
                 field_path, src_fields[src_idx]['type'], param.annotation)
             field_path.pop()
-            return lambda values: field_converter(values[src_idx])
+            return lambda values: field_decoder(values[src_idx])
 
         default_value = param.default
         if default_value is inspect.Parameter.empty:
@@ -96,12 +117,12 @@ def _make_engine_struct_value_converter(
 
         return lambda _: default_value
 
-    field_value_converters = [
+    field_value_decoder = [
         make_closure_for_value(name, param)
         for (name, param) in inspect.signature(dst_dataclass_type).parameters.items()]
 
     return lambda values: dst_dataclass_type(
-        *(converter(values) for converter in field_value_converters))
+        *(decoder(values) for decoder in field_value_decoder))
 
 def dump_engine_object(v: Any) -> Any:
     """Recursively dump an object for engine. Engine side uses `Pythonized` to catch."""

cocoindex/flow.py

@@ -19,7 +19,7 @@ from . import index
 from . import op
 from .convert import dump_engine_object
 from .typing import encode_enriched_type
-from .runtime import op_execution_context
+from .runtime import execution_context
 
 class _NameBuilder:
     _existing_names: set[str]
@@ -142,9 +142,9 @@ class DataSlice:
 
     def row(self) -> DataScope:
         """
-        Return a scope representing each entry of the collection.
+        Return a scope representing each row of the table.
         """
-        row_scope = self._state.engine_data_slice.collection_entry_scope()
+        row_scope = self._state.engine_data_slice.table_row_scope()
         return DataScope(self._state.flow_builder_state, row_scope)
 
     def for_each(self, f: Callable[[DataScope], None]) -> None:
@@ -355,6 +355,12 @@ class FlowBuilder:
             name
         )
 
+    def declare(self, spec: op.DeclarationSpec):
+        """
+        Add a declaration to the flow.
+        """
+        self._state.engine_flow_builder.declare(dump_engine_object(spec))
+
 @dataclass
 class FlowLiveUpdaterOptions:
     """
@@ -369,16 +375,29 @@ class FlowLiveUpdater:
     """
     _engine_live_updater: _engine.FlowLiveUpdater
 
-    def __init__(self, fl: Flow, options: FlowLiveUpdaterOptions | None = None):
-        self._engine_live_updater = _engine.FlowLiveUpdater(
-            fl._lazy_engine_flow(), dump_engine_object(options or FlowLiveUpdaterOptions()))
+    def __init__(self, arg: Flow | _engine.FlowLiveUpdater, options: FlowLiveUpdaterOptions | None = None):
+        if isinstance(arg, _engine.FlowLiveUpdater):
+            self._engine_live_updater = arg
+        else:
+            self._engine_live_updater = execution_context.run(_engine.FlowLiveUpdater(
+                arg.internal_flow(), dump_engine_object(options or FlowLiveUpdaterOptions())))
+
+    @staticmethod
+    async def create(fl: Flow, options: FlowLiveUpdaterOptions | None = None) -> FlowLiveUpdater:
+        """
+        Create a live updater for a flow.
+        """
+        engine_live_updater = await _engine.FlowLiveUpdater.create(
+            await fl.ainternal_flow(),
+            dump_engine_object(options or FlowLiveUpdaterOptions()))
+        return FlowLiveUpdater(engine_live_updater)
 
     def __enter__(self) -> FlowLiveUpdater:
         return self
 
     def __exit__(self, exc_type, exc_value, traceback):
         self.abort()
-        asyncio.run(self.wait())
+        execution_context.run(self.wait())
 
     async def __aenter__(self) -> FlowLiveUpdater:
         return self
@@ -450,7 +469,7 @@ class Flow:
         Update the index defined by the flow.
         Once the function returns, the indice is fresh up to the moment when the function is called.
         """
-        updater = FlowLiveUpdater(self, FlowLiveUpdaterOptions(live_mode=False))
+        updater = await FlowLiveUpdater.create(self, FlowLiveUpdaterOptions(live_mode=False))
         await updater.wait()
         return updater.update_stats()
 
@@ -466,6 +485,12 @@ class Flow:
         """
         return self._lazy_engine_flow()
 
+    async def ainternal_flow(self) -> _engine.Flow:
+        """
+        Get the engine flow. The async version.
+        """
+        return await asyncio.to_thread(self.internal_flow)
+
 def _create_lazy_flow(name: str | None, fl_def: Callable[[FlowBuilder, DataScope], None]) -> Flow:
     """
     Create a flow without really building it yet.
@@ -476,7 +501,7 @@ def _create_lazy_flow(name: str | None, fl_def: Callable[[FlowBuilder, DataScope
         root_scope = DataScope(
             flow_builder_state, flow_builder_state.engine_flow_builder.root_scope())
         fl_def(FlowBuilder(flow_builder_state), root_scope)
-        return flow_builder_state.engine_flow_builder.build_flow(op_execution_context.event_loop)
+        return flow_builder_state.engine_flow_builder.build_flow(execution_context.event_loop)
 
     return Flow(_create_engine_flow)
 
@@ -523,17 +548,23 @@ def ensure_all_flows_built() -> None:
     """
     Ensure all flows are built.
     """
-    with _flows_lock:
-        for fl in _flows.values():
-            fl.internal_flow()
+    for fl in flows():
+        fl.internal_flow()
+
+async def aensure_all_flows_built() -> None:
+    """
+    Ensure all flows are built.
+    """
+    for fl in flows():
+        await fl.ainternal_flow()
 
 async def update_all_flows(options: FlowLiveUpdaterOptions) -> dict[str, _engine.IndexUpdateInfo]:
     """
     Update all flows.
     """
-    ensure_all_flows_built()
+    await aensure_all_flows_built()
     async def _update_flow(fl: Flow) -> _engine.IndexUpdateInfo:
-        updater = FlowLiveUpdater(fl, options)
+        updater = await FlowLiveUpdater.create(fl, options)
         await updater.wait()
         return updater.update_stats()
     fls = flows()
@@ -572,7 +603,7 @@ class TransientFlow:
         flow_builder_state.engine_flow_builder.set_direct_output(
             _data_slice_state(output).engine_data_slice)
         self._engine_flow = flow_builder_state.engine_flow_builder.build_transient_flow(
-            op_execution_context.event_loop)
+            execution_context.event_loop)
 
     def __str__(self):
         return str(self._engine_flow)

cocoindex/functions.py

@@ -41,7 +41,7 @@ class SentenceTransformerEmbedExecutor:
         args = self.spec.args or {}
         self._model = sentence_transformers.SentenceTransformer(self.spec.model, **args)
         dim = self._model.get_sentence_embedding_dimension()
-        return Annotated[list[Float32], Vector(dim=dim), TypeAttr("cocoindex.io/vector_origin_text", text.analyzed_value)]
+        return Annotated[Vector[Float32, dim], TypeAttr("cocoindex.io/vector_origin_text", text.analyzed_value)]
 
     def __call__(self, text: str) -> list[Float32]:
         return self._model.encode(text).tolist()

cocoindex/lib.py

@@ -1,7 +1,6 @@
 """
 Library level functions and states.
 """
-import asyncio
 import os
 import sys
 import functools
@@ -12,6 +11,7 @@ from dataclasses import dataclass
 
 from . import _engine
 from . import flow, query, cli
+from .convert import dump_engine_object
 
 
 def _load_field(target: dict[str, str], name: str, env_name: str, required: bool = False):
@@ -22,24 +22,32 @@ def _load_field(target: dict[str, str], name: str, env_name: str, required: bool
     else:
         target[name] = value
 
+@dataclass
+class DatabaseConnectionSpec:
+    url: str
+    user: str | None = None
+    password: str | None = None
+
 @dataclass
 class Settings:
     """Settings for the cocoindex library."""
-    database_url: str
+    database: DatabaseConnectionSpec
 
     @classmethod
     def from_env(cls) -> Self:
         """Load settings from environment variables."""
 
-        kwargs: dict[str, str] = dict()
-        _load_field(kwargs, "database_url", "COCOINDEX_DATABASE_URL", required=True)
-
-        return cls(**kwargs)
+        db_kwargs: dict[str, str] = dict()
+        _load_field(db_kwargs, "url", "COCOINDEX_DATABASE_URL", required=True)
+        _load_field(db_kwargs, "user", "COCOINDEX_DATABASE_USER")
+        _load_field(db_kwargs, "password", "COCOINDEX_DATABASE_PASSWORD")
+        database = DatabaseConnectionSpec(**db_kwargs)
+        return cls(database=database)
 
 
 def init(settings: Settings):
     """Initialize the cocoindex library."""
-    _engine.init(settings.__dict__)
+    _engine.init(dump_engine_object(settings))
 
 @dataclass
 class ServerSettings:
@@ -101,7 +109,8 @@ def main_fn(
                 try:
                     if _should_run_cli():
                         # Schedule to a separate thread as it invokes nested event loop.
-                        return await asyncio.to_thread(_run_cli)
+                        # return await asyncio.to_thread(_run_cli)
+                        return _run_cli()
                     return await fn(*args, **kwargs)
                 finally:
                     stop()

cocoindex/llm.py

@@ -5,6 +5,8 @@ class LlmApiType(Enum):
     """The type of LLM API to use."""
     OPENAI = "OpenAi"
     OLLAMA = "Ollama"
+    GEMINI = "Gemini"
+    ANTHROPIC = "Anthropic"
 
 @dataclass
 class LlmSpec:

cocoindex/op.py

@@ -7,10 +7,9 @@ import inspect
 
 from typing import get_type_hints, Protocol, Any, Callable, Awaitable, dataclass_transform
 from enum import Enum
-from functools import partial
 
 from .typing import encode_enriched_type
-from .convert import to_engine_value, make_engine_value_converter
+from .convert import encode_engine_value, make_engine_value_decoder
 from . import _engine
 
 class OpCategory(Enum):
@@ -18,7 +17,7 @@ class OpCategory(Enum):
     FUNCTION = "function"
     SOURCE = "source"
     STORAGE = "storage"
-
+    DECLARATION = "declaration"
 @dataclass_transform()
 class SpecMeta(type):
     """Meta class for spec classes."""
@@ -41,6 +40,8 @@ class FunctionSpec(metaclass=SpecMeta, category=OpCategory.FUNCTION): # pylint:
 class StorageSpec(metaclass=SpecMeta, category=OpCategory.STORAGE): # pylint: disable=too-few-public-methods
     """A storage spec. All its subclass can be instantiated similar to a dataclass, i.e. ClassName(field1=value1, field2=value2, ...)"""
 
+class DeclarationSpec(metaclass=SpecMeta, category=OpCategory.DECLARATION): # pylint: disable=too-few-public-methods
+    """A declaration spec. All its subclass can be instantiated similar to a dataclass, i.e. ClassName(field1=value1, field2=value2, ...)"""
 class Executor(Protocol):
     """An executor for an operation."""
     op_category: OpCategory
@@ -128,7 +129,7 @@ def _register_op_factory(
                     raise ValueError(
                         f"Too many positional arguments passed in: {len(args)} > {next_param_idx}")
                 self._args_converters.append(
-                    make_engine_value_converter(
+                    make_engine_value_decoder(
                         [arg_name], arg.value_type['type'], arg_param.annotation))
                 if arg_param.kind != inspect.Parameter.VAR_POSITIONAL:
                     next_param_idx += 1
@@ -145,7 +146,7 @@ def _register_op_factory(
                 if expected_arg is None:
                     raise ValueError(f"Unexpected keyword argument passed in: {kwarg_name}")
                 arg_param = expected_arg[1]
-                self._kwargs_converters[kwarg_name] = make_engine_value_converter(
+                self._kwargs_converters[kwarg_name] = make_engine_value_decoder(
                     [kwarg_name], kwarg.value_type['type'], arg_param.annotation)
 
             missing_args = [name for (name, arg) in expected_kwargs
@@ -187,7 +188,7 @@ def _register_op_factory(
                     output = await self._acall(*converted_args, **converted_kwargs)
             else:
                 output = await self._acall(*converted_args, **converted_kwargs)
-            return to_engine_value(output)
+            return encode_engine_value(output)
 
     _WrappedClass.__name__ = executor_cls.__name__
     _WrappedClass.__doc__ = executor_cls.__doc__

cocoindex/query.py

@@ -66,15 +66,16 @@ class SimpleSemanticsQueryHandler:
         return self._lazy_query_handler()
 
     def search(self, query: str, limit: int, vector_field_name: str | None = None,
-               similarity_matric: index.VectorSimilarityMetric | None = None) -> tuple[list[QueryResult], SimpleSemanticsQueryInfo]:
+               similarity_metric: index.VectorSimilarityMetric | None = None
+               ) -> tuple[list[QueryResult], SimpleSemanticsQueryInfo]:
         """
         Search the index with the given query, limit, vector field name, and similarity metric.
         """
         internal_results, internal_info = self.internal_handler().search(
             query, limit, vector_field_name,
-            similarity_matric.value if similarity_matric is not None else None)
-        fields = [field['name'] for field in internal_results['fields']]
-        results = [QueryResult(data=dict(zip(fields, result['data'])),  score=result['score']) for result in internal_results['results']]
+            similarity_metric.value if similarity_metric is not None else None)
+        results = [QueryResult(data=result['data'],  score=result['score'])
+                   for result in internal_results]
         info = SimpleSemanticsQueryInfo(
             similarity_metric=index.VectorSimilarityMetric(internal_info['similarity_metric']),
             query_vector=internal_info['query_vector'],

cocoindex/runtime.py

@@ -1,7 +1,12 @@
+"""
+This module provides a standalone execution runtime for executing coroutines in a thread-safe
+manner.
+"""
+
 import threading
 import asyncio
-
-class _OpExecutionContext:
+from typing import Coroutine
+class _ExecutionContext:
     _lock: threading.Lock
     _event_loop: asyncio.AbstractEventLoop | None = None
 
@@ -14,8 +19,11 @@ class _OpExecutionContext:
         with self._lock:
             if self._event_loop is None:
                 self._event_loop = asyncio.new_event_loop()
-                asyncio.set_event_loop(self._event_loop)
                 threading.Thread(target=self._event_loop.run_forever, daemon=True).start()
             return self._event_loop
 
-op_execution_context = _OpExecutionContext()
+    def run(self, coro: Coroutine):
+        """Run a coroutine in the event loop, blocking until it finishes. Return its result."""
+        return asyncio.run_coroutine_threadsafe(coro, self.event_loop).result()
+
+execution_context = _ExecutionContext()

cocoindex/storages.py

@@ -9,7 +9,7 @@ from .auth_registry import AuthEntryReference
 class Postgres(op.StorageSpec):
     """Storage powered by Postgres and pgvector."""
 
-    database_url: str | None = None
+    database: AuthEntryReference | None = None
     table_name: str | None = None
 
 @dataclass
@@ -43,8 +43,9 @@ class NodeReferenceMapping:
     fields: list[TargetFieldMapping]
 
 @dataclass
-class NodeStorageSpec:
+class ReferencedNode:
     """Storage spec for a graph node."""
+    label: str
     primary_key_fields: Sequence[str]
     vector_indexes: Sequence[index.VectorIndexDef] = ()
 
@@ -63,10 +64,16 @@ class RelationshipMapping:
     rel_type: str
     source: NodeReferenceMapping
     target: NodeReferenceMapping
-    nodes_storage_spec: dict[str, NodeStorageSpec] | None = None
 
 class Neo4j(op.StorageSpec):
     """Graph storage powered by Neo4j."""
 
     connection: AuthEntryReference
     mapping: NodeMapping | RelationshipMapping
+
+class Neo4jDeclarations(op.DeclarationSpec):
+    """Declarations for Neo4j."""
+
+    kind = "Neo4j"
+    connection: AuthEntryReference
+    referenced_nodes: Sequence[ReferencedNode] = ()

cocoindex/tests/test_convert.py

@@ -1,15 +1,21 @@
-import dataclasses
 import uuid
 import datetime
-from dataclasses import dataclass
+from dataclasses import dataclass, make_dataclass
 import pytest
-from cocoindex.convert import to_engine_value
-
+import cocoindex
+from cocoindex.typing import encode_enriched_type
+from cocoindex.convert import encode_engine_value, make_engine_value_decoder
+from typing import Literal
 @dataclass
 class Order:
     order_id: str
     name: str
     price: float
+    extra_field: str = "default_extra"
+
+@dataclass
+class Tag:
+    name: str
 
 @dataclass
 class Basket:
@@ -19,51 +25,256 @@ class Basket:
 class Customer:
     name: str
     order: Order
+    tags: list[Tag] | None = None
+
+@dataclass
+class NestedStruct:
+    customer: Customer
+    orders: list[Order]
+    count: int = 0
+
+def build_engine_value_decoder(engine_type_in_py, python_type=None):
+    """
+    Helper to build a converter for the given engine-side type (as represented in Python).
+    If python_type is not specified, uses engine_type_in_py as the target.
+    """
+    engine_type = encode_enriched_type(engine_type_in_py)["type"]
+    return make_engine_value_decoder([], engine_type, python_type or engine_type_in_py)
 
-def test_to_engine_value_basic_types():
-    assert to_engine_value(123) == 123
-    assert to_engine_value(3.14) == 3.14
-    assert to_engine_value("hello") == "hello"
-    assert to_engine_value(True) is True
+def test_encode_engine_value_basic_types():
+    assert encode_engine_value(123) == 123
+    assert encode_engine_value(3.14) == 3.14
+    assert encode_engine_value("hello") == "hello"
+    assert encode_engine_value(True) is True
 
-def test_to_engine_value_uuid():
+def test_encode_engine_value_uuid():
     u = uuid.uuid4()
-    assert to_engine_value(u) == u.bytes
+    assert encode_engine_value(u) == u.bytes
 
-def test_to_engine_value_date_time_types():
+def test_encode_engine_value_date_time_types():
     d = datetime.date(2024, 1, 1)
-    assert to_engine_value(d) == d
+    assert encode_engine_value(d) == d
     t = datetime.time(12, 30)
-    assert to_engine_value(t) == t
+    assert encode_engine_value(t) == t
     dt = datetime.datetime(2024, 1, 1, 12, 30)
-    assert to_engine_value(dt) == dt
+    assert encode_engine_value(dt) == dt
 
-def test_to_engine_value_struct():
+def test_encode_engine_value_struct():
     order = Order(order_id="O123", name="mixed nuts", price=25.0)
-    assert to_engine_value(order) == ["O123", "mixed nuts", 25.0]
+    assert encode_engine_value(order) == ["O123", "mixed nuts", 25.0, "default_extra"]
 
-def test_to_engine_value_list_of_structs():
+def test_encode_engine_value_list_of_structs():
     orders = [Order("O1", "item1", 10.0), Order("O2", "item2", 20.0)]
-    assert to_engine_value(orders) == [["O1", "item1", 10.0], ["O2", "item2", 20.0]]
+    assert encode_engine_value(orders) == [["O1", "item1", 10.0, "default_extra"], ["O2", "item2", 20.0, "default_extra"]]
 
-def test_to_engine_value_struct_with_list():
+def test_encode_engine_value_struct_with_list():
     basket = Basket(items=["apple", "banana"])
-    assert to_engine_value(basket) == [["apple", "banana"]]
+    assert encode_engine_value(basket) == [["apple", "banana"]]
 
-def test_to_engine_value_nested_struct():
+def test_encode_engine_value_nested_struct():
     customer = Customer(name="Alice", order=Order("O1", "item1", 10.0))
-    assert to_engine_value(customer) == ["Alice", ["O1", "item1", 10.0]]
+    assert encode_engine_value(customer) == ["Alice", ["O1", "item1", 10.0, "default_extra"], None]
+
+def test_encode_engine_value_empty_list():
+    assert encode_engine_value([]) == []
+    assert encode_engine_value([[]]) == [[]]
+
+def test_encode_engine_value_tuple():
+    assert encode_engine_value(()) == []
+    assert encode_engine_value((1, 2, 3)) == [1, 2, 3]
+    assert encode_engine_value(((1, 2), (3, 4))) == [[1, 2], [3, 4]]
+    assert encode_engine_value(([],)) == [[]]
+    assert encode_engine_value(((),)) == [[]]
+
+def test_encode_engine_value_none():
+    assert encode_engine_value(None) is None
+
+def test_make_engine_value_decoder_basic_types():
+    for engine_type_in_py, value in [
+        (int, 42),
+        (float, 3.14),
+        (str, "hello"),
+        (bool, True),
+        # (type(None), None),  # Removed unsupported NoneType
+    ]:
+        decoder = build_engine_value_decoder(engine_type_in_py)
+        assert decoder(value) == value
+
+@pytest.mark.parametrize(
+    "data_type, engine_val, expected",
+    [
+        # All fields match
+        (Order, ["O123", "mixed nuts", 25.0, "default_extra"], Order("O123", "mixed nuts", 25.0, "default_extra")),
+        # Extra field in engine value (should ignore extra)
+        (Order, ["O123", "mixed nuts", 25.0, "default_extra", "unexpected"], Order("O123", "mixed nuts", 25.0, "default_extra")),
+        # Fewer fields in engine value (should fill with default)
+        (Order, ["O123", "mixed nuts", 0.0, "default_extra"], Order("O123", "mixed nuts", 0.0, "default_extra")),
+        # More fields in engine value (should ignore extra)
+        (Order, ["O123", "mixed nuts", 25.0, "unexpected"], Order("O123", "mixed nuts", 25.0, "unexpected")),
+        # Truly extra field (should ignore the fifth field)
+        (Order, ["O123", "mixed nuts", 25.0, "default_extra", "ignored"], Order("O123", "mixed nuts", 25.0, "default_extra")),
+        # Missing optional field in engine value (tags=None)
+        (Customer, ["Alice", ["O1", "item1", 10.0, "default_extra"], None], Customer("Alice", Order("O1", "item1", 10.0, "default_extra"), None)),
+        # Extra field in engine value for Customer (should ignore)
+        (Customer, ["Alice", ["O1", "item1", 10.0, "default_extra"], [["vip"]], "extra"], Customer("Alice", Order("O1", "item1", 10.0, "default_extra"), [Tag("vip")])),
+    ]
+)
+def test_struct_decoder_cases(data_type, engine_val, expected):
+    decoder = build_engine_value_decoder(data_type)
+    assert decoder(engine_val) == expected
+
+def test_make_engine_value_decoder_collections():
+    # List of structs
+    decoder = build_engine_value_decoder(list[Order])
+    engine_val = [
+        ["O1", "item1", 10.0, "default_extra"],
+        ["O2", "item2", 20.0, "default_extra"]
+    ]
+    assert decoder(engine_val) == [Order("O1", "item1", 10.0, "default_extra"), Order("O2", "item2", 20.0, "default_extra")]
+    # Struct with list field
+    decoder = build_engine_value_decoder(Customer)
+    engine_val = ["Alice", ["O1", "item1", 10.0, "default_extra"], [["vip"], ["premium"]]]
+    assert decoder(engine_val) == Customer("Alice", Order("O1", "item1", 10.0, "default_extra"), [Tag("vip"), Tag("premium")])
+    # Struct with struct field
+    decoder = build_engine_value_decoder(NestedStruct)
+    engine_val = [
+        ["Alice", ["O1", "item1", 10.0, "default_extra"], [["vip"]]],
+        [["O1", "item1", 10.0, "default_extra"], ["O2", "item2", 20.0, "default_extra"]],
+        2
+    ]
+    assert decoder(engine_val) == NestedStruct(
+        Customer("Alice", Order("O1", "item1", 10.0, "default_extra"), [Tag("vip")]),
+        [Order("O1", "item1", 10.0, "default_extra"), Order("O2", "item2", 20.0, "default_extra")],
+        2
+    )
+
+def make_engine_order(fields):
+    return make_dataclass('EngineOrder', fields)
+
+def make_python_order(fields, defaults=None):
+    if defaults is None:
+        defaults = {}
+    # Move all fields with defaults to the end (Python dataclass requirement)
+    non_default_fields = [(n, t) for n, t in fields if n not in defaults]
+    default_fields = [(n, t) for n, t in fields if n in defaults]
+    ordered_fields = non_default_fields + default_fields
+    # Prepare the namespace for defaults (only for fields at the end)
+    namespace = {k: defaults[k] for k, _ in default_fields}
+    return make_dataclass('PythonOrder', ordered_fields, namespace=namespace)
+
+@pytest.mark.parametrize(
+    "engine_fields, python_fields, python_defaults, engine_val, expected_python_val",
+    [
+        # Extra field in Python (middle)
+        (
+            [("id", str), ("name", str)],
+            [("id", str), ("price", float), ("name", str)],
+            {"price": 0.0},
+            ["O123", "mixed nuts"],
+            ("O123", 0.0, "mixed nuts"),
+        ),
+        # Missing field in Python (middle)
+        (
+            [("id", str), ("price", float), ("name", str)],
+            [("id", str), ("name", str)],
+            {},
+            ["O123", 25.0, "mixed nuts"],
+            ("O123", "mixed nuts"),
+        ),
+        # Extra field in Python (start)
+        (
+            [("name", str), ("price", float)],
+            [("extra", str), ("name", str), ("price", float)],
+            {"extra": "default"},
+            ["mixed nuts", 25.0],
+            ("default", "mixed nuts", 25.0),
+        ),
+        # Missing field in Python (start)
+        (
+            [("extra", str), ("name", str), ("price", float)],
+            [("name", str), ("price", float)],
+            {},
+            ["unexpected", "mixed nuts", 25.0],
+            ("mixed nuts", 25.0),
+        ),
+        # Field order difference (should map by name)
+        (
+            [("id", str), ("name", str), ("price", float)],
+            [("name", str), ("id", str), ("price", float), ("extra", str)],
+            {"extra": "default"},
+            ["O123", "mixed nuts", 25.0],
+            ("mixed nuts", "O123", 25.0, "default"),
+        ),
+        # Extra field (Python has extra field with default)
+        (
+            [("id", str), ("name", str)],
+            [("id", str), ("name", str), ("price", float)],
+            {"price": 0.0},
+            ["O123", "mixed nuts"],
+            ("O123", "mixed nuts", 0.0),
+        ),
+        # Missing field (Engine has extra field)
+        (
+            [("id", str), ("name", str), ("price", float)],
+            [("id", str), ("name", str)],
+            {},
+            ["O123", "mixed nuts", 25.0],
+            ("O123", "mixed nuts"),
+        ),
+    ]
+)
+def test_field_position_cases(engine_fields, python_fields, python_defaults, engine_val, expected_python_val):
+    EngineOrder = make_engine_order(engine_fields)
+    PythonOrder = make_python_order(python_fields, python_defaults)
+    decoder = build_engine_value_decoder(EngineOrder, PythonOrder)
+    # Map field names to expected values
+    expected_dict = dict(zip([f[0] for f in python_fields], expected_python_val))
+    # Instantiate using keyword arguments (order doesn't matter)
+    assert decoder(engine_val) == PythonOrder(**expected_dict)
+
+def test_roundtrip_ltable():
+    t = list[Order]
+    value = [Order("O1", "item1", 10.0), Order("O2", "item2", 20.0)]
+    encoded = encode_engine_value(value)
+    assert encoded == [["O1", "item1", 10.0, "default_extra"], ["O2", "item2", 20.0, "default_extra"]]
+    decoded = build_engine_value_decoder(t)(encoded)
+    assert decoded == value
+
+def test_roundtrip_ktable_str_key():
+    t = dict[str, Order]
+    value = {"K1": Order("O1", "item1", 10.0), "K2": Order("O2", "item2", 20.0)}
+    encoded = encode_engine_value(value)
+    assert encoded == [["K1", "O1", "item1", 10.0, "default_extra"], ["K2", "O2", "item2", 20.0, "default_extra"]]
+    decoded = build_engine_value_decoder(t)(encoded)
+    assert decoded == value
+
+def test_roundtrip_ktable_struct_key():
+    @dataclass(frozen=True)
+    class OrderKey:
+        shop_id: str
+        version: int
+
+    t = dict[OrderKey, Order]
+    value = {OrderKey("A", 3): Order("O1", "item1", 10.0), OrderKey("B", 4): Order("O2", "item2", 20.0)}
+    encoded = encode_engine_value(value)
+    assert encoded == [[["A", 3], "O1", "item1", 10.0, "default_extra"],
+                       [["B", 4], "O2", "item2", 20.0, "default_extra"]]
+    decoded = build_engine_value_decoder(t)(encoded)
+    assert decoded == value
 
-def test_to_engine_value_empty_list():
-    assert to_engine_value([]) == []
-    assert to_engine_value([[]]) == [[]]
+IntVectorType = cocoindex.Vector[int, Literal[5]]
+def test_vector_as_vector() -> None:
+    value: IntVectorType = [1, 2, 3, 4, 5]
+    encoded = encode_engine_value(value)
+    assert encoded == [1, 2, 3, 4, 5]
+    decoded = build_engine_value_decoder(IntVectorType)(encoded)
+    assert decoded == value
 
-def test_to_engine_value_tuple():
-    assert to_engine_value(()) == []
-    assert to_engine_value((1, 2, 3)) == [1, 2, 3]
-    assert to_engine_value(((1, 2), (3, 4))) == [[1, 2], [3, 4]]
-    assert to_engine_value(([],)) == [[]]
-    assert to_engine_value(((),)) == [[]]
+ListIntType = list[int]
+def test_vector_as_list() -> None:
+    value: ListIntType = [1, 2, 3, 4, 5]
+    encoded = encode_engine_value(value)
+    assert encoded == [1, 2, 3, 4, 5]
+    decoded = build_engine_value_decoder(ListIntType)(encoded)
+    assert decoded == value
 
-def test_to_engine_value_none():
-    assert to_engine_value(None) is None

cocoindex/typing.py

@@ -5,9 +5,9 @@ import datetime
 import types
 import inspect
 import uuid
-from typing import Annotated, NamedTuple, Any, TypeVar, TYPE_CHECKING, overload
+from typing import Annotated, NamedTuple, Any, TypeVar, TYPE_CHECKING, overload, Sequence, Protocol, Generic, Literal
 
-class Vector(NamedTuple):
+class VectorInfo(NamedTuple):
     dim: int | None
 
 class TypeKind(NamedTuple):
@@ -21,7 +21,7 @@ class TypeAttr:
         self.key = key
         self.value = value
 
-Annotation = Vector | TypeKind | TypeAttr
+Annotation = TypeKind | TypeAttr | VectorInfo
 
 Float32 = Annotated[float, TypeKind('Float32')]
 Float64 = Annotated[float, TypeKind('Float64')]
@@ -30,29 +30,34 @@ Json = Annotated[Any, TypeKind('Json')]
 LocalDateTime = Annotated[datetime.datetime, TypeKind('LocalDateTime')]
 OffsetDateTime = Annotated[datetime.datetime, TypeKind('OffsetDateTime')]
 
-COLLECTION_TYPES = ('Table', 'List')
-
-R = TypeVar("R")
-
 if TYPE_CHECKING:
-    Table = Annotated[list[R], TypeKind('Table')]
-    List = Annotated[list[R], TypeKind('List')]
+    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):
+        """Vector[T, Dim] is a special typing alias for a list[T] with optional dimension info"""
 else:
-    # pylint: disable=too-few-public-methods
-    class Table:  # type: ignore[unreachable]
-        """
-        A Table type, which has a list of rows. The first field of each row is the key.
-        """
-        def __class_getitem__(cls, item: type[R]):
-            return Annotated[list[item], TypeKind('Table')]
-
-    # pylint: disable=too-few-public-methods
-    class List:  # type: ignore[unreachable]
-        """
-        A List type, which has a list of ordered rows.
-        """
-        def __class_getitem__(cls, item: type[R]):
-            return Annotated[list[item], TypeKind('List')]
+    class Vector:  # type: ignore[unreachable]
+        """ 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
+                elem_type = params
+                return Annotated[list[elem_type], VectorInfo(dim=None)]
+            else:
+                # Element type and dimension provided
+                elem_type, dim = params
+                if typing.get_origin(dim) is Literal:
+                    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'
+
+ElementType = type | tuple[type, type]
+
+def _is_struct_type(t) -> bool:
+    return isinstance(t, type) and dataclasses.is_dataclass(t)
 
 @dataclasses.dataclass
 class AnalyzedTypeInfo:
@@ -60,9 +65,12 @@ class AnalyzedTypeInfo:
     Analyzed info of a Python type.
     """
     kind: str
-    vector_info: Vector | None
-    elem_type: type | None
-    dataclass_type: type | None
+    vector_info: VectorInfo | None  # For Vector
+    elem_type: ElementType | None   # For Vector and Table
+
+    key_type: type | None           # For element of KTable
+    dataclass_type: type | None     # For Struct
+
     attrs: dict[str, Any] | None
     nullable: bool = False
 
@@ -70,6 +78,12 @@ def analyze_type_info(t) -> 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
+        return result
+
     annotations: tuple[Annotation, ...] = ()
     base_type = None
     nullable = False
@@ -98,33 +112,41 @@ def analyze_type_info(t) -> AnalyzedTypeInfo:
             if attrs is None:
                 attrs = dict()
             attrs[attr.key] = attr.value
-        elif isinstance(attr, Vector):
+        elif isinstance(attr, VectorInfo):
             vector_info = attr
         elif isinstance(attr, TypeKind):
             kind = attr.kind
 
     dataclass_type = None
     elem_type = None
-    if isinstance(t, type) and dataclasses.is_dataclass(t):
+    key_type = None
+    if _is_struct_type(t):
         if kind is None:
             kind = 'Struct'
         elif kind != 'Struct':
             raise ValueError(f"Unexpected type kind for struct: {kind}")
         dataclass_type = t
     elif base_type is collections.abc.Sequence or base_type is list:
+        args = typing.get_args(t)
+        elem_type = args[0]
+
         if kind is None:
-            kind = 'Vector' if vector_info is not None else 'List'
-        elif not (kind == 'Vector' or kind in COLLECTION_TYPES):
+            if _is_struct_type(elem_type):
+                kind = 'LTable'
+                if vector_info is not None:
+                    raise ValueError("Vector element must be a simple type, not a struct")
+            else:
+                kind = 'Vector'
+                if vector_info is None:
+                    vector_info = VectorInfo(dim=None)
+        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)
-        if len(args) != 1:
-            raise ValueError(f"{kind} must have exactly one type argument")
-        elem_type = args[0]
+        elem_type = (args[0], args[1])
+        kind = 'KTable'
     elif kind is None:
-        if base_type is collections.abc.Sequence or base_type is list:
-            kind = 'Vector' if vector_info is not None else 'List'
-        elif t is bytes:
+        if t is bytes:
             kind = 'Bytes'
         elif t is str:
             kind = 'Str'
@@ -145,20 +167,26 @@ def analyze_type_info(t) -> AnalyzedTypeInfo:
         else:
             raise ValueError(f"type unsupported yet: {t}")
 
-    return AnalyzedTypeInfo(kind=kind, vector_info=vector_info, elem_type=elem_type,
-                            dataclass_type=dataclass_type, attrs=attrs, nullable=nullable)
+    return AnalyzedTypeInfo(kind=kind, vector_info=vector_info,
+                            elem_type=elem_type, key_type=key_type, dataclass_type=dataclass_type,
+                            attrs=attrs, nullable=nullable)
 
-def _encode_fields_schema(dataclass_type: type) -> list[dict[str, Any]]:
+def _encode_fields_schema(dataclass_type: type, key_type: type | None = None) -> list[dict[str, Any]]:
     result = []
-    for field in dataclasses.fields(dataclass_type):
+    def add_field(name: str, t) -> None:
         try:
-            type_info = encode_enriched_type_info(analyze_type_info(field.type))
+            type_info = encode_enriched_type_info(analyze_type_info(t))
         except ValueError as e:
             e.add_note(f"Failed to encode annotation for field - "
-                       f"{dataclass_type.__name__}.{field.name}: {field.type}")
+                       f"{dataclass_type.__name__}.{name}: {t}")
             raise
-        type_info['name'] = field.name
+        type_info['name'] = name
         result.append(type_info)
+
+    if key_type is not None:
+        add_field(KEY_FIELD_NAME, key_type)
+    for field in dataclasses.fields(dataclass_type):
+        add_field(field.name, field.type)
     return result
 
 def _encode_type(type_info: AnalyzedTypeInfo) -> dict[str, Any]:
@@ -167,7 +195,7 @@ def _encode_type(type_info: AnalyzedTypeInfo) -> dict[str, Any]:
     if type_info.kind == 'Struct':
         if type_info.dataclass_type is None:
             raise ValueError("Struct type must have a dataclass type")
-        encoded_type['fields'] = _encode_fields_schema(type_info.dataclass_type)
+        encoded_type['fields'] = _encode_fields_schema(type_info.dataclass_type, type_info.key_type)
         if doc := inspect.getdoc(type_info.dataclass_type):
             encoded_type['description'] = doc
 
@@ -179,7 +207,7 @@ def _encode_type(type_info: AnalyzedTypeInfo) -> dict[str, Any]:
         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 COLLECTION_TYPES:
+    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)

{cocoindex-0.1.25.dist-info → cocoindex-0.1.27.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cocoindex
-Version: 0.1.25
+Version: 0.1.27
 Requires-Dist: sentence-transformers>=3.3.1
 Requires-Dist: click>=8.1.8
 Requires-Dist: pytest ; extra == 'test'
@@ -117,7 +117,7 @@ Go to the [examples directory](examples) to try out with any of the examples, fo
 | [PDF Embedding](examples/pdf_embedding) | Parse PDF and index text embeddings for semantic search |
 | [Manuals LLM Extraction](examples/manuals_llm_extraction) | Extract structured information from a manual using LLM |
 | [Google Drive Text Embedding](examples/gdrive_text_embedding) | Index text documents from Google Drive |
-| [Docs to Knowledge Graph](examples/docs_to_kg) | Extract relationships from Markdown documents and build a knowledge graph |
+| [Docs to Knowledge Graph](examples/docs_to_knowledge_graph) | Extract relationships from Markdown documents and build a knowledge graph |
 | [Embeddings to Qdrant](examples/text_embedding_qdrant) | Index documents in a Qdrant collection for semantic search |
 
 More coming and stay tuned! If there's any specific examples you would like to see, please let us know in our [Discord community](https://discord.com/invite/zpA9S2DR7s) 🌱.

cocoindex-0.1.27.dist-info/RECORD

@@ -0,0 +1,24 @@
+cocoindex-0.1.27.dist-info/METADATA,sha256=O6XL0i2OUPY0KehlPYXxywyfX6uMdNk1xuTYxdJOcnA,8209
+cocoindex-0.1.27.dist-info/WHEEL,sha256=tAGdc4C2KTz7B2CZ8Jf3DcKSAviAbCg44UH9ma2gYww,96
+cocoindex-0.1.27.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+cocoindex/auth_registry.py,sha256=QQI8P7NMvA_NFIHXzV-yS94wVaZuXaIjY992Vrcii1E,641
+cocoindex/cli.py,sha256=kX2PQx7MJYX9UBGvyzIMqpzZSJfZA-NQJl9QI3m1ICU,7252
+cocoindex/convert.py,sha256=M8wRr38AgPpd43eklyWpNMaAvKHsIEyy_L3IlU7Q0oA,6095
+cocoindex/flow.py,sha256=Gu9uwDtoNz7IWnQFX6GtaSgee1NpODT1_4qS90OxqaE,21672
+cocoindex/functions.py,sha256=2yPL_s908AFxb6vVleFOVs8-6SCyT5cO-M7JLDqVFzA,1694
+cocoindex/index.py,sha256=32iiQI60VKhRRHle17rpoEVa_tsAHnyXXXnrLaX68uQ,557
+cocoindex/lib.py,sha256=V1bNKH6lpb1WT4f4F_4qD7e4Uarq-sS-donKXH5PjFo,4001
+cocoindex/llm.py,sha256=POMdB-huMvPkRDpvcaBeOgXfbm0YZa0swNOdD2s4TRc,364
+cocoindex/op.py,sha256=SYjXRlMxi304OcuOLPGlovv3CYa_DeQUunx4YJjmRc0,10871
+cocoindex/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cocoindex/query.py,sha256=GU3V8AoSK--xOU2yX0Ao-Rz1t3mlrsJ4JIhzsLVwFH8,3297
+cocoindex/runtime.py,sha256=WwyDSpJhvaHjnxH4q6r2MVftJB-QkNVH_TxZLxuDtFw,1009
+cocoindex/setup.py,sha256=euHPZ9-7a68DV4PbdK2A0cZ9ECa6vT4qBraY3WKZk4s,512
+cocoindex/sources.py,sha256=4JWsW7sjFuiizaxOkxXJpZgVmVgF9ys9ATvvRY-SBjE,966
+cocoindex/storages.py,sha256=AYYua_rzDUyvYb2ou3YFjO3jvRUcJKUTQlIYZzoTDnE,2036
+cocoindex/tests/test_convert.py,sha256=l5VpBgDw8F-0eMT_kEitUQTyI5newGnxqsm3gb6c2XA,11516
+cocoindex/tests/__init__.py,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+cocoindex/typing.py,sha256=RP322ATJqGkHkC7ht0s0tuRMg39CeNKUhk3cR_f78EY,8705
+cocoindex/__init__.py,sha256=FZo8bM7rmJ3Ppg_ysAjjlWxiHPQPrNNwyHb4V-onXT0,673
+cocoindex/_engine.cp311-win_amd64.pyd,sha256=79tgqK7SCVNjQldNdOWBdZRNynaQviO03U8C5FFwJpM,58859008
+cocoindex-0.1.27.dist-info/RECORD,,

cocoindex-0.1.25.dist-info/RECORD

@@ -1,24 +0,0 @@
-cocoindex-0.1.25.dist-info/METADATA,sha256=-ufLCvjdS1aeIfab5HeYCq0rwMWGp5L98HNWnjijtL8,8196
-cocoindex-0.1.25.dist-info/WHEEL,sha256=tAGdc4C2KTz7B2CZ8Jf3DcKSAviAbCg44UH9ma2gYww,96
-cocoindex-0.1.25.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-cocoindex/auth_registry.py,sha256=QQI8P7NMvA_NFIHXzV-yS94wVaZuXaIjY992Vrcii1E,641
-cocoindex/cli.py,sha256=-7lJjjXQbgYZTgsbrH9yl1DvWz-8vwPCmaWHKX_IdCM,7119
-cocoindex/convert.py,sha256=BIIc2YGr3bc5zVgn4M_kcJeAyVkbl7YJ1ZVNgYIAmpQ,5144
-cocoindex/flow.py,sha256=izi6qxDAB35_rYuyc62-J2Petq88iIs6qBEHLBdm_3Q,20560
-cocoindex/functions.py,sha256=kF4GUK1uvCu4IE5MLlCidoGyONp3b6lm47qcjMaFCtg,1704
-cocoindex/index.py,sha256=32iiQI60VKhRRHle17rpoEVa_tsAHnyXXXnrLaX68uQ,557
-cocoindex/lib.py,sha256=FTzT07U1dxjP1QsMDLndD4pBem7Baerf1ZbSaVq-OVM,3582
-cocoindex/llm.py,sha256=t6EcAYM17tl7UgMSAizSRbXF8M96g3tQdynASLsqx6I,312
-cocoindex/op.py,sha256=ee9Zu0pNygALCb9iPHPGqjQhD2PnNFcdVNPIezMEcPw,10609
-cocoindex/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cocoindex/query.py,sha256=FO_w1lsh4-lu7wPqkEDcZyvqKeis3e3Bq1L1h--91fg,3364
-cocoindex/runtime.py,sha256=R7FBysOH-4TL75cZNeDvAeEZ5jNmJ0m0zfkSUE7l0Lg,713
-cocoindex/setup.py,sha256=euHPZ9-7a68DV4PbdK2A0cZ9ECa6vT4qBraY3WKZk4s,512
-cocoindex/sources.py,sha256=4JWsW7sjFuiizaxOkxXJpZgVmVgF9ys9ATvvRY-SBjE,966
-cocoindex/storages.py,sha256=zICYAP3qHSFbGiVuNJNqn73-P6waNoBnU_SKOPfeygc,1882
-cocoindex/tests/test_convert.py,sha256=usmtQ7O91FYCfw131dxtmOrpFHo5I1zS-CFjPs8eHAs,2127
-cocoindex/tests/__init__.py,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-cocoindex/typing.py,sha256=SlO_QNa8lLJIdqJgESxISNsP7LSThC5DoWvFDcSgHK8,7501
-cocoindex/__init__.py,sha256=hdpaL27JWb9Jr1I0gVaZa9QffBLxb_MABkEcNTfU524,583
-cocoindex/_engine.cp311-win_amd64.pyd,sha256=aJ4bqXJtDQXCcfYWTCg0D7Aeymd96EDa2FqMbL9-KRA,58040832
-cocoindex-0.1.25.dist-info/RECORD,,