vgi-python 0.20.0__tar.gz → 0.21.0__tar.gz

{vgi_python-0.20.0 → vgi_python-0.21.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vgi-python
-Version: 0.20.0
+Version: 0.21.0
 Summary: Vector Gateway Interface - Connect DuckDB to external programs via Apache Arrow
 Project-URL: Homepage, https://query.farm
 Project-URL: Repository, https://github.com/Query-farm/vgi-python

{vgi_python-0.20.0 → vgi_python-0.21.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "vgi-python"
-version = "0.20.0"
+version = "0.21.0"
 description = "Vector Gateway Interface - Connect DuckDB to external programs via Apache Arrow"
 readme = "README.md"
 keywords = [

{vgi_python-0.20.0 → vgi_python-0.21.0}/tests/catalog/test_serialization.py

@@ -1275,16 +1275,22 @@ class TestScanBranchSerialization:
         assert restored.branches[1].function_name == "iceberg_scan"
         assert restored.required_extensions == ["iceberg", "httpfs"]
 
-    def test_scan_branches_result_empty_branches_rejected(self) -> None:
-        """Empty branches list is rejected at deserialize — workers must return >=1 branch."""
-        import pytest
-
+    def test_scan_branches_result_empty_branches_tolerated(self) -> None:
+        """Empty branches list round-trips cleanly.
+
+        Lenient producers (the Rust/Go/Java SDKs, tolerated by the DuckDB C++
+        client) omit the IPC stream for an empty nested list, so a strict
+        consumer must accept a zero-branch result rather than raising — otherwise
+        the Cedar proxy (the only strict Python consumer in the path) fails
+        closed on a legitimate response.
+        """
         from vgi.catalog import ScanBranchesResult
 
         empty = ScanBranchesResult(branches=[], required_extensions=[])
         batch, _ = deserialize_record_batch(empty.serialize())
-        with pytest.raises(ValueError, match="branches list must not be empty"):
-            ScanBranchesResult.deserialize(batch)
+        restored = ScanBranchesResult.deserialize(batch)
+        assert restored.branches == []
+        assert restored.required_extensions == []
 
 
 class TestSecretTypeSpecSerialization:

{vgi_python-0.20.0 → vgi_python-0.21.0}/tests/test_protocol_classes.py

@@ -1149,3 +1149,61 @@ class TestAnyArrow:
         assert obj.data.value == {"key": "value"}
         assert obj.data.position == "data"
         assert obj.data.name == "data"
+
+
+class TestBindCallWireFormat:
+    """The embedded ``bind_call`` must serialize as an opaque binary IPC blob.
+
+    Every non-Python VGI implementation (the DuckDB C++ client, the Rust/Go/Java
+    SDKs) encodes ``bind_call`` as ``Bytes`` — an IPC-serialized ``BindRequest``
+    (Rust: ``ipc::read_batch(&dto.bind_call.0)``). If Python serializes it as an
+    inline Arrow *struct* instead, those workers reject the request with
+    "expected Binary array". This regression-anchors the ``bind_call`` field
+    being ``Annotated[BindRequest, ArrowType(pa.binary())]`` on every request
+    that carries one, so the Cedar proxy's re-serialized bind stays wire-
+    compatible with a non-Python backend.
+    """
+
+    @staticmethod
+    def _bind_call_arrow_type(obj: object) -> str:
+        batch = pa.ipc.open_stream(obj.serialize_to_bytes()).read_next_batch()  # type: ignore[attr-defined]
+        return str(dict((f.name, f.type) for f in batch.schema)["bind_call"])
+
+    def _make_bind(self) -> object:
+        """Build a minimal ``BindRequest`` to embed as ``bind_call``."""
+        from vgi.protocol import BindRequest, FunctionType
+
+        return BindRequest(
+            function_name="f",
+            arguments=Arguments(positional=[], named=None),
+            function_type=FunctionType.TABLE,
+        )
+
+    def test_init_request_bind_call_is_binary(self) -> None:
+        """``InitRequest.bind_call`` serializes as binary and round-trips."""
+        from vgi.protocol import InitRequest
+
+        ir = InitRequest(bind_call=self._make_bind(), output_schema=pa.schema([pa.field("x", pa.int64())]))
+        assert self._bind_call_arrow_type(ir) == "binary"
+        # round-trips back into a BindRequest
+        restored = InitRequest.deserialize_from_bytes(ir.serialize_to_bytes())
+        assert restored.bind_call.function_name == "f"
+
+    def test_table_function_requests_bind_call_is_binary(self) -> None:
+        """The ``table_function_*`` requests also serialize ``bind_call`` as binary."""
+        from vgi.protocol import (
+            TableFunctionCardinalityRequest,
+            TableFunctionDynamicToStringRequest,
+            TableFunctionStatisticsRequest,
+        )
+
+        cases = [
+            (TableFunctionCardinalityRequest, {}),
+            (TableFunctionStatisticsRequest, {}),
+            (TableFunctionDynamicToStringRequest, {"global_execution_id": b"exec"}),
+        ]
+        for cls, extra in cases:
+            obj = cls(bind_call=self._make_bind(), **extra)
+            assert self._bind_call_arrow_type(obj) == "binary", cls.__name__
+            restored = cls.deserialize_from_bytes(obj.serialize_to_bytes())
+            assert restored.bind_call.function_name == "f", cls.__name__

{vgi_python-0.20.0 → vgi_python-0.21.0}/uv.lock

@@ -2228,7 +2228,7 @@ requires-dist = [
 
 [[package]]
 name = "vgi-python"
-version = "0.19.0"
+version = "0.21.0"
 source = { editable = "." }
 dependencies = [
     { name = "click" },

{vgi_python-0.20.0 → vgi_python-0.21.0}/vgi/_test_fixtures/http_server.py

@@ -330,13 +330,23 @@ def main() -> None:
 
             authenticate = _optional_bearer
 
-        from vgi.worker import _get_vgi_version
-
         # Match vgi-fixture-worker (subprocess transport): always serve the
         # base ExampleWorker plus the projection_repro, schema_reconcile,
         # and accumulate fixture catalogs. Add the writable catalog when its
-        # extra is installed.
-        worker_classes: list[type] = [ExampleWorker, ProjReproWorker, SchemaReconcileWorker, AccumulateWorker]
+        # extra is installed. The twin_a/twin_b catalogs (same worker, one
+        # function name colliding across two catalogs) back
+        # scalar/same_name_catalogs.test — catalog-qualified dispatch.
+        from vgi._test_fixtures.twin_catalogs import TwinAWorker, TwinBWorker
+        from vgi.worker import _get_vgi_version
+
+        worker_classes: list[type] = [
+            ExampleWorker,
+            ProjReproWorker,
+            SchemaReconcileWorker,
+            AccumulateWorker,
+            TwinAWorker,
+            TwinBWorker,
+        ]
         try:
             from vgi._test_fixtures.writable.worker import WritableWorker
         except ImportError:

{vgi_python-0.20.0 → vgi_python-0.21.0}/vgi/catalog/catalog_interface.py

@@ -1188,9 +1188,10 @@ class ScanBranchesResult:
         )
 
         branch_blobs = cast("list[bytes]", row["branches"])
-        if not branch_blobs:
-            raise ValueError(f"{cls.__name__}: branches list must not be empty")
-
+        # An empty branch list is valid: a multi-branch scan can prune to zero
+        # branches (see catalog/multi_branch_empty_branches) — it scans nothing.
+        # Lenient producers (the Rust/Go/Java SDKs, tolerated by the DuckDB C++
+        # client) send it; don't reject.
         branches: list[ScanBranch] = []
         for blob in branch_blobs:
             branch_batch, _ = deserialize_record_batch(blob)

{vgi_python-0.20.0 → vgi_python-0.21.0}/vgi/protocol.py

@@ -288,7 +288,7 @@ class InitRequest(ArrowSerializableDataclass):
     """
 
     # Core (always present)
-    bind_call: BindRequest
+    bind_call: Annotated[BindRequest, ArrowType(pa.binary())]
     output_schema: Annotated[pa.Schema, ArrowType(pa.binary())]
     bind_opaque_data: Annotated[bytes | None, ArrowType(pa.binary())] = None
 
@@ -348,7 +348,7 @@ class TableFunctionCardinalityRequest(ArrowSerializableDataclass):
             ``InitRequest.bind_opaque_data``).
     """
 
-    bind_call: BindRequest
+    bind_call: Annotated[BindRequest, ArrowType(pa.binary())]
     bind_opaque_data: Annotated[bytes | None, ArrowType(pa.binary())] = None
 
 
@@ -368,7 +368,7 @@ class TableFunctionStatisticsRequest(ArrowSerializableDataclass):
             ``InitRequest.bind_opaque_data``).
     """
 
-    bind_call: BindRequest
+    bind_call: Annotated[BindRequest, ArrowType(pa.binary())]
     bind_opaque_data: Annotated[bytes | None, ArrowType(pa.binary())] = None
 
 
@@ -392,7 +392,7 @@ class TableFunctionDynamicToStringRequest(ArrowSerializableDataclass):
             persisted the diagnostics this RPC retrieves.
     """
 
-    bind_call: BindRequest
+    bind_call: Annotated[BindRequest, ArrowType(pa.binary())]
     bind_opaque_data: Annotated[bytes | None, ArrowType(pa.binary())] = None
     global_execution_id: bytes