vgi-python 0.29.0__tar.gz → 0.29.3__tar.gz

{vgi_python-0.29.0 → vgi_python-0.29.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: vgi-python
-Version: 0.29.0
+Version: 0.29.3
 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
@@ -212,18 +212,22 @@ Provides-Extra: transactor
 Requires-Dist: sqlglot; extra == 'transactor'
 Description-Content-Type: text/markdown
 
-# VGI (Vector Gateway Interface)
-
 <p align="center">
-  <img src="https://raw.githubusercontent.com/Query-farm/vgi-python/main/docs/vgi-logo.png" alt="VGI Logo" width="480">
+  <img src="https://raw.githubusercontent.com/Query-farm/vgi-python/main/docs/vgi-logo.png?v=2" alt="Vector Gateway Interface logo" width="320">
 </p>
 
+<h1 align="center">VGI</h1>
+
 <p align="center">
-  <strong>Apache Arrow-based protocol for extending DuckDB using any language.</strong>
+  Apache Arrow-based protocol for extending DuckDB using any language — the Python reference implementation.<br>
+  Built by <a href="https://query.farm">🚜 Query.Farm</a>
 </p>
 
 <p align="center">
-  Created by <a href="https://query.farm">Query.Farm</a>
+  <a href="https://github.com/Query-farm/vgi-python/actions/workflows/ci.yml"><img src="https://github.com/Query-farm/vgi-python/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
+  <a href="https://pypi.org/project/vgi-python/"><img src="https://img.shields.io/pypi/v/vgi-python" alt="PyPI"></a>
+  <a href="https://pypi.org/project/vgi-python/"><img src="https://img.shields.io/pypi/pyversions/vgi-python" alt="Python versions"></a>
+  <a href="LICENSE"><img src="https://img.shields.io/pypi/l/vgi-python" alt="License"></a>
 </p>
 
 ---

{vgi_python-0.29.0 → vgi_python-0.29.3}/README.md

@@ -1,15 +1,19 @@
-# VGI (Vector Gateway Interface)
-
 <p align="center">
-  <img src="https://raw.githubusercontent.com/Query-farm/vgi-python/main/docs/vgi-logo.png" alt="VGI Logo" width="480">
+  <img src="https://raw.githubusercontent.com/Query-farm/vgi-python/main/docs/vgi-logo.png?v=2" alt="Vector Gateway Interface logo" width="320">
 </p>
 
+<h1 align="center">VGI</h1>
+
 <p align="center">
-  <strong>Apache Arrow-based protocol for extending DuckDB using any language.</strong>
+  Apache Arrow-based protocol for extending DuckDB using any language — the Python reference implementation.<br>
+  Built by <a href="https://query.farm">🚜 Query.Farm</a>
 </p>
 
 <p align="center">
-  Created by <a href="https://query.farm">Query.Farm</a>
+  <a href="https://github.com/Query-farm/vgi-python/actions/workflows/ci.yml"><img src="https://github.com/Query-farm/vgi-python/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
+  <a href="https://pypi.org/project/vgi-python/"><img src="https://img.shields.io/pypi/v/vgi-python" alt="PyPI"></a>
+  <a href="https://pypi.org/project/vgi-python/"><img src="https://img.shields.io/pypi/pyversions/vgi-python" alt="Python versions"></a>
+  <a href="LICENSE"><img src="https://img.shields.io/pypi/l/vgi-python" alt="License"></a>
 </p>
 
 ---

{vgi_python-0.29.0 → vgi_python-0.29.3}/pyproject.toml

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

vgi_python-0.29.3/tests/client/test_batch_metadata_callback.py

@@ -0,0 +1,77 @@
+# Copyright 2026 Query Farm LLC - https://query.farm
+
+# ruff: noqa: S101, D101, D102, D103
+"""`Client.table_function(batch_metadata_callback=...)`.
+
+`_table_function_parallel` previously discarded `AnnotatedBatch.custom_metadata`
+unconditionally (`if output.batch.num_rows > 0: output_queue.put(output.batch)`)
+and only forwarded the bare `pa.RecordBatch` — so a worker's `vgi.cache.*`
+cacheability advertisement (`vgi/cache_control.py`), which rides
+`custom_metadata`, was structurally unreachable through the public
+`table_function()` generator. `batch_metadata_callback` mirrors the existing
+`bind_result_callback` pattern to fix that additively, with no change to the
+generator's yield type. Exercised against `cacheable_numbers`
+(`vgi/_test_fixtures/table/cache.py`), which advertises `vgi.cache.ttl` on its
+first batch.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import pyarrow as pa
+import pytest
+
+from vgi.arguments import Arguments
+
+DATA = "data"
+
+
+@pytest.fixture
+def client(client_transport: Any) -> Any:
+    with client_transport() as c:
+        c.catalog_attach(name="example", data_version_spec=None, implementation_version=None)
+        yield c
+
+
+def test_callback_receives_cache_control_metadata(client: Any) -> None:
+    metas: list[pa.KeyValueMetadata | None] = []
+    batches = list(
+        client.table_function(
+            function_name="cacheable_numbers",
+            schema_name=DATA,
+            arguments=Arguments(named={"n": pa.scalar(5)}),
+            batch_metadata_callback=metas.append,
+        )
+    )
+    assert sum(b.num_rows for b in batches) == 5
+    assert len(metas) == len(batches)
+    assert metas[0] is not None
+    assert dict(metas[0])[b"vgi.cache.ttl"] == b"300"
+
+
+def test_callback_is_optional_and_defaults_to_none(client: Any) -> None:
+    """No `batch_metadata_callback` -> unchanged behavior, no crash."""
+    batches = list(
+        client.table_function(
+            function_name="cacheable_numbers",
+            schema_name=DATA,
+            arguments=Arguments(named={"n": pa.scalar(3)}),
+        )
+    )
+    assert sum(b.num_rows for b in batches) == 3
+
+
+def test_callback_sees_none_for_a_batch_without_custom_metadata(client: Any) -> None:
+    """A function that never advertises cache control still drives the callback once per batch, with `None`."""
+    metas: list[pa.KeyValueMetadata | None] = []
+    list(
+        client.table_function(
+            function_name="sequence",
+            schema_name="main",
+            arguments=Arguments(positional=[pa.scalar(4)]),
+            batch_metadata_callback=metas.append,
+        )
+    )
+    assert metas
+    assert all(m is None for m in metas)

vgi_python-0.29.3/tests/client/test_scan_branches_client.py

@@ -0,0 +1,67 @@
+# Copyright 2026 Query Farm LLC - https://query.farm
+
+# ruff: noqa: S101, D101, D102, D103
+"""`Client.table_scan_branches_get`.
+
+`Client` had no wrapper for `catalog_table_scan_branches_get` at all —
+grepped the whole `vgi/client/` package for "branch" and the only hit was an
+unrelated code comment ("skip the subprocess branch"). A multi-branch table
+was therefore invisible to any non-DuckDB caller, not just unsupported by a
+higher-level connector. Exercised against `data.multi_branch_numbers` (two
+`sequence(50)` arms — `vgi/_test_fixtures/worker.py`) and, for the legacy
+fallback, `data.numbers` (an ordinary single-branch table whose worker only
+implements the older `table_scan_function_get`).
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import pytest
+
+from vgi.catalog import ScanBranch, ScanBranchesResult
+
+DATA = "data"
+
+
+@pytest.fixture
+def client(client_transport: Any) -> Any:
+    with client_transport() as c:
+        c.catalog_attach(name="example", data_version_spec=None, implementation_version=None)
+        yield c
+
+
+def _attach_opaque(client: Any) -> Any:
+    # catalog_attach() was already called by the fixture above (its return
+    # value discarded) — re-attach here to get the opaque data this method
+    # needs, mirroring how CatalogClientMixin methods are used standalone.
+    return client.catalog_attach(name="example", data_version_spec=None, implementation_version=None).attach_opaque_data
+
+
+def test_multi_branch_table_returns_all_branches(client: Any) -> None:
+    result = client.table_scan_branches_get(
+        attach_opaque_data=_attach_opaque(client),
+        schema_name=DATA,
+        name="multi_branch_numbers",
+    )
+    assert isinstance(result, ScanBranchesResult)
+    assert len(result.branches) == 2
+    for branch in result.branches:
+        assert isinstance(branch, ScanBranch)
+        assert branch.function_name == "sequence"
+        assert branch.source_table is None  # function branch, not catalog-table
+
+
+def test_single_branch_table_falls_back_to_legacy_rpc(client: Any) -> None:
+    """`data.numbers` only implements `table_scan_function_get` — the fallback wraps it as one branch."""
+    result = client.table_scan_branches_get(
+        attach_opaque_data=_attach_opaque(client),
+        schema_name=DATA,
+        name="numbers",
+    )
+    assert len(result.branches) == 1
+    assert result.branches[0].function_name == client.table_scan_function_get(
+        attach_opaque_data=_attach_opaque(client),
+        schema_name=DATA,
+        name="numbers",
+    ).function_name

vgi_python-0.29.3/tests/client/test_split_client.py

@@ -0,0 +1,93 @@
+# Copyright 2026 Query Farm LLC - https://query.farm
+
+# ruff: noqa: S101, D101, D102, D103
+"""`Client.table_function_plan` + `Client.table_function(split_tokens=...)`.
+
+Splits were previously entirely unreachable from `Client` — no wrapper for
+`on_plan()` existed at all, and `table_function()`/`_do_init` had no
+`split_tokens` parameter to redeem one, even though the wire protocol
+(`TableFunctionPlanRequest`/`PlanResponse`/`InitRequest.split_tokens`) and the
+`VgiProtocol.table_function_plan` RPC already supported it — the DuckDB C++
+extension drives this today, but the reference Python client never grew the
+equivalent. Exercised against `split_sequence` (the split-capable twin of
+`sequence`, `vgi/_test_fixtures/table/splits.py`) over every client transport.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import pyarrow as pa
+import pytest
+
+from vgi.arguments import Arguments
+from vgi.protocol import ScanSplit
+
+MAIN = "main"
+
+
+@pytest.fixture
+def client(client_transport: Any) -> Any:
+    with client_transport() as c:
+        c.catalog_attach(name="example", data_version_spec=None, implementation_version=None)
+        yield c
+
+
+def test_plan_returns_typed_scan_splits(client: Any) -> None:
+    args = Arguments(named={"n": pa.scalar(20), "splits": pa.scalar(4)})
+    plan = client.table_function_plan(function_name="split_sequence", schema_name=MAIN, arguments=args)
+    assert len(plan.splits) == 4
+    for split in plan.splits:
+        assert isinstance(split, ScanSplit)
+        assert split.token  # framework-stamped, non-empty
+        assert split.estimated_rows == 5
+
+
+def test_redeeming_each_split_in_order_reproduces_the_whole_scan(client: Any) -> None:
+    """split_sequence redeemed split-by-split must equal sequence(n)'s output.
+
+    Also threads ``split_execution_id``/``split_init_opaque_data`` from the
+    plan on every redemption — this fixture doesn't need cross-split shared
+    state to be correct, but this proves the wire path accepts and round-trips
+    them without erroring, for workers that do.
+    """
+    args = Arguments(named={"n": pa.scalar(37), "splits": pa.scalar(5)})
+    plan = client.table_function_plan(function_name="split_sequence", schema_name=MAIN, arguments=args)
+
+    all_rows: list[int] = []
+    for split in plan.splits:
+        batches = list(
+            client.table_function(
+                function_name="split_sequence",
+                schema_name=MAIN,
+                arguments=args,
+                split_tokens=[split.token],
+                split_execution_id=plan.execution_id,
+                split_init_opaque_data=plan.init_opaque_data,
+            )
+        )
+        for batch in batches:
+            all_rows.extend(batch.column("n").to_pylist())
+
+    assert sorted(all_rows) == list(range(37))
+
+
+def test_split_zero_yields_no_splits_and_no_rows(client: Any) -> None:
+    args = Arguments(named={"n": pa.scalar(10), "splits": pa.scalar(4)})
+    plan = client.table_function_plan(function_name="split_zero", schema_name=MAIN, arguments=args)
+    assert plan.splits == []
+
+
+def test_redeeming_a_split_forces_single_worker(client: Any) -> None:
+    """`split_tokens` bypasses `_spawn_additional_workers` — no additional worker connections open."""
+    args = Arguments(named={"n": pa.scalar(8), "splits": pa.scalar(2)})
+    plan = client.table_function_plan(function_name="split_sequence", schema_name=MAIN, arguments=args)
+    list(
+        client.table_function(
+            function_name="split_sequence",
+            schema_name=MAIN,
+            arguments=args,
+            split_tokens=[plan.splits[0].token],
+        )
+    )
+    assert client._additional_workers == []

vgi_python-0.29.3/tests/client/test_time_travel_client.py

@@ -0,0 +1,85 @@
+# Copyright 2026 Query Farm LLC - https://query.farm
+
+# ruff: noqa: S101, D101, D102, D103
+"""`Client.table_get`/`table_function(at_unit=..., at_value=...)`.
+
+Both methods previously dropped `at_unit`/`at_value` on the floor even though
+the underlying wire RPCs (`catalog_table_get`, `BindRequest.at_unit`/
+`.at_value`) already carried them — `table_scan_function_get` was the only
+`Client` method that exposed time travel at all. Two distinct worker
+patterns are exercised, both real fixtures, proving this isn't just plumbing
+that happens to compile:
+
+* `data.versioned_data` reads its version through a pre-resolved bind
+  argument (`table_scan_function_get(at_unit=...)` bakes it into the
+  returned `ScanFunctionResult.arguments`) — `table_get(at_unit=...)` is
+  what needed fixing here, to see the schema at that version at all.
+* `data.tt_pushdown_fn` (`tt_pushdown_scan`) reads `at_unit`/`at_value`
+  **directly off the init request** (`ProcessParams.at_unit`/`.at_value`,
+  see `vgi/_test_fixtures/table/tt_pushdown.py`) — this is the pattern that
+  needed `table_function(at_unit=...)` specifically; no amount of
+  pre-resolved arguments would reach it.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import pyarrow as pa
+import pytest
+
+from vgi.arguments import Arguments
+
+DATA = "data"
+
+
+@pytest.fixture
+def client(client_transport: Any) -> Any:
+    with client_transport() as c:
+        c.catalog_attach(name="example", data_version_spec=None, implementation_version=None)
+        yield c
+
+
+def _attach_opaque(client: Any) -> Any:
+    result = client.catalog_attach(name="example", data_version_spec=None, implementation_version=None)
+    return result.attach_opaque_data
+
+
+def test_table_get_at_unit_returns_the_versioned_schema(client: Any) -> None:
+    opaque = _attach_opaque(client)
+    v1 = client.table_get(
+        attach_opaque_data=opaque, schema_name=DATA, name="versioned_data", at_unit="VERSION", at_value="1"
+    )
+    live = client.table_get(attach_opaque_data=opaque, schema_name=DATA, name="versioned_data")
+
+    v1_schema = pa.ipc.read_schema(pa.py_buffer(v1.columns))
+    live_schema = pa.ipc.read_schema(pa.py_buffer(live.columns))
+    assert v1_schema.names == ["id"]  # version 1: (id int64) only
+    assert live_schema.names == ["id", "score"]  # current: version 3
+
+
+def test_table_get_with_no_at_clause_is_unaffected(client: Any) -> None:
+    """The new `at_unit`/`at_value` params default to `None` — unchanged behavior without them."""
+    info = client.table_get(attach_opaque_data=_attach_opaque(client), schema_name=DATA, name="numbers")
+    assert info is not None
+
+
+def test_table_function_at_unit_reaches_a_worker_that_reads_it_from_init(client: Any) -> None:
+    """`tt_pushdown_scan` reads `at_unit`/`at_value` off the init request, not a resolved bind arg."""
+    v1_batches = list(
+        client.table_function(function_name="tt_pushdown_scan", schema_name=DATA, at_unit="VERSION", at_value="1")
+    )
+    live_batches = list(client.table_function(function_name="tt_pushdown_scan", schema_name=DATA))
+
+    assert sum(b.num_rows for b in v1_batches) == 5
+    assert sum(b.num_rows for b in live_batches) == 10
+
+
+def test_table_function_with_no_at_clause_is_unaffected(client: Any) -> None:
+    """The new `at_unit`/`at_value` params default to `None` — unchanged behavior without them."""
+    batches = list(
+        client.table_function(
+            function_name="sequence", schema_name="main", arguments=Arguments(positional=[pa.scalar(5)])
+        )
+    )
+    assert sum(b.num_rows for b in batches) == 5

{vgi_python-0.29.0 → vgi_python-0.29.3}/uv.lock

@@ -929,6 +929,11 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b9/6d/a637d52449d98a6892d9a4dc0262587afdb6a66f201871842dce5a97b1c1/httpx2-2.10.0-py3-none-any.whl", hash = "sha256:5e3194a432701e1cc6f69a8b1b2fa199ef907013fede8d9a09a2c5b7b8141a18", size = 94355, upload-time = "2026-08-09T09:11:30.882Z" },
 ]
 
+[package.optional-dependencies]
+zstd = [
+    { name = "zstandard", marker = "python_full_version < '3.14'" },
+]
+
 [[package]]
 name = "httpx2-jsfetch"
 version = "1.0"
@@ -2555,7 +2560,7 @@ requires-dist = [
 
 [[package]]
 name = "vgi-python"
-version = "0.28.1"
+version = "0.29.2"
 source = { editable = "." }
 dependencies = [
     { name = "click" },
@@ -2698,7 +2703,7 @@ docs = [
 
 [[package]]
 name = "vgi-rpc"
-version = "0.43.0"
+version = "0.43.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "docstring-parser" },
@@ -2706,9 +2711,9 @@ dependencies = [
     { name = "pywin32", marker = "sys_platform == 'win32'" },
     { name = "tzdata", marker = "sys_platform == 'win32'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/e6/ee/94a47d89eaebcd2ad433b86b0c6017131f5b15ef1d7f02c60fbab4906dbc/vgi_rpc-0.43.0.tar.gz", hash = "sha256:abae616414353cbc18467d4c325369adb5acf0cab36332a35c2a7d463692885b", size = 1142865, upload-time = "2026-08-24T00:43:51.796Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/27/a0/b308cc62cde38fe2a7bc7a2c57bbb8e956084dd04134a4b0d805378daf16/vgi_rpc-0.43.1.tar.gz", hash = "sha256:d94a3c2cfcf90e1122b2b7ec23a47912f1b3e2d265267aa6704bd64c3a7f2a55", size = 1145519, upload-time = "2026-08-27T14:51:14.923Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5c/03/680bc346a6335451f97618e5432ddae3b976e1ff6682ee1e736540980f20/vgi_rpc-0.43.0-py3-none-any.whl", hash = "sha256:227fac13e0053caa73b2d75e62eab155d36dcb457a165d215f7817fdae865fb0", size = 526747, upload-time = "2026-08-24T00:43:50.055Z" },
+    { url = "https://files.pythonhosted.org/packages/96/f2/15bd8a76ee3534c4d911b0f76c948378db4c175a40ceeb30325e6ab994a6/vgi_rpc-0.43.1-py3-none-any.whl", hash = "sha256:1eecd6c17f06d6fadae332be33998d22cdd01e5caaaae7889b747f0c1eaac498", size = 526753, upload-time = "2026-08-27T14:51:12.975Z" },
 ]
 
 [package.optional-dependencies]
@@ -2723,7 +2728,7 @@ external = [
 ]
 http = [
     { name = "falcon" },
-    { name = "httpx2" },
+    { name = "httpx2", extra = ["zstd"] },
     { name = "msgpack" },
     { name = "pycryptodome" },
     { name = "pynacl", marker = "sys_platform == 'linux'" },

{vgi_python-0.29.0 → vgi_python-0.29.3}/vgi/_test_fixtures/table_in_out.py

@@ -95,6 +95,7 @@ __all__ = [
     "RowSumFunction",
     "BlendedDropFunction",
     "SubstreamPartialSumFunction",
+    "MultiBatchFinishFunction",
     "SumAllColumnsFunction",
     "SumAllColumnsSimpleDistributed",
     "ExceptionProcessFunction",
@@ -195,6 +196,88 @@ class SubstreamPartialSumFunction(TableInOutFunction[SingleTableArguments, Subst
         return [pa.RecordBatch.from_pydict({name: [total]}, schema=params.output_schema)]
 
 
+@dataclass(kw_only=True)
+class MultiBatchFinishState(ArrowSerializableDataclass):
+    """This substream's running total and the number of rows it saw."""
+
+    total: int = 0
+    rows: int = 0
+
+
+class MultiBatchFinishFunction(TableInOutFunction[SingleTableArguments, MultiBatchFinishState]):
+    """Streaming FINALIZE that emits MANY batches — the shape no SDK had a fixture for.
+
+    Every other finalize fixture returns a single batch, and one batch is the
+    easy case: over HTTP a producer is strictly lock-step (one batch per
+    response), so a single-batch flush completes in one turn and never needs a
+    continuation. A flush of TWO OR MORE batches does, and in vgi-rust that path
+    was a hard error rather than a pagination — invisible for as long as nothing
+    exercised it.
+
+    So this emits one batch per input row the substream saw: ``rows`` batches,
+    the first carrying that substream's ``total`` and the rest carrying 0. The
+    split is deliberate — it makes the two failure modes distinguishable:
+
+    * ``SUM(n)`` wrong  → a batch's CONTENTS were lost, duplicated or reordered.
+    * ``COUNT(*)`` wrong → a BATCH was lost or repeated. This is the one that
+      catches a broken continuation: a flush truncated after its first batch
+      still sums correctly and only the count betrays it.
+
+    Both invariants hold regardless of how DuckDB fans the input across
+    substreams (each substream's partials sum to the whole, and its batch count
+    equals its row count), so the test needs no assumption about thread count.
+    """
+
+    class Meta:
+        name = "multi_batch_finish"
+        description = "Streaming finalize that emits one batch per input row (multi-batch flush)"
+        categories = ["testing", "aggregation"]
+
+    @classmethod
+    def cardinality(cls, params: BindParams[SingleTableArguments]) -> TableCardinality:
+        # One output row per input row, but the input size is unknown up-front.
+        return TableCardinality(estimate=1, max=None)
+
+    @classmethod
+    def on_bind(cls, params: BindParams[SingleTableArguments]) -> BindResponse:
+        assert params.bind_call.input_schema is not None
+        field = params.bind_call.input_schema.field(0)
+        return BindResponse(output_schema=schema({field.name: pa.int64()}))
+
+    @classmethod
+    def initial_state(cls, params: ProcessParams[SingleTableArguments]) -> MultiBatchFinishState:
+        return MultiBatchFinishState(total=0, rows=0)
+
+    @classmethod
+    def transform(
+        cls,
+        batch: pa.RecordBatch,
+        params: ProcessParams[SingleTableArguments],
+        state: MultiBatchFinishState | None,
+    ) -> list[pa.RecordBatch]:
+        if state is None:
+            raise ValueError("State must not be None in transform()")
+        col_sum = pc.sum(batch.column(0))
+        if col_sum.is_valid:
+            state.total += col_sum.as_py()
+        state.rows += batch.num_rows
+        return []  # accumulate only; the whole point is the flush
+
+    @classmethod
+    def finish(
+        cls,
+        params: ProcessParams[SingleTableArguments],
+        states: list[MultiBatchFinishState],
+    ) -> list[pa.RecordBatch]:
+        total = sum(st.total for st in states)
+        rows = sum(st.rows for st in states)
+        name = params.output_schema.names[0]
+        return [
+            pa.RecordBatch.from_pydict({name: [total if i == 0 else 0]}, schema=params.output_schema)
+            for i in range(rows)
+        ]
+
+
 class EchoFunction(TableInOutGenerator[SingleTableArguments]):
     """Passthrough function that emits each input batch unchanged.
 
@@ -1097,7 +1180,19 @@ class CrashOnProcessFunction(BufferInputFunction):
             os.kill(os.getpid(), signal.SIGABRT)
         else:
             os.kill(os.getpid(), signal.SIGKILL)
-        return params.execution_id  # unreachable
+        # Killing YOURSELF is not synchronous: kill(2) returns on the calling
+        # thread and the kernel tears the task down asynchronously. RETURNING
+        # here hands that window to the framework, which then races to serialize
+        # and write the process response — and how many bytes escape before the
+        # process actually dies decides what the client sees: nothing (the
+        # "RPC response stream EOF" these tests assert), a schema only, a
+        # truncated batch message, or the whole response, in which case the
+        # query SUCCEEDS with zero rows. Measured in the Go SDK, whose fixture
+        # had the identical shape, that was a 23% failure rate — see
+        # vgi-go 41f18d1. CPython's slower interpreter makes it rarer here, not
+        # impossible. Park instead, so this worker can never write another byte.
+        time.sleep(5)
+        raise AssertionError("crash_on_process: SIGKILL did not terminate the worker")
 
 
 class CrashOnCombineFunction(BufferInputFunction):

{vgi_python-0.29.0 → vgi_python-0.29.3}/vgi/_test_fixtures/worker.py

@@ -286,6 +286,7 @@ from vgi._test_fixtures.table_in_out import (
     HangOnProcessFunction,
     HostileProvenanceFunction,
     LargeStateFunction,
+    MultiBatchFinishFunction,
     OrderedBufferInputFunction,
     OrderedSourceFunction,
     ProjectableBlendedFunction,
@@ -441,6 +442,7 @@ _EXAMPLE_CATALOG = Catalog(
                 SecretInOutFunction,
                 RepeatInputsFunction,
                 SlowCancellableInOutFunction,
+                MultiBatchFinishFunction,
                 SubstreamPartialSumFunction,
                 SumAllColumnsFunction,
                 SumAllColumnsSimpleDistributed,