cocoindex 0.1.70__cp311-cp311-win_amd64.whl → 0.1.72__cp311-cp311-win_amd64.whl

cocoindex/__init__.py

@@ -38,6 +38,7 @@ __all__ = [
     "targets",
     "storages",
     "cli",
+    "op",
     "utils",
     # Auth registry
     "AuthEntryReference",

cocoindex/convert.py

@@ -92,10 +92,14 @@ def make_engine_value_decoder(
         if src_type_kind == "Struct":
             return _make_engine_struct_to_dict_decoder(field_path, src_type["fields"])
         if 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."
-            )
+            if src_type_kind == "LTable":
+                return _make_engine_ltable_to_list_dict_decoder(
+                    field_path, src_type["row"]["fields"]
+                )
+            elif src_type_kind == "KTable":
+                return _make_engine_ktable_to_dict_dict_decoder(
+                    field_path, src_type["row"]["fields"]
+                )
         return lambda value: value
 
     # Handle struct -> dict binding for explicit dict annotations
@@ -340,6 +344,77 @@ def _make_engine_struct_to_dict_decoder(
     return decode_to_dict
 
 
+def _make_engine_ltable_to_list_dict_decoder(
+    field_path: list[str],
+    src_fields: list[dict[str, Any]],
+) -> Callable[[list[Any] | None], list[dict[str, Any]] | None]:
+    """Make a decoder from engine LTable values to a list of dicts."""
+
+    # Create a decoder for each row (struct) to dict
+    row_decoder = _make_engine_struct_to_dict_decoder(field_path, src_fields)
+
+    def decode_to_list_dict(values: list[Any] | None) -> list[dict[str, Any]] | None:
+        if values is None:
+            return None
+        result = []
+        for i, row_values in enumerate(values):
+            decoded_row = row_decoder(row_values)
+            if decoded_row is None:
+                raise ValueError(
+                    f"LTable row at index {i} decoded to None, which is not allowed."
+                )
+            result.append(decoded_row)
+        return result
+
+    return decode_to_list_dict
+
+
+def _make_engine_ktable_to_dict_dict_decoder(
+    field_path: list[str],
+    src_fields: list[dict[str, Any]],
+) -> Callable[[list[Any] | None], dict[Any, dict[str, Any]] | None]:
+    """Make a decoder from engine KTable values to a dict of dicts."""
+
+    if not src_fields:
+        raise ValueError("KTable must have at least one field for the key")
+
+    # First field is the key, remaining fields are the value
+    key_field_schema = src_fields[0]
+    value_fields_schema = src_fields[1:]
+
+    # Create decoders
+    field_path.append(f".{key_field_schema.get('name', KEY_FIELD_NAME)}")
+    key_decoder = make_engine_value_decoder(field_path, key_field_schema["type"], Any)
+    field_path.pop()
+
+    value_decoder = _make_engine_struct_to_dict_decoder(field_path, value_fields_schema)
+
+    def decode_to_dict_dict(
+        values: list[Any] | None,
+    ) -> dict[Any, dict[str, Any]] | None:
+        if values is None:
+            return None
+        result = {}
+        for row_values in values:
+            if not row_values:
+                raise ValueError("KTable row must have at least 1 value (the key)")
+            key = key_decoder(row_values[0])
+            if len(row_values) == 1:
+                value: dict[str, Any] = {}
+            else:
+                tmp = value_decoder(row_values[1:])
+                if tmp is None:
+                    value = {}
+                else:
+                    value = tmp
+            if isinstance(key, dict):
+                key = tuple(key.values())
+            result[key] = value
+        return result
+
+    return decode_to_dict_dict
+
+
 def dump_engine_object(v: Any) -> Any:
     """Recursively dump an object for engine. Engine side uses `Pythonized` to catch."""
     if v is None:

cocoindex/flow.py

@@ -10,6 +10,13 @@ import functools
 import inspect
 import re
 
+from .validation import (
+    validate_flow_name,
+    NamingError,
+    validate_full_flow_name,
+    validate_target_name,
+)
+
 from dataclasses import dataclass
 from enum import Enum
 from threading import Lock
@@ -300,6 +307,9 @@ class DataScope:
         )
 
     def __setitem__(self, field_name: str, value: DataSlice[T]) -> None:
+        from .validation import validate_field_name
+
+        validate_field_name(field_name)
         value._state.attach_to_scope(self._engine_data_scope, field_name)
 
     def __enter__(self) -> DataScope:
@@ -367,7 +377,7 @@ class DataCollector:
 
     def export(
         self,
-        name: str,
+        target_name: str,
         target_spec: op.TargetSpec,
         /,
         *,
@@ -381,6 +391,8 @@ class DataCollector:
 
         `vector_index` is for backward compatibility only. Please use `vector_indexes` instead.
         """
+
+        validate_target_name(target_name)
         if not isinstance(target_spec, op.TargetSpec):
             raise ValueError(
                 "export() can only be called on a CocoIndex target storage"
@@ -398,7 +410,7 @@ class DataCollector:
             vector_indexes=vector_indexes,
         )
         self._flow_builder_state.engine_flow_builder.export(
-            name,
+            target_name,
             _spec_kind(target_spec),
             dump_engine_object(target_spec),
             dump_engine_object(index_options),
@@ -660,6 +672,8 @@ class Flow:
     def __init__(
         self, name: str, full_name: str, engine_flow_creator: Callable[[], _engine.Flow]
     ):
+        validate_flow_name(name)
+        validate_full_flow_name(full_name)
         self._name = name
         self._full_name = full_name
         engine_flow = None
@@ -831,11 +845,6 @@ def get_flow_full_name(name: str) -> str:
 
 
 def add_flow_def(name: str, fl_def: Callable[[FlowBuilder, DataScope], None]) -> Flow:
-    """Add a flow definition to the cocoindex library."""
-    if not all(c.isalnum() or c == "_" for c in name):
-        raise ValueError(
-            f"Flow name '{name}' contains invalid characters. Only alphanumeric characters and underscores are allowed."
-        )
     with _flows_lock:
         if name in _flows:
             raise KeyError(f"Flow with name {name} already exists")

cocoindex/functions.py

@@ -66,14 +66,19 @@ class SentenceTransformerEmbed(op.FunctionSpec):
     args: dict[str, Any] | None = None
 
 
-@op.executor_class(gpu=True, cache=True, behavior_version=1)
+@op.executor_class(
+    gpu=True,
+    cache=True,
+    behavior_version=1,
+    arg_relationship=(op.ArgRelationship.EMBEDDING_ORIGIN_TEXT, "text"),
+)
 class SentenceTransformerEmbedExecutor:
     """Executor for SentenceTransformerEmbed."""
 
     spec: SentenceTransformerEmbed
     _model: Any | None = None
 
-    def analyze(self, text: Any) -> type:
+    def analyze(self, _text: Any) -> type:
         try:
             # Only import sentence_transformers locally when it's needed, as its import is very slow.
             import sentence_transformers  # pylint: disable=import-outside-toplevel
@@ -88,11 +93,7 @@ class SentenceTransformerEmbedExecutor:
         args = self.spec.args or {}
         self._model = sentence_transformers.SentenceTransformer(self.spec.model, **args)
         dim = self._model.get_sentence_embedding_dimension()
-        result: type = Annotated[
-            Vector[np.float32, Literal[dim]],  # type: ignore
-            TypeAttr("cocoindex.io/vector_origin_text", text.analyzed_value),
-        ]
-        return result
+        return Vector[np.float32, Literal[dim]]  # type: ignore
 
     def __call__(self, text: str) -> NDArray[np.float32]:
         assert self._model is not None

cocoindex/op.py

@@ -6,11 +6,11 @@ import asyncio
 import dataclasses
 import inspect
 from enum import Enum
-from typing import Any, Awaitable, Callable, Protocol, dataclass_transform
+from typing import Any, Awaitable, Callable, Protocol, dataclass_transform, Annotated
 
 from . import _engine  # type: ignore
 from .convert import encode_engine_value, make_engine_value_decoder
-from .typing import encode_enriched_type, resolve_forward_ref
+from .typing import TypeAttr, encode_enriched_type, resolve_forward_ref
 
 
 class OpCategory(Enum):
@@ -85,6 +85,17 @@ class _FunctionExecutorFactory:
 _gpu_dispatch_lock = asyncio.Lock()
 
 
+_COCOINDEX_ATTR_PREFIX = "cocoindex.io/"
+
+
+class ArgRelationship(Enum):
+    """Specifies the relationship between an input argument and the output."""
+
+    EMBEDDING_ORIGIN_TEXT = _COCOINDEX_ATTR_PREFIX + "embedding_origin_text"
+    CHUNKS_BASE_TEXT = _COCOINDEX_ATTR_PREFIX + "chunk_base_text"
+    RECTS_BASE_IMAGE = _COCOINDEX_ATTR_PREFIX + "rects_base_image"
+
+
 @dataclasses.dataclass
 class OpArgs:
     """
@@ -92,11 +103,15 @@ class OpArgs:
     - cache: Whether the executor will be cached.
     - behavior_version: The behavior version of the executor. Cache will be invalidated if it
       changes. Must be provided if `cache` is True.
+    - arg_relationship: It specifies the relationship between an input argument and the output,
+      e.g. `(ArgRelationship.CHUNKS_BASE_TEXT, "content")` means the output is chunks for the
+      input argument with name `content`.
     """
 
     gpu: bool = False
     cache: bool = False
     behavior_version: int | None = None
+    arg_relationship: tuple[ArgRelationship, str] | None = None
 
 
 def _to_async_call(call: Callable[..., Any]) -> Callable[..., Awaitable[Any]]:
@@ -143,6 +158,15 @@ def _register_op_factory(
             """
             self._args_decoders = []
             self._kwargs_decoders = {}
+            attributes = []
+
+            def process_attribute(arg_name: str, arg: _engine.OpArgSchema) -> None:
+                if op_args.arg_relationship is not None:
+                    related_attr, related_arg_name = op_args.arg_relationship
+                    if related_arg_name == arg_name:
+                        attributes.append(
+                            TypeAttr(related_attr.value, arg.analyzed_value)
+                        )
 
             # Match arguments with parameters.
             next_param_idx = 0
@@ -164,6 +188,7 @@ def _register_op_factory(
                         [arg_name], arg.value_type["type"], arg_param.annotation
                     )
                 )
+                process_attribute(arg_name, arg)
                 if arg_param.kind != inspect.Parameter.VAR_POSITIONAL:
                     next_param_idx += 1
 
@@ -194,6 +219,7 @@ def _register_op_factory(
                 self._kwargs_decoders[kwarg_name] = make_engine_value_decoder(
                     [kwarg_name], kwarg.value_type["type"], arg_param.annotation
                 )
+                process_attribute(kwarg_name, kwarg)
 
             missing_args = [
                 name
@@ -216,9 +242,12 @@ def _register_op_factory(
 
             prepare_method = getattr(executor_cls, "analyze", None)
             if prepare_method is not None:
-                return prepare_method(self, *args, **kwargs)
+                result = prepare_method(self, *args, **kwargs)
             else:
-                return expected_return
+                result = expected_return
+            if len(attributes) > 0:
+                result = Annotated[result, *attributes]
+            return result
 
         async def prepare(self) -> None:
             """

cocoindex/setting.py

@@ -6,6 +6,7 @@ import os
 
 from typing import Callable, Self, Any, overload
 from dataclasses import dataclass
+from .validation import validate_app_namespace_name
 
 _app_namespace: str = ""
 
@@ -27,6 +28,8 @@ def split_app_namespace(full_name: str, delimiter: str) -> tuple[str, str]:
 
 def set_app_namespace(app_namespace: str) -> None:
     """Set the application namespace."""
+    if app_namespace:
+        validate_app_namespace_name(app_namespace)
     global _app_namespace  # pylint: disable=global-statement
     _app_namespace = app_namespace
 

cocoindex/tests/test_convert.py

@@ -1341,3 +1341,130 @@ def test_roundtrip_namedtuple_to_dict_binding() -> None:
     validate_full_roundtrip(
         instance, Point, (expected_dict, dict), (expected_dict, Any)
     )
+
+
+def test_roundtrip_ltable_to_list_dict_binding() -> None:
+    """Test LTable -> list[dict] binding with Any annotation."""
+
+    @dataclass
+    class User:
+        id: str
+        name: str
+        age: int
+
+    users = [User("u1", "Alice", 25), User("u2", "Bob", 30), User("u3", "Charlie", 35)]
+    expected_list_dict = [
+        {"id": "u1", "name": "Alice", "age": 25},
+        {"id": "u2", "name": "Bob", "age": 30},
+        {"id": "u3", "name": "Charlie", "age": 35},
+    ]
+
+    # Test Any annotation
+    validate_full_roundtrip(users, list[User], (expected_list_dict, Any))
+
+
+def test_roundtrip_ktable_to_dict_dict_binding() -> None:
+    """Test KTable -> dict[K, dict] binding with Any annotation."""
+
+    @dataclass
+    class Product:
+        name: str
+        price: float
+        active: bool
+
+    products = {
+        "p1": Product("Widget", 29.99, True),
+        "p2": Product("Gadget", 49.99, False),
+        "p3": Product("Tool", 19.99, True),
+    }
+    expected_dict_dict = {
+        "p1": {"name": "Widget", "price": 29.99, "active": True},
+        "p2": {"name": "Gadget", "price": 49.99, "active": False},
+        "p3": {"name": "Tool", "price": 19.99, "active": True},
+    }
+
+    # Test Any annotation
+    validate_full_roundtrip(products, dict[str, Product], (expected_dict_dict, Any))
+
+
+def test_roundtrip_ktable_with_complex_key() -> None:
+    """Test KTable with complex key types -> dict binding."""
+
+    @dataclass(frozen=True)
+    class OrderKey:
+        shop_id: str
+        version: int
+
+    @dataclass
+    class Order:
+        customer: str
+        total: float
+
+    orders = {
+        OrderKey("shop1", 1): Order("Alice", 100.0),
+        OrderKey("shop2", 2): Order("Bob", 200.0),
+    }
+    expected_dict_dict = {
+        ("shop1", 1): {"customer": "Alice", "total": 100.0},
+        ("shop2", 2): {"customer": "Bob", "total": 200.0},
+    }
+
+    # Test Any annotation
+    validate_full_roundtrip(orders, dict[OrderKey, Order], (expected_dict_dict, Any))
+
+
+def test_roundtrip_ltable_with_nested_structs() -> None:
+    """Test LTable with nested structs -> list[dict] binding."""
+
+    @dataclass
+    class Address:
+        street: str
+        city: str
+
+    @dataclass
+    class Person:
+        name: str
+        age: int
+        address: Address
+
+    people = [
+        Person("John", 30, Address("123 Main St", "Anytown")),
+        Person("Jane", 25, Address("456 Oak Ave", "Somewhere")),
+    ]
+    expected_list_dict = [
+        {
+            "name": "John",
+            "age": 30,
+            "address": {"street": "123 Main St", "city": "Anytown"},
+        },
+        {
+            "name": "Jane",
+            "age": 25,
+            "address": {"street": "456 Oak Ave", "city": "Somewhere"},
+        },
+    ]
+
+    # Test Any annotation
+    validate_full_roundtrip(people, list[Person], (expected_list_dict, Any))
+
+
+def test_roundtrip_ktable_with_list_fields() -> None:
+    """Test KTable with list fields -> dict binding."""
+
+    @dataclass
+    class Team:
+        name: str
+        members: list[str]
+        active: bool
+
+    teams = {
+        "team1": Team("Dev Team", ["Alice", "Bob"], True),
+        "team2": Team("QA Team", ["Charlie", "David"], False),
+    }
+    expected_dict_dict = {
+        "team1": {"name": "Dev Team", "members": ["Alice", "Bob"], "active": True},
+        "team2": {"name": "QA Team", "members": ["Charlie", "David"], "active": False},
+    }
+
+    # Test Any annotation
+    validate_full_roundtrip(teams, dict[str, Team], (expected_dict_dict, Any))

cocoindex/tests/test_validation.py

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

cocoindex/validation.py

@@ -0,0 +1,104 @@
+"""
+Naming validation for CocoIndex identifiers.
+
+This module enforces naming conventions for flow names, field names,
+target names, and app namespace names as specified in issue #779.
+"""
+
+import re
+from typing import Optional
+
+_IDENTIFIER_PATTERN = re.compile(r"^[a-zA-Z_][a-zA-Z0-9_]*$")
+_IDENTIFIER_WITH_DOTS_PATTERN = re.compile(r"^[a-zA-Z_][a-zA-Z0-9_.]*$")
+
+
+class NamingError(ValueError):
+    """Exception raised for naming convention violations."""
+
+    pass
+
+
+def validate_identifier_name(
+    name: str,
+    max_length: int = 64,
+    allow_dots: bool = False,
+    identifier_type: str = "identifier",
+) -> Optional[str]:
+    """
+    Validate identifier names according to CocoIndex naming rules.
+
+    Args:
+        name: The name to validate
+        max_length: Maximum allowed length (default 64)
+        allow_dots: Whether to allow dots in the name (for full flow names)
+        identifier_type: Type of identifier for error messages
+
+    Returns:
+        None if valid, error message string if invalid
+    """
+    if not name:
+        return f"{identifier_type} name cannot be empty"
+
+    if len(name) > max_length:
+        return f"{identifier_type} name '{name}' exceeds maximum length of {max_length} characters"
+
+    if name.startswith("__"):
+        return f"{identifier_type} name '{name}' cannot start with double underscores (reserved for internal usage)"
+
+    # Define allowed pattern
+    if allow_dots:
+        pattern = _IDENTIFIER_WITH_DOTS_PATTERN
+        allowed_chars = "letters, digits, underscores, and dots"
+    else:
+        pattern = _IDENTIFIER_PATTERN
+        allowed_chars = "letters, digits, and underscores"
+
+    if not pattern.match(name):
+        return f"{identifier_type} name '{name}' must start with a letter or underscore and contain only {allowed_chars}"
+
+    return None
+
+
+def validate_field_name(name: str) -> None:
+    """Validate field names."""
+    error = validate_identifier_name(
+        name, max_length=64, allow_dots=False, identifier_type="Field"
+    )
+    if error:
+        raise NamingError(error)
+
+
+def validate_flow_name(name: str) -> None:
+    """Validate flow names."""
+    error = validate_identifier_name(
+        name, max_length=64, allow_dots=False, identifier_type="Flow"
+    )
+    if error:
+        raise NamingError(error)
+
+
+def validate_full_flow_name(name: str) -> None:
+    """Validate full flow names (can contain dots for namespacing)."""
+    error = validate_identifier_name(
+        name, max_length=64, allow_dots=True, identifier_type="Full flow"
+    )
+    if error:
+        raise NamingError(error)
+
+
+def validate_app_namespace_name(name: str) -> None:
+    """Validate app namespace names."""
+    error = validate_identifier_name(
+        name, max_length=64, allow_dots=False, identifier_type="App namespace"
+    )
+    if error:
+        raise NamingError(error)
+
+
+def validate_target_name(name: str) -> None:
+    """Validate target names."""
+    error = validate_identifier_name(
+        name, max_length=64, allow_dots=False, identifier_type="Target"
+    )
+    if error:
+        raise NamingError(error)

{cocoindex-0.1.70.dist-info → cocoindex-0.1.72.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cocoindex
-Version: 0.1.70
+Version: 0.1.72
 Requires-Dist: click>=8.1.8
 Requires-Dist: rich>=14.0.0
 Requires-Dist: python-dotenv>=1.1.0
@@ -52,18 +52,18 @@ Ultra performant data transformation framework for AI, with core engine written
 ⭐ Drop a star to help us grow!
 
 <div align="center">
-    
+
 <!-- Keep these links. Translations will automatically update with the README. -->
-[Deutsch](https://readme-i18n.com/cocoindex-io/cocoindex?lang=de) | 
-[English](https://readme-i18n.com/cocoindex-io/cocoindex?lang=en) | 
-[Español](https://readme-i18n.com/cocoindex-io/cocoindex?lang=es) | 
-[français](https://readme-i18n.com/cocoindex-io/cocoindex?lang=fr) | 
-[日本語](https://readme-i18n.com/cocoindex-io/cocoindex?lang=ja) | 
-[한국어](https://readme-i18n.com/cocoindex-io/cocoindex?lang=ko) | 
-[Português](https://readme-i18n.com/cocoindex-io/cocoindex?lang=pt) | 
-[Русский](https://readme-i18n.com/cocoindex-io/cocoindex?lang=ru) | 
+[Deutsch](https://readme-i18n.com/cocoindex-io/cocoindex?lang=de) |
+[English](https://readme-i18n.com/cocoindex-io/cocoindex?lang=en) |
+[Español](https://readme-i18n.com/cocoindex-io/cocoindex?lang=es) |
+[français](https://readme-i18n.com/cocoindex-io/cocoindex?lang=fr) |
+[日本語](https://readme-i18n.com/cocoindex-io/cocoindex?lang=ja) |
+[한국어](https://readme-i18n.com/cocoindex-io/cocoindex?lang=ko) |
+[Português](https://readme-i18n.com/cocoindex-io/cocoindex?lang=pt) |
+[Русский](https://readme-i18n.com/cocoindex-io/cocoindex?lang=ru) |
 [中文](https://readme-i18n.com/cocoindex-io/cocoindex?lang=zh)
-    
+
 </div>
 
 </br>
@@ -208,6 +208,7 @@ It defines an index flow like this:
 | [FastAPI Server with Docker](examples/fastapi_server_docker) | Run the semantic search server in a Dockerized FastAPI setup |
 | [Product Recommendation](examples/product_recommendation) | Build real-time product recommendations with LLM and graph database|
 | [Image Search with Vision API](examples/image_search) | Generates detailed captions for images using a vision model, embeds them, enables live-updating semantic search via FastAPI and served on a React frontend|
+| [Face Recognition](examples/face_recognition) | Recognize faces in images and build embedding index |
 | [Paper Metadata](examples/paper_metadata) | Index papers in PDF files, and build metadata tables for each paper |
 
 More coming and stay tuned 👀!

{cocoindex-0.1.70.dist-info → cocoindex-0.1.72.dist-info}/RECORD

@@ -1,28 +1,30 @@
-cocoindex-0.1.70.dist-info/METADATA,sha256=4mFNelKh4RZNnPXiqDr1KOQoyBpL6ysW0ff7M5-MMIQ,11426
-cocoindex-0.1.70.dist-info/WHEEL,sha256=auo2gA2SV-bvS4ssY6DIG7dtu3SpmB5FcBkwIwO6YZk,96
-cocoindex-0.1.70.dist-info/entry_points.txt,sha256=_NretjYVzBdNTn7dK-zgwr7YfG2afz1u1uSE-5bZXF8,46
-cocoindex-0.1.70.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-cocoindex/__init__.py,sha256=gN0v1r7nktqXGcVld4s1fmdCG9l1J_xRO56Jxu_yXOQ,2193
-cocoindex/_engine.cp311-win_amd64.pyd,sha256=UOvbowU48GTZmnbGHlokQgu5cG3-djm7B1Ycykxpkp8,70170624
+cocoindex-0.1.72.dist-info/METADATA,sha256=qD-MFwBDoEkZmGKDcz0wB9FiQuXsXP6nMApfhSoLkks,11515
+cocoindex-0.1.72.dist-info/WHEEL,sha256=auo2gA2SV-bvS4ssY6DIG7dtu3SpmB5FcBkwIwO6YZk,96
+cocoindex-0.1.72.dist-info/entry_points.txt,sha256=_NretjYVzBdNTn7dK-zgwr7YfG2afz1u1uSE-5bZXF8,46
+cocoindex-0.1.72.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+cocoindex/__init__.py,sha256=1u3kotLS9MDAj4jY4jN5rRuu39B3DH_wL2LAS2VFC5Y,2204
+cocoindex/_engine.cp311-win_amd64.pyd,sha256=PHp3WdbsiMxuRgsv5dAtsRCeJ0t2rKnLwlLzULayzcw,70187520
 cocoindex/auth_registry.py,sha256=Qq1IVZb-7K4luRrQSDlOPbISnGEZ4kIDsrCU8H2ARw0,1529
 cocoindex/cli.py,sha256=zjZv7EH-ZLoO1-3Ua2U7Yt3n2A_T7pN2NCuv7FB8WA0,23097
-cocoindex/convert.py,sha256=iz7lYydzh1ClMdXl2sc8HiidPp186YY4qXVI133g5u0,13487
-cocoindex/flow.py,sha256=On0J6-3_3uPg-2TjzU3yans_4t_9vchrkH5BpGkbLMo,37203
-cocoindex/functions.py,sha256=pt4Zs_ybz1fBPrwLbgTxHN4yL41SX4IrNGeB5tahzno,3262
+cocoindex/convert.py,sha256=xZXkzZiUQktrGYY0GYGMeK2xi5cTyUN55g2FkA5F80w,16251
+cocoindex/flow.py,sha256=GF7YlgdZfK1F50yXJaSrWmCWP1g6CeUCp7ay1c4okYc,37293
+cocoindex/functions.py,sha256=ERtlJJ_D5xNSL4nE6FiqMseX4aAuqsTG6RvJVBC_LPE,3210
 cocoindex/index.py,sha256=GrqTm1rLwICQ8hadtNvJAxVg7GWMvtMmFcbiNtNzmP0,569
 cocoindex/lib.py,sha256=cZosix4nwROvod4QJOwCzrm6U1CVy_wKMMk7sDDG_Z0,849
 cocoindex/llm.py,sha256=TDUyTxW7ooFmpA_jDNezABhReXksOXN8F8zY9aiuNTw,709
-cocoindex/op.py,sha256=h1bp56NEVxCRrOjzyta1h52u6d9Vol_Qau9Pv1sUlVE,12141
+cocoindex/op.py,sha256=6RRlzNf3rq5q1TNxNB8nv9OOee22dHyk9LZ2fD-K20s,13522
 cocoindex/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cocoindex/runtime.py,sha256=6mE-jR1Kh5c4GETDvBgwjXZq69TK5rh1qNpaseRDZnw,1117
-cocoindex/setting.py,sha256=E_5Z_MqDt6vaMcqPNA67QB7h_36OBcNu50EN3WjNDts,4898
+cocoindex/setting.py,sha256=KkWDDJ6-BVtzW41ygnpxFjx3mzVRbA3F8LnhzAkTSDc,5026
 cocoindex/setup.py,sha256=KbJvmeFu0NbeoH-5iDmHZP86f26HIId8kHmGUNZAePI,3160
 cocoindex/sources.py,sha256=DEEfJGrz0eG9dFF-sjn7ddbebHfqPpbyN5KXYagbZ50,2152
 cocoindex/targets.py,sha256=7FfG9kuEf5KTXtLwXMFaPFIut3PsIbpb3XIEjjeF7Bg,2931
 cocoindex/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cocoindex/tests/test_convert.py,sha256=zgWJlhnx8QCnvAD92U2BbFchQgYmFv3hbX532RqVMkk,46793
+cocoindex/tests/test_convert.py,sha256=yVWlR2QMfwdzSXBVIi0eFeQ8k9Xvu8vLGgBhzwS1-ng,50430
 cocoindex/tests/test_optional_database.py,sha256=dnzmTgaJf37D3q8fQsjP5UDER6FYETaUokDnFBMLtIk,8755
 cocoindex/tests/test_typing.py,sha256=YHQonf49SPxic8wnZC_5UmltwS5eAa5VNTH0aVwccBQ,15373
+cocoindex/tests/test_validation.py,sha256=I4wr8lAMAjmy5xgG5N_OJKveXt8XIa96MsQTXhw5AnA,4677
 cocoindex/typing.py,sha256=wVjfugSYNXK9H11pPjXci2X2EyvS5eoILAQ3a0H8VLs,13656
 cocoindex/utils.py,sha256=U3W39zD2uZpXX8v84tJD7sRmbC5ar3z_ljAP1cJrYXI,618
-cocoindex-0.1.70.dist-info/RECORD,,
+cocoindex/validation.py,sha256=4ZjsW-SZT8X_TEEhEE6QG6D-8Oq_TkPAhTqP0mdFYSE,3194
+cocoindex-0.1.72.dist-info/RECORD,,