cocoindex 0.1.53__cp311-cp311-win_amd64.whl → 0.1.55__cp311-cp311-win_amd64.whl

cocoindex/cli.py

@@ -1,19 +1,23 @@
-import click
+import atexit
 import datetime
-import sys
 import importlib.util
 import os
-import atexit
+import signal
+import sys
+import threading
 import types
+from types import FrameType
+from typing import Any
 
-from dotenv import load_dotenv, find_dotenv
+import click
+import watchfiles
+from dotenv import find_dotenv, load_dotenv
 from rich.console import Console
 from rich.panel import Panel
 from rich.table import Table
-from typing import Any
 
 from . import flow, lib, setting
-from .setup import sync_setup, drop_setup, flow_names_with_setup, apply_setup_changes
+from .setup import apply_setup_changes, drop_setup, flow_names_with_setup, sync_setup
 
 # Create ServerSettings lazily upon first call, as environment variables may be loaded from files, etc.
 COCOINDEX_HOST = "https://cocoindex.io"
@@ -116,6 +120,12 @@ def _load_user_app(app_target: str) -> types.ModuleType:
         )
 
 
+def _initialize_cocoindex_in_process() -> None:
+    settings = setting.Settings.from_env()
+    lib.init(settings)
+    atexit.register(lib.stop)
+
+
 @click.group()
 @click.version_option(package_name="cocoindex", message="%(prog)s version %(version)s")
 @click.option(
@@ -128,7 +138,7 @@ def _load_user_app(app_target: str) -> types.ModuleType:
     default=None,
     show_default=False,
 )
-def cli(env_file: str | None) -> None:
+def cli(env_file: str | None = None) -> None:
     """
     CLI for Cocoindex.
     """
@@ -139,9 +149,7 @@ def cli(env_file: str | None) -> None:
         click.echo(f"Loaded environment variables from: {loaded_env_path}", err=True)
 
     try:
-        settings = setting.Settings.from_env()
-        lib.init(settings)
-        atexit.register(lib.stop)
+        _initialize_cocoindex_in_process()
     except Exception as e:
         raise click.ClickException(f"Failed to initialize CocoIndex library: {e}")
 
@@ -485,6 +493,14 @@ def evaluate(
     default=False,
     help="Avoid printing anything to the standard output, e.g. statistics.",
 )
+@click.option(
+    "-r",
+    "--reload",
+    is_flag=True,
+    show_default=True,
+    default=False,
+    help="Enable auto-reload on code changes.",
+)
 def server(
     app_target: str,
     address: str | None,
@@ -493,6 +509,7 @@ def server(
     cors_origin: str | None,
     cors_cocoindex: bool,
     cors_local: int | None,
+    reload: bool,
 ) -> None:
     """
     Start a HTTP server providing REST APIs.
@@ -502,6 +519,58 @@ def server(
     APP_TARGET: path/to/app.py or installed_module.
     """
     app_ref = _get_app_ref_from_specifier(app_target)
+    args = (
+        app_ref,
+        address,
+        cors_origin,
+        cors_cocoindex,
+        cors_local,
+        live_update,
+        quiet,
+    )
+
+    if reload:
+        watch_paths = {os.getcwd()}
+        if os.path.isfile(app_ref):
+            watch_paths.add(os.path.dirname(os.path.abspath(app_ref)))
+        else:
+            try:
+                spec = importlib.util.find_spec(app_ref)
+                if spec and spec.origin:
+                    watch_paths.add(os.path.dirname(os.path.abspath(spec.origin)))
+            except ImportError:
+                pass
+
+        watchfiles.run_process(
+            *watch_paths,
+            target=_reloadable_server_target,
+            args=args,
+            watch_filter=watchfiles.PythonFilter(),
+            callback=lambda changes: click.secho(
+                f"\nDetected changes in {len(changes)} file(s), reloading server...\n",
+                fg="cyan",
+            ),
+        )
+    else:
+        _run_server(*args)
+
+
+def _reloadable_server_target(*args: Any, **kwargs: Any) -> None:
+    """Reloadable target for the watchfiles process."""
+    _initialize_cocoindex_in_process()
+    _run_server(*args, **kwargs)
+
+
+def _run_server(
+    app_ref: str,
+    address: str | None = None,
+    cors_origin: str | None = None,
+    cors_cocoindex: bool = False,
+    cors_local: int | None = None,
+    live_update: bool = False,
+    quiet: bool = False,
+) -> None:
+    """Helper function to run the server with specified settings."""
     _load_user_app(app_ref)
 
     server_settings = setting.ServerSettings.from_env()
@@ -525,7 +594,17 @@ def server(
     if live_update:
         options = flow.FlowLiveUpdaterOptions(live_mode=True, print_stats=not quiet)
         flow.update_all_flows(options)
-    input("Press Enter to stop...")
+
+    click.secho("Press Ctrl+C to stop the server.", fg="yellow")
+
+    shutdown_event = threading.Event()
+
+    def handle_signal(signum: int, frame: FrameType | None) -> None:
+        shutdown_event.set()
+
+    signal.signal(signal.SIGINT, handle_signal)
+    signal.signal(signal.SIGTERM, handle_signal)
+    shutdown_event.wait()
 
 
 def _flow_name(name: str | None) -> str:

cocoindex/convert.py

@@ -14,6 +14,7 @@ import numpy as np
 from .typing import (
     KEY_FIELD_NAME,
     TABLE_TYPES,
+    AnalyzedTypeInfo,
     DtypeRegistry,
     analyze_type_info,
     encode_enriched_type,
@@ -41,11 +42,22 @@ def encode_engine_value(value: Any) -> Any:
         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
 
 
+_CONVERTIBLE_KINDS = {
+    ("Float32", "Float64"),
+    ("LocalDateTime", "OffsetDateTime"),
+}
+
+
+def _is_type_kind_convertible_to(src_type_kind: str, dst_type_kind: str) -> bool:
+    return (
+        src_type_kind == dst_type_kind
+        or (src_type_kind, dst_type_kind) in _CONVERTIBLE_KINDS
+    )
+
+
 def make_engine_value_decoder(
     field_path: list[str],
     src_type: dict[str, Any],
@@ -65,11 +77,20 @@ def make_engine_value_decoder(
 
     src_type_kind = src_type["kind"]
 
+    dst_type_info: AnalyzedTypeInfo | None = None
     if (
-        dst_annotation is None
-        or dst_annotation is inspect.Parameter.empty
-        or dst_annotation is Any
+        dst_annotation is not None
+        and dst_annotation is not inspect.Parameter.empty
+        and dst_annotation is not Any
     ):
+        dst_type_info = analyze_type_info(dst_annotation)
+        if not _is_type_kind_convertible_to(src_type_kind, dst_type_info.kind):
+            raise ValueError(
+                f"Type mismatch for `{''.join(field_path)}`: "
+                f"passed in {src_type_kind}, declared {dst_annotation} ({dst_type_info.kind})"
+            )
+
+    if dst_type_info is None:
         if src_type_kind == "Struct" or src_type_kind in TABLE_TYPES:
             raise ValueError(
                 f"Missing type annotation for `{''.join(field_path)}`."
@@ -77,32 +98,66 @@ def make_engine_value_decoder(
             )
         return lambda value: value
 
-    dst_type_info = analyze_type_info(dst_annotation)
+    if dst_type_info.kind in ("Float32", "Float64", "Int64"):
+        dst_core_type = dst_type_info.core_type
 
-    if src_type_kind != dst_type_info.kind:
-        raise ValueError(
-            f"Type mismatch for `{''.join(field_path)}`: "
-            f"passed in {src_type_kind}, declared {dst_annotation} ({dst_type_info.kind})"
-        )
+        def decode_scalar(value: Any) -> Any | None:
+            if value is None:
+                if dst_type_info.nullable:
+                    return None
+                raise ValueError(
+                    f"Received null for non-nullable scalar `{''.join(field_path)}`"
+                )
+            return dst_core_type(value)
 
-    if dst_type_info.struct_type is not None:
-        return _make_engine_struct_value_decoder(
-            field_path, src_type["fields"], dst_type_info.struct_type
+        return decode_scalar
+
+    if src_type_kind == "Vector":
+        field_path_str = "".join(field_path)
+        expected_dim = (
+            dst_type_info.vector_info.dim if dst_type_info.vector_info else None
         )
 
-    if dst_type_info.np_number_type is not None and src_type_kind != "Vector":
-        numpy_type = dst_type_info.np_number_type
+        elem_decoder = None
+        scalar_dtype = None
+        if dst_type_info.np_number_type is None:  # for Non-NDArray vector
+            elem_decoder = make_engine_value_decoder(
+                field_path + ["[*]"],
+                src_type["element_type"],
+                dst_type_info.elem_type,
+            )
+        else:  # for NDArray vector
+            scalar_dtype = extract_ndarray_scalar_dtype(dst_type_info.np_number_type)
+            _ = DtypeRegistry.validate_dtype_and_get_kind(scalar_dtype)
 
-        def decode_numpy_scalar(value: Any) -> Any | None:
+        def decode_vector(value: Any) -> Any | None:
             if value is None:
                 if dst_type_info.nullable:
                     return None
                 raise ValueError(
-                    f"Received null for non-nullable scalar `{''.join(field_path)}`"
+                    f"Received null for non-nullable vector `{field_path_str}`"
+                )
+            if not isinstance(value, (np.ndarray, list)):
+                raise TypeError(
+                    f"Expected NDArray or list for vector `{field_path_str}`, got {type(value)}"
+                )
+            if expected_dim is not None and len(value) != expected_dim:
+                raise ValueError(
+                    f"Vector dimension mismatch for `{field_path_str}`: "
+                    f"expected {expected_dim}, got {len(value)}"
                 )
-            return numpy_type(value)
 
-        return decode_numpy_scalar
+            if elem_decoder is not None:  # for Non-NDArray vector
+                return [elem_decoder(v) for v in value]
+            else:  # for NDArray vector
+                return np.array(value, dtype=scalar_dtype)
+
+        return decode_vector
+
+    if dst_type_info.struct_type is not None:
+        return _make_engine_struct_value_decoder(
+            field_path, src_type["fields"], dst_type_info.struct_type
+        )
 
     if src_type_kind in TABLE_TYPES:
         field_path.append("[*]")
@@ -141,48 +196,8 @@ def make_engine_value_decoder(
         field_path.pop()
         return decode
 
-    if src_type_kind == "Uuid":
-        return lambda value: uuid.UUID(bytes=value)
-
-    if src_type_kind == "Vector":
-
-        def decode_vector(value: Any) -> Any | None:
-            field_path_str = "".join(field_path)
-            expected_dim = (
-                dst_type_info.vector_info.dim if dst_type_info.vector_info else None
-            )
-
-            if value is None:
-                if dst_type_info.nullable:
-                    return None
-                raise ValueError(
-                    f"Received null for non-nullable vector `{field_path_str}`"
-                )
-            if not isinstance(value, (np.ndarray, list)):
-                raise TypeError(
-                    f"Expected NDArray or list for vector `{field_path_str}`, got {type(value)}"
-                )
-            if expected_dim is not None and len(value) != expected_dim:
-                raise ValueError(
-                    f"Vector dimension mismatch for `{field_path_str}`: "
-                    f"expected {expected_dim}, got {len(value)}"
-                )
-
-            if dst_type_info.np_number_type is None:  # for Non-NDArray vector
-                elem_decoder = make_engine_value_decoder(
-                    field_path + ["[*]"],
-                    src_type["element_type"],
-                    dst_type_info.elem_type,
-                )
-                return [elem_decoder(v) for v in value]
-            else:  # for NDArray vector
-                scalar_dtype = extract_ndarray_scalar_dtype(
-                    dst_type_info.np_number_type
-                )
-                _ = DtypeRegistry.validate_dtype_and_get_kind(scalar_dtype)
-                return np.array(value, dtype=scalar_dtype)
-
-        return decode_vector
+    if src_type_kind == "Union":
+        return lambda value: value[1]
 
     return lambda value: value
 

cocoindex/flow.py

@@ -92,6 +92,7 @@ def _spec_kind(spec: Any) -> str:
 
 
 T = TypeVar("T")
+S = TypeVar("S")
 
 
 class _DataSliceState:
@@ -185,7 +186,7 @@ class DataSlice(Generic[T]):
 
     def transform(
         self, fn_spec: op.FunctionSpec, *args: Any, **kwargs: Any
-    ) -> DataSlice[T]:
+    ) -> DataSlice[Any]:
         """
         Apply a function to the data slice.
         """
@@ -216,7 +217,7 @@ class DataSlice(Generic[T]):
             ),
         )
 
-    def call(self, func: Callable[[DataSlice[T]], T], *args: Any, **kwargs: Any) -> T:
+    def call(self, func: Callable[..., S], *args: Any, **kwargs: Any) -> S:
         """
         Call a function with the data slice.
         """

cocoindex/functions.py

@@ -32,6 +32,16 @@ class SplitRecursively(op.FunctionSpec):
     custom_languages: list[CustomLanguageSpec] = dataclasses.field(default_factory=list)
 
 
+class EmbedText(op.FunctionSpec):
+    """Embed a text into a vector space."""
+
+    api_type: llm.LlmApiType
+    model: str
+    address: str | None = None
+    output_dimension: int | None = None
+    task_type: str | None = None
+
+
 class ExtractByLlm(op.FunctionSpec):
     """Extract information from a text using a LLM."""
 

cocoindex/llm.py

@@ -11,6 +11,7 @@ class LlmApiType(Enum):
     ANTHROPIC = "Anthropic"
     LITE_LLM = "LiteLlm"
     OPEN_ROUTER = "OpenRouter"
+    VOYAGE = "Voyage"
 
 
 @dataclass

cocoindex/tests/__init__.py

@@ -1 +0,0 @@
-

cocoindex/tests/test_convert.py

@@ -91,23 +91,26 @@ def validate_full_roundtrip(
     """
     from cocoindex import _engine  # type: ignore
 
+    def eq(a: Any, b: Any) -> bool:
+        if isinstance(a, np.ndarray) and isinstance(b, np.ndarray):
+            return np.array_equal(a, b)
+        return type(a) == type(b) and not not (a == b)
+
     encoded_value = encode_engine_value(value)
     value_type = value_type or type(value)
     encoded_output_type = encode_enriched_type(value_type)["type"]
     value_from_engine = _engine.testutil.seder_roundtrip(
         encoded_value, encoded_output_type
     )
-    decoded_value = build_engine_value_decoder(value_type, value_type)(
-        value_from_engine
-    )
-    np.testing.assert_array_equal(decoded_value, value)
+    decoder = make_engine_value_decoder([], encoded_output_type, value_type)
+    decoded_value = decoder(value_from_engine)
+    assert eq(decoded_value, value)
 
     if other_decoded_values is not None:
         for other_value, other_type in other_decoded_values:
-            other_decoded_value = build_engine_value_decoder(other_type, other_type)(
-                value_from_engine
-            )
-            np.testing.assert_array_equal(other_decoded_value, other_value)
+            decoder = make_engine_value_decoder([], encoded_output_type, other_type)
+            other_decoded_value = decoder(value_from_engine)
+            assert eq(other_decoded_value, other_value)
 
 
 def test_encode_engine_value_basic_types() -> None:
@@ -119,7 +122,7 @@ def test_encode_engine_value_basic_types() -> None:
 
 def test_encode_engine_value_uuid() -> None:
     u = uuid.uuid4()
-    assert encode_engine_value(u) == u.bytes
+    assert encode_engine_value(u) == u
 
 
 def test_encode_engine_value_date_time_types() -> None:
@@ -215,19 +218,38 @@ def test_encode_engine_value_none() -> None:
 
 
 def test_roundtrip_basic_types() -> None:
-    validate_full_roundtrip(42, int)
+    validate_full_roundtrip(42, int, (42, None))
     validate_full_roundtrip(3.25, float, (3.25, Float64))
-    validate_full_roundtrip(3.25, Float64, (3.25, float))
-    validate_full_roundtrip(3.25, Float32)
-    validate_full_roundtrip("hello", str)
-    validate_full_roundtrip(True, bool)
-    validate_full_roundtrip(False, bool)
-    validate_full_roundtrip(datetime.date(2025, 1, 1), datetime.date)
-    validate_full_roundtrip(datetime.datetime.now(), cocoindex.LocalDateTime)
     validate_full_roundtrip(
-        datetime.datetime.now(datetime.UTC), cocoindex.OffsetDateTime
+        3.25, Float64, (3.25, float), (np.float64(3.25), np.float64)
+    )
+    validate_full_roundtrip(
+        3.25, Float32, (3.25, float), (np.float32(3.25), np.float32)
+    )
+    validate_full_roundtrip("hello", str, ("hello", None))
+    validate_full_roundtrip(True, bool, (True, None))
+    validate_full_roundtrip(False, bool, (False, None))
+    validate_full_roundtrip(
+        datetime.date(2025, 1, 1), datetime.date, (datetime.date(2025, 1, 1), None)
+    )
+
+    validate_full_roundtrip(
+        datetime.datetime(2025, 1, 2, 3, 4, 5, 123456),
+        cocoindex.LocalDateTime,
+        (datetime.datetime(2025, 1, 2, 3, 4, 5, 123456), datetime.datetime),
+    )
+    validate_full_roundtrip(
+        datetime.datetime(2025, 1, 2, 3, 4, 5, 123456, datetime.UTC),
+        cocoindex.OffsetDateTime,
+        (
+            datetime.datetime(2025, 1, 2, 3, 4, 5, 123456, datetime.UTC),
+            datetime.datetime,
+        ),
     )
 
+    uuid_value = uuid.uuid4()
+    validate_full_roundtrip(uuid_value, uuid.UUID, (uuid_value, None))
+
 
 def test_decode_scalar_numpy_values() -> None:
     test_cases = [
@@ -263,8 +285,8 @@ def test_non_ndarray_vector_decoding() -> None:
     decoder = make_engine_value_decoder(["field"], src_type, dst_type_uuid)
     uuid1 = uuid.uuid4()
     uuid2 = uuid.uuid4()
-    input_bytes = [uuid1.bytes, uuid2.bytes]
-    result = decoder(input_bytes)
+    input_uuids = [uuid1, uuid2]
+    result = decoder(input_uuids)
     assert isinstance(result, list)
     assert all(isinstance(x, uuid.UUID) for x in result)
     assert result == [uuid1, uuid2]
@@ -549,6 +571,48 @@ def test_field_position_cases(
     assert decoder(engine_val) == PythonOrder(**expected_dict)
 
 
+def test_roundtrip_union_simple() -> None:
+    t = int | str | float
+    value = 10.4
+    validate_full_roundtrip(value, t)
+
+
+def test_roundtrip_union_with_active_uuid() -> None:
+    t = str | uuid.UUID | int
+    value = uuid.uuid4()
+    validate_full_roundtrip(value, t)
+
+
+def test_roundtrip_union_with_inactive_uuid() -> None:
+    t = str | uuid.UUID | int
+    value = "5a9f8f6a-318f-4f1f-929d-566d7444a62d"  # it's a string
+    validate_full_roundtrip(value, t)
+
+
+def test_roundtrip_union_offset_datetime() -> None:
+    t = str | uuid.UUID | float | int | datetime.datetime
+    value = datetime.datetime.now(datetime.UTC)
+    validate_full_roundtrip(value, t)
+
+
+def test_roundtrip_union_date() -> None:
+    t = str | uuid.UUID | float | int | datetime.date
+    value = datetime.date.today()
+    validate_full_roundtrip(value, t)
+
+
+def test_roundtrip_union_time() -> None:
+    t = str | uuid.UUID | float | int | datetime.time
+    value = datetime.time()
+    validate_full_roundtrip(value, t)
+
+
+def test_roundtrip_union_timedelta() -> None:
+    t = str | uuid.UUID | float | int | datetime.timedelta
+    value = datetime.timedelta(hours=39, minutes=10, seconds=1)
+    validate_full_roundtrip(value, t)
+
+
 def test_roundtrip_ltable() -> None:
     t = list[Order]
     value = [Order("O1", "item1", 10.0), Order("O2", "item2", 20.0)]
@@ -807,37 +871,72 @@ def test_dump_vector_type_annotation_no_dim() -> None:
 
 def test_full_roundtrip_vector_numeric_types() -> None:
     """Test full roundtrip for numeric vector types using NDArray."""
-    value_f32: Vector[np.float32, Literal[3]] = np.array(
-        [1.0, 2.0, 3.0], dtype=np.float32
+    value_f32 = np.array([1.0, 2.0, 3.0], dtype=np.float32)
+    validate_full_roundtrip(
+        value_f32,
+        Vector[np.float32, Literal[3]],
+        ([np.float32(1.0), np.float32(2.0), np.float32(3.0)], list[np.float32]),
+        ([1.0, 2.0, 3.0], list[cocoindex.Float32]),
+        ([1.0, 2.0, 3.0], list[float]),
     )
-    validate_full_roundtrip(value_f32, Vector[np.float32, Literal[3]])
-    value_f64: Vector[np.float64, Literal[3]] = np.array(
-        [1.0, 2.0, 3.0], dtype=np.float64
+    validate_full_roundtrip(
+        value_f32,
+        np.typing.NDArray[np.float32],
+        ([np.float32(1.0), np.float32(2.0), np.float32(3.0)], list[np.float32]),
+        ([1.0, 2.0, 3.0], list[cocoindex.Float32]),
+        ([1.0, 2.0, 3.0], list[float]),
     )
-    validate_full_roundtrip(value_f64, Vector[np.float64, Literal[3]])
-    value_i64: Vector[np.int64, Literal[3]] = np.array([1, 2, 3], dtype=np.int64)
-    validate_full_roundtrip(value_i64, Vector[np.int64, Literal[3]])
-    value_i32: Vector[np.int32, Literal[3]] = np.array([1, 2, 3], dtype=np.int32)
+    validate_full_roundtrip(
+        value_f32.tolist(),
+        list[np.float32],
+        (value_f32, Vector[np.float32, Literal[3]]),
+        ([1.0, 2.0, 3.0], list[cocoindex.Float32]),
+        ([1.0, 2.0, 3.0], list[float]),
+    )
+
+    value_f64 = np.array([1.0, 2.0, 3.0], dtype=np.float64)
+    validate_full_roundtrip(
+        value_f64,
+        Vector[np.float64, Literal[3]],
+        ([np.float64(1.0), np.float64(2.0), np.float64(3.0)], list[np.float64]),
+        ([1.0, 2.0, 3.0], list[cocoindex.Float64]),
+        ([1.0, 2.0, 3.0], list[float]),
+    )
+
+    value_i64 = np.array([1, 2, 3], dtype=np.int64)
+    validate_full_roundtrip(
+        value_i64,
+        Vector[np.int64, Literal[3]],
+        ([np.int64(1), np.int64(2), np.int64(3)], list[np.int64]),
+        ([1, 2, 3], list[int]),
+    )
+
+    value_i32 = np.array([1, 2, 3], dtype=np.int32)
     with pytest.raises(ValueError, match="Unsupported NumPy dtype"):
         validate_full_roundtrip(value_i32, Vector[np.int32, Literal[3]])
-    value_u8: Vector[np.uint8, Literal[3]] = np.array([1, 2, 3], dtype=np.uint8)
+    value_u8 = np.array([1, 2, 3], dtype=np.uint8)
     with pytest.raises(ValueError, match="Unsupported NumPy dtype"):
         validate_full_roundtrip(value_u8, Vector[np.uint8, Literal[3]])
-    value_u16: Vector[np.uint16, Literal[3]] = np.array([1, 2, 3], dtype=np.uint16)
+    value_u16 = np.array([1, 2, 3], dtype=np.uint16)
     with pytest.raises(ValueError, match="Unsupported NumPy dtype"):
         validate_full_roundtrip(value_u16, Vector[np.uint16, Literal[3]])
-    value_u32: Vector[np.uint32, Literal[3]] = np.array([1, 2, 3], dtype=np.uint32)
+    value_u32 = np.array([1, 2, 3], dtype=np.uint32)
     with pytest.raises(ValueError, match="Unsupported NumPy dtype"):
         validate_full_roundtrip(value_u32, Vector[np.uint32, Literal[3]])
-    value_u64: Vector[np.uint64, Literal[3]] = np.array([1, 2, 3], dtype=np.uint64)
+    value_u64 = np.array([1, 2, 3], dtype=np.uint64)
     with pytest.raises(ValueError, match="Unsupported NumPy dtype"):
         validate_full_roundtrip(value_u64, Vector[np.uint64, Literal[3]])
 
 
 def test_roundtrip_vector_no_dimension() -> None:
     """Test full roundtrip for vector types without dimension annotation."""
-    value_f64: Vector[np.float64] = np.array([1.0, 2.0, 3.0], dtype=np.float64)
-    validate_full_roundtrip(value_f64, Vector[np.float64])
+    value_f64 = np.array([1.0, 2.0, 3.0], dtype=np.float64)
+    validate_full_roundtrip(
+        value_f64,
+        Vector[np.float64],
+        ([1.0, 2.0, 3.0], list[float]),
+        (np.array([1.0, 2.0, 3.0], dtype=np.float64), np.typing.NDArray[np.float64]),
+    )
 
 
 def test_roundtrip_string_vector() -> None:
@@ -862,9 +961,9 @@ def test_roundtrip_dimension_mismatch() -> None:
 def test_full_roundtrip_scalar_numeric_types() -> None:
     """Test full roundtrip for scalar NumPy numeric types."""
     # Test supported scalar types
-    validate_full_roundtrip(np.int64(42), np.int64)
-    validate_full_roundtrip(np.float32(3.14), np.float32)
-    validate_full_roundtrip(np.float64(2.718), np.float64)
+    validate_full_roundtrip(np.int64(42), np.int64, (42, int))
+    validate_full_roundtrip(np.float32(3.25), np.float32, (3.25, cocoindex.Float32))
+    validate_full_roundtrip(np.float64(3.25), np.float64, (3.25, cocoindex.Float64))
 
     # Test unsupported scalar types
     for unsupported_type in [np.int32, np.uint8, np.uint16, np.uint32, np.uint64]:

cocoindex/tests/test_typing.py

@@ -2,7 +2,7 @@ import dataclasses
 import datetime
 import uuid
 from collections.abc import Mapping, Sequence
-from typing import Annotated, Any, Dict, List, Literal, NamedTuple, get_args, get_origin
+from typing import Annotated, Any, Literal, NamedTuple, get_args, get_origin
 
 import numpy as np
 import pytest
@@ -162,10 +162,11 @@ def test_ndarray_any_dtype() -> None:
 
 
 def test_list_of_primitives() -> None:
-    typ = List[str]
+    typ = list[str]
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
         kind="Vector",
+        core_type=list[str],
         vector_info=VectorInfo(dim=None),
         elem_type=str,
         key_type=None,
@@ -177,10 +178,11 @@ def test_list_of_primitives() -> None:
 
 
 def test_list_of_structs() -> None:
-    typ = List[SimpleDataclass]
+    typ = list[SimpleDataclass]
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
         kind="LTable",
+        core_type=list[SimpleDataclass],
         vector_info=None,
         elem_type=SimpleDataclass,
         key_type=None,
@@ -196,6 +198,7 @@ def test_sequence_of_int() -> None:
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
         kind="Vector",
+        core_type=Sequence[int],
         vector_info=VectorInfo(dim=None),
         elem_type=int,
         key_type=None,
@@ -207,10 +210,11 @@ def test_sequence_of_int() -> None:
 
 
 def test_list_with_vector_info() -> None:
-    typ = Annotated[List[int], VectorInfo(dim=5)]
+    typ = Annotated[list[int], VectorInfo(dim=5)]
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
         kind="Vector",
+        core_type=list[int],
         vector_info=VectorInfo(dim=5),
         elem_type=int,
         key_type=None,
@@ -222,10 +226,11 @@ def test_list_with_vector_info() -> None:
 
 
 def test_dict_str_int() -> None:
-    typ = Dict[str, int]
+    typ = dict[str, int]
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
         kind="KTable",
+        core_type=dict[str, int],
         vector_info=None,
         elem_type=(str, int),
         key_type=None,
@@ -241,6 +246,7 @@ def test_mapping_str_dataclass() -> None:
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
         kind="KTable",
+        core_type=Mapping[str, SimpleDataclass],
         vector_info=None,
         elem_type=(str, SimpleDataclass),
         key_type=None,
@@ -256,6 +262,7 @@ def test_dataclass() -> None:
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
         kind="Struct",
+        core_type=SimpleDataclass,
         vector_info=None,
         elem_type=None,
         key_type=None,
@@ -271,6 +278,7 @@ def test_named_tuple() -> None:
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
         kind="Struct",
+        core_type=SimpleNamedTuple,
         vector_info=None,
         elem_type=None,
         key_type=None,
@@ -286,6 +294,7 @@ def test_tuple_key_value() -> None:
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
         kind="Int64",
+        core_type=int,
         vector_info=None,
         elem_type=None,
         key_type=str,
@@ -301,6 +310,7 @@ def test_str() -> None:
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
         kind="Str",
+        core_type=str,
         vector_info=None,
         elem_type=None,
         key_type=None,
@@ -316,6 +326,7 @@ def test_bool() -> None:
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
         kind="Bool",
+        core_type=bool,
         vector_info=None,
         elem_type=None,
         key_type=None,
@@ -331,6 +342,7 @@ def test_bytes() -> None:
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
         kind="Bytes",
+        core_type=bytes,
         vector_info=None,
         elem_type=None,
         key_type=None,
@@ -346,6 +358,7 @@ def test_uuid() -> None:
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
         kind="Uuid",
+        core_type=uuid.UUID,
         vector_info=None,
         elem_type=None,
         key_type=None,
@@ -361,6 +374,7 @@ def test_date() -> None:
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
         kind="Date",
+        core_type=datetime.date,
         vector_info=None,
         elem_type=None,
         key_type=None,
@@ -376,6 +390,7 @@ def test_time() -> None:
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
         kind="Time",
+        core_type=datetime.time,
         vector_info=None,
         elem_type=None,
         key_type=None,
@@ -391,6 +406,7 @@ def test_timedelta() -> None:
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
         kind="TimeDelta",
+        core_type=datetime.timedelta,
         vector_info=None,
         elem_type=None,
         key_type=None,
@@ -406,6 +422,7 @@ def test_float() -> None:
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
         kind="Float64",
+        core_type=float,
         vector_info=None,
         elem_type=None,
         key_type=None,
@@ -421,6 +438,7 @@ def test_int() -> None:
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
         kind="Int64",
+        core_type=int,
         vector_info=None,
         elem_type=None,
         key_type=None,
@@ -436,6 +454,7 @@ def test_type_with_attributes() -> None:
     result = analyze_type_info(typ)
     assert result == AnalyzedTypeInfo(
         kind="Str",
+        core_type=str,
         vector_info=None,
         elem_type=None,
         key_type=None,
@@ -472,7 +491,7 @@ def test_encode_enriched_type_vector() -> None:
 
 
 def test_encode_enriched_type_ltable() -> None:
-    typ = List[SimpleDataclass]
+    typ = list[SimpleDataclass]
     result = encode_enriched_type(typ)
     assert result["type"]["kind"] == "LTable"
     assert result["type"]["row"]["kind"] == "Struct"
@@ -513,7 +532,7 @@ def test_invalid_struct_kind() -> None:
 
 
 def test_invalid_list_kind() -> None:
-    typ = Annotated[List[int], TypeKind("Struct")]
+    typ = Annotated[list[int], TypeKind("Struct")]
     with pytest.raises(ValueError, match="Unexpected type kind for list: Struct"):
         analyze_type_info(typ)
 

cocoindex/typing.py

@@ -150,6 +150,7 @@ class AnalyzedTypeInfo:
     """
 
     kind: str
+    core_type: Any
     vector_info: VectorInfo | None  # For Vector
     elem_type: ElementType | None  # For Vector and Table
 
@@ -161,6 +162,7 @@ class AnalyzedTypeInfo:
 
     attrs: dict[str, Any] | None
     nullable: bool = False
+    union_variant_types: typing.List[ElementType] | None = None  # For Union
 
 
 def analyze_type_info(t: Any) -> AnalyzedTypeInfo:
@@ -181,18 +183,6 @@ def analyze_type_info(t: Any) -> AnalyzedTypeInfo:
         if base_type is Annotated:
             annotations = t.__metadata__
             t = t.__origin__
-        elif base_type is types.UnionType:
-            possible_types = typing.get_args(t)
-            non_none_types = [
-                arg for arg in possible_types if arg not in (None, types.NoneType)
-            ]
-            if len(non_none_types) != 1:
-                raise ValueError(
-                    f"Expect exactly one non-None choice for Union type, but got {len(non_none_types)}: {t}"
-                )
-            t = non_none_types[0]
-            if len(possible_types) > 1:
-                nullable = True
         else:
             break
 
@@ -211,6 +201,7 @@ def analyze_type_info(t: Any) -> AnalyzedTypeInfo:
 
     struct_type: type | None = None
     elem_type: ElementType | None = None
+    union_variant_types: typing.List[ElementType] | None = None
     key_type: type | None = None
     np_number_type: type | None = None
     if _is_struct_type(t):
@@ -251,6 +242,24 @@ def analyze_type_info(t: Any) -> AnalyzedTypeInfo:
         args = typing.get_args(t)
         elem_type = (args[0], args[1])
         kind = "KTable"
+    elif base_type is types.UnionType:
+        possible_types = typing.get_args(t)
+        non_none_types = [
+            arg for arg in possible_types if arg not in (None, types.NoneType)
+        ]
+
+        if len(non_none_types) == 0:
+            return analyze_type_info(None)
+
+        nullable = len(non_none_types) < len(possible_types)
+
+        if len(non_none_types) == 1:
+            result = analyze_type_info(non_none_types[0])
+            result.nullable = nullable
+            return result
+
+        kind = "Union"
+        union_variant_types = non_none_types
     elif kind is None:
         if t is bytes:
             kind = "Bytes"
@@ -277,8 +286,10 @@ def analyze_type_info(t: Any) -> AnalyzedTypeInfo:
 
     return AnalyzedTypeInfo(
         kind=kind,
+        core_type=t,
         vector_info=vector_info,
         elem_type=elem_type,
+        union_variant_types=union_variant_types,
         key_type=key_type,
         struct_type=struct_type,
         np_number_type=np_number_type,
@@ -338,6 +349,14 @@ def _encode_type(type_info: AnalyzedTypeInfo) -> dict[str, Any]:
         encoded_type["element_type"] = _encode_type(elem_type_info)
         encoded_type["dimension"] = type_info.vector_info.dim
 
+    elif type_info.kind == "Union":
+        if type_info.union_variant_types is None:
+            raise ValueError("Union type must have a variant type list")
+        encoded_type["types"] = [
+            _encode_type(analyze_type_info(typ))
+            for typ in type_info.union_variant_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")

{cocoindex-0.1.53.dist-info → cocoindex-0.1.55.dist-info}/METADATA

@@ -1,12 +1,14 @@
 Metadata-Version: 2.4
 Name: cocoindex
-Version: 0.1.53
+Version: 0.1.55
 Requires-Dist: sentence-transformers>=3.3.1
 Requires-Dist: click>=8.1.8
 Requires-Dist: rich>=14.0.0
 Requires-Dist: python-dotenv>=1.1.0
+Requires-Dist: watchfiles>=1.1.0
 Requires-Dist: pytest ; extra == 'test'
 Requires-Dist: ruff ; extra == 'dev'
+Requires-Dist: pre-commit ; extra == 'dev'
 Provides-Extra: test
 Provides-Extra: dev
 License-File: LICENSE
@@ -51,10 +53,10 @@ Unlike a workflow orchestration framework where data is usually opaque, in CocoI
 
 ```python
 # import
-data['content'] = flow_builder.add_source(...) 
+data['content'] = flow_builder.add_source(...)
 
 # transform
-data['out'] = data['content'] 
+data['out'] = data['content']
     .transform(...)
     .transform(...)
 
@@ -75,17 +77,17 @@ As a data framework, CocoIndex takes it to the next level on data freshness. **I
 The frameworks takes care of
 - Change data capture.
 - Figure out what exactly needs to be updated, and only updating that without having to recompute everything.
-  
+
 This makes it fast to reflect any source updates to the target store. If you have concerns with surfacing stale data to AI agents and are spending lots of efforts working on infra piece to optimize the latency, the framework actually handles it for you.
 
 
 ## Quick Start:
-If you're new to CocoIndex, we recommend checking out 
+If you're new to CocoIndex, we recommend checking out
 - 📖 [Documentation](https://cocoindex.io/docs)
 - ⚡  [Quick Start Guide](https://cocoindex.io/docs/getting_started/quickstart)
-- 🎬 [Quick Start Video Tutorial](https://youtu.be/gv5R8nOXsWU?si=9ioeKYkMEnYevTXT) 
+- 🎬 [Quick Start Video Tutorial](https://youtu.be/gv5R8nOXsWU?si=9ioeKYkMEnYevTXT)
 
-### Setup 
+### Setup
 
 1. Install CocoIndex Python library
 
@@ -155,8 +157,8 @@ It defines an index flow like this:
 | [Google Drive Text Embedding](examples/gdrive_text_embedding) | Index text documents from Google Drive |
 | [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 |
-| [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| 
+| [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|
 
 More coming and stay tuned 👀!
@@ -178,7 +180,7 @@ Join our community here:
 - 📜 [Read our blog posts](https://cocoindex.io/blogs/)
 
 ## Support us:
-We are constantly improving, and more features and examples are coming soon. If you love this project, please drop us a star ⭐ at GitHub repo [![GitHub](https://img.shields.io/github/stars/cocoindex-io/cocoindex?color=5B5BD6)](https://github.com/cocoindex-io/cocoindex) to stay tuned and help us grow. 
+We are constantly improving, and more features and examples are coming soon. If you love this project, please drop us a star ⭐ at GitHub repo [![GitHub](https://img.shields.io/github/stars/cocoindex-io/cocoindex?color=5B5BD6)](https://github.com/cocoindex-io/cocoindex) to stay tuned and help us grow.
 
 ## License
 CocoIndex is Apache 2.0 licensed.

cocoindex-0.1.55.dist-info/RECORD

@@ -0,0 +1,28 @@
+cocoindex-0.1.55.dist-info/METADATA,sha256=uZ5mri9lCaVS5sLMfY1c8lFIyaAHI2duMFy_Y6sxh_Q,10105
+cocoindex-0.1.55.dist-info/WHEEL,sha256=j4qqVNEKdft0WYe2NEymIjSlGSeJ1BogQYEaMx5ZvPI,96
+cocoindex-0.1.55.dist-info/entry_points.txt,sha256=_NretjYVzBdNTn7dK-zgwr7YfG2afz1u1uSE-5bZXF8,46
+cocoindex-0.1.55.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+cocoindex/__init__.py,sha256=0cJBLw3MQX7MeuurZ49TV96zdKkSCva9atqxJZG0U2M,1853
+cocoindex/_engine.cp311-win_amd64.pyd,sha256=aoFG_VuYjPnC-04UOhXaNaqFEoAk1QPKG7E02FnuWpQ,61743616
+cocoindex/auth_registry.py,sha256=LojDKoX0ccO-G3bboFMlAti50_t5GK9BS0ouPJZfyUs,745
+cocoindex/cli.py,sha256=Zw_TJalwAxIR1VDvUGNUMqfgqcdrHH-yP20ppax-xpE,20995
+cocoindex/convert.py,sha256=Gvy2bw0YrhOhqx7EQpa-bZ1TxWREy6ur2sKwMK9J_h4,10522
+cocoindex/flow.py,sha256=H54uyDSrJ-akBrzv3Y-ncr2hCbSeg55FZ9tp_Wmt3Gs,30992
+cocoindex/functions.py,sha256=1P8UhXlSS59zmBS0L7ltK0Elbo9VKw_T1M_O_ASGnWQ,2710
+cocoindex/index.py,sha256=GrqTm1rLwICQ8hadtNvJAxVg7GWMvtMmFcbiNtNzmP0,569
+cocoindex/lib.py,sha256=o2UGq3eWsZbK5nusZEU7Y0R6NTbT0i03G2ye8N6ATNg,3015
+cocoindex/llm.py,sha256=zc-5o6qWo8KBXa6a533jbmad5QoSBtJL9b7bj9SFehY,453
+cocoindex/op.py,sha256=Jk1KfRNBY4TEsbbhWHB5pEzNcMo_2T-FQR1Y75OUVhU,12143
+cocoindex/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cocoindex/runtime.py,sha256=saKEZntVwUVQNASRhiO9bHRVIFmQccemq2f9mo4mo1A,1090
+cocoindex/setting.py,sha256=dRNdX-rPBn321zGx6GGoSMggS4F2879A6EBLOUbX8R4,3717
+cocoindex/setup.py,sha256=nqJAEGQH-5yTulEy3aCAa9khbuiaqD81ZZUdeM3K_lo,799
+cocoindex/sources.py,sha256=4hxsntuyClp_jKH4oZbx3iE3UM4P2bZTpWy28dqdyFY,1375
+cocoindex/targets.py,sha256=7FfG9kuEf5KTXtLwXMFaPFIut3PsIbpb3XIEjjeF7Bg,2931
+cocoindex/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cocoindex/tests/test_convert.py,sha256=npvLoWfZenQn4U-7odrP_CG7R3quwZWI0IEMNMDD5H0,37195
+cocoindex/tests/test_optional_database.py,sha256=dnzmTgaJf37D3q8fQsjP5UDER6FYETaUokDnFBMLtIk,8755
+cocoindex/tests/test_typing.py,sha256=6W2NQmyTj4LMuWegV5m4NVP2clVNrUa5eD28_3nwzjs,15300
+cocoindex/typing.py,sha256=T5BsXOArgXK4yoDSh9Fo-dzXGYYgsnRhLVOH1Z_42Ig,12985
+cocoindex/utils.py,sha256=U3W39zD2uZpXX8v84tJD7sRmbC5ar3z_ljAP1cJrYXI,618
+cocoindex-0.1.55.dist-info/RECORD,,

{cocoindex-0.1.53.dist-info → cocoindex-0.1.55.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: maturin (1.8.7)
+Generator: maturin (1.9.0)
 Root-Is-Purelib: false
 Tag: cp311-cp311-win_amd64

cocoindex-0.1.53.dist-info/RECORD

@@ -1,28 +0,0 @@
-cocoindex-0.1.53.dist-info/METADATA,sha256=tsTjQi0dIr3mU1aTxOcDs2xyChKVauyGIkT4CN1UwuE,10039
-cocoindex-0.1.53.dist-info/WHEEL,sha256=s0dDfj2AxxVsNT4qxjje5WVH9nG_gFfyCM_ZRxv6bRM,96
-cocoindex-0.1.53.dist-info/entry_points.txt,sha256=_NretjYVzBdNTn7dK-zgwr7YfG2afz1u1uSE-5bZXF8,46
-cocoindex-0.1.53.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-cocoindex/__init__.py,sha256=0cJBLw3MQX7MeuurZ49TV96zdKkSCva9atqxJZG0U2M,1853
-cocoindex/_engine.cp311-win_amd64.pyd,sha256=_d7PBH4pnG2CqDJGtNAEUIF-T5C0SOOkrBipZwvZ0hM,61381120
-cocoindex/auth_registry.py,sha256=LojDKoX0ccO-G3bboFMlAti50_t5GK9BS0ouPJZfyUs,745
-cocoindex/cli.py,sha256=G69aDjYiT6wWJIG2l-VQAslfdxVE_OmkWQzZdR3KXiw,18798
-cocoindex/convert.py,sha256=yRUQaiTuLwC6rHJZI7g1gnqsZWefBiD_9vPgHxGa5Ow,10066
-cocoindex/flow.py,sha256=Dt6lzzhZgnnNbFOZ0smeDy6SlBCBofneoCBZ-T3rtIg,30983
-cocoindex/functions.py,sha256=3l7POrvuk5DVIwGUgCODAi-JNFJ1_WLTOg6Yn-uZ0IE,2471
-cocoindex/index.py,sha256=GrqTm1rLwICQ8hadtNvJAxVg7GWMvtMmFcbiNtNzmP0,569
-cocoindex/lib.py,sha256=o2UGq3eWsZbK5nusZEU7Y0R6NTbT0i03G2ye8N6ATNg,3015
-cocoindex/llm.py,sha256=bvdI0dzU0DV_56xfyHnRKv1E75aEm_qDZ82EqN1MDQ4,430
-cocoindex/op.py,sha256=Jk1KfRNBY4TEsbbhWHB5pEzNcMo_2T-FQR1Y75OUVhU,12143
-cocoindex/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cocoindex/runtime.py,sha256=saKEZntVwUVQNASRhiO9bHRVIFmQccemq2f9mo4mo1A,1090
-cocoindex/setting.py,sha256=dRNdX-rPBn321zGx6GGoSMggS4F2879A6EBLOUbX8R4,3717
-cocoindex/setup.py,sha256=nqJAEGQH-5yTulEy3aCAa9khbuiaqD81ZZUdeM3K_lo,799
-cocoindex/sources.py,sha256=4hxsntuyClp_jKH4oZbx3iE3UM4P2bZTpWy28dqdyFY,1375
-cocoindex/targets.py,sha256=7FfG9kuEf5KTXtLwXMFaPFIut3PsIbpb3XIEjjeF7Bg,2931
-cocoindex/tests/__init__.py,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-cocoindex/tests/test_convert.py,sha256=7pcYPICPOgMA4SjXK4jsTutLMRyBHxhuXgZpZdjeDew,34181
-cocoindex/tests/test_optional_database.py,sha256=dnzmTgaJf37D3q8fQsjP5UDER6FYETaUokDnFBMLtIk,8755
-cocoindex/tests/test_typing.py,sha256=XX_d1q5IUWcPANsp2oKZb7JI4DjVBVt1U7FwwEy9igo,14708
-cocoindex/typing.py,sha256=Vc51BobrtswtX_sNSuSiWc4iiHeafL6dXqhbNo0iKXc,12385
-cocoindex/utils.py,sha256=U3W39zD2uZpXX8v84tJD7sRmbC5ar3z_ljAP1cJrYXI,618
-cocoindex-0.1.53.dist-info/RECORD,,