vgi-python 0.34.1__tar.gz → 0.35.0__tar.gz

{vgi_python-0.34.1 → vgi_python-0.35.0}/CLAUDE.md

@@ -298,7 +298,6 @@ vgi-client --input data.parquet --function sum_all_columns --worker vgi-fixture-
 | `VGI_OAUTH_DEVICE_CODE_CLIENT_SECRET` | Client secret for device-code flow (optional, URL-safe chars only) |
 | `VGI_OAUTH_USE_ID_TOKEN` | When `1`/`true`/`yes`, clients use OIDC `id_token` as Bearer instead of `access_token` |
 | `VGI_INTROSPECT_PRINCIPALS` | Comma-separated principals permitted to call `vgi_rpc.Identity.v1`'s `introspect_token`. Required — no permissive default — whenever the worker implements `resolve_token()` (see below) |
-| `VGI_INTROSPECT_RATE_LIMIT` | Introspection requests allowed per caller per second (default 20) |
 | `VGI_WORKER_ACCESS_LOG_SAMPLE` | Fraction of *successful* calls to keep in the access log, `0.0`–`1.0`. Errors are always kept; the decision is per call, so every record of one stream shares a fate |
 | `VGI_WORKER_ACCESS_LOG_ASYNC` | When `1`/`true`/`yes`, emit access-log records from a listener thread. Bounded queue; full means drop, and a crash loses whatever is queued |
 | `VGI_WORKER_ACCESS_LOG_QUEUE_SIZE` | Bound on the async access-log queue (default 10000) |
@@ -461,8 +460,10 @@ Enabling it also requires an allowlist of principals permitted to ask, via
 default and a worker that overrides the hook without one **refuses to start**:
 authenticating and introspecting are different capabilities, and "any
 authenticated caller" lets any user resolve any other user's credential to its
-owner. `--introspect-rate-limit` (default 20/caller/second) bounds, rather than
-closes, the oracle an allowlisted-but-compromised caller still has.
+owner. Introspection is deliberately not rate limited (vgi-rpc removed the
+limiter): the allowlisted caller is a proxy asking on behalf of every client, so a
+per-caller limit was one budget for every user's login, drainable by junk
+credentials. Throttle untrusted traffic at the proxy, per client.
 
 Return `None` for "the store answered and this credential is unknown"; raise
 `AuthUnavailableError` for "the answer is not knowable". A caller that

{vgi_python-0.34.1 → vgi_python-0.35.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: vgi-python
-Version: 0.34.1
+Version: 0.35.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
@@ -162,7 +162,7 @@ Requires-Dist: httpx2>=2.9.1
 Requires-Dist: platformdirs
 Requires-Dist: pyarrow
 Requires-Dist: typer>=0.9
-Requires-Dist: vgi-rpc>=0.46.0
+Requires-Dist: vgi-rpc>=0.47.0
 Provides-Extra: azure
 Requires-Dist: azure-identity>=1.16.0; extra == 'azure'
 Requires-Dist: pymssql>=2.3.0; extra == 'azure'

{vgi_python-0.34.1 → vgi_python-0.35.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "vgi-python"
-version = "0.34.1"
+version = "0.35.0"
 description = "Vector Gateway Interface - Connect DuckDB to external programs via Apache Arrow"
 readme = "README.md"
 keywords = [
@@ -40,7 +40,7 @@ dependencies = [
     "pyarrow",
     "typer>=0.9",
     "platformdirs",
-    "vgi-rpc>=0.46.0",
+    "vgi-rpc>=0.47.0",
     "httpx2>=2.9.1",
 ]
 

{vgi_python-0.34.1 → vgi_python-0.35.0}/tests/catalog/test_client_catalog.py

@@ -10,13 +10,9 @@ For full catalog CRUD workflows (create/get/drop tables, views, schemas),
 see tests/catalog/test_integration.py which exercises all catalog operations.
 """
 
-import sys
-
+from tests.conftest import CATALOG_WORKER
 from vgi.client import Client
 
-# Worker command for catalog tests
-CATALOG_WORKER = f"{sys.executable} -m vgi._test_fixtures.catalog"
-
 
 class TestClientCatalogStatelessOperations:
     """Test catalog operations that work independently."""

{vgi_python-0.34.1 → vgi_python-0.35.0}/tests/catalog/test_example_worker_catalog.py

@@ -8,6 +8,7 @@ interface, allowing clients to discover available functions.
 
 import pyarrow as pa
 
+from tests.conftest import FIXTURE_WORKER
 from vgi._test_fixtures.worker import ExampleWorker
 from vgi.catalog import (
     AttachOpaqueData,
@@ -23,7 +24,7 @@ from vgi.catalog import (
 from vgi.client import Client
 
 # Worker command for catalog tests
-EXAMPLE_WORKER = "vgi-fixture-worker"
+EXAMPLE_WORKER = FIXTURE_WORKER
 
 
 def _get_expected_function_names() -> set[str]:

{vgi_python-0.34.1 → vgi_python-0.35.0}/tests/conformance/test_function_inventory.py

@@ -19,6 +19,7 @@ from dataclasses import dataclass
 
 import pytest
 
+from tests.conftest import FIXTURE_WORKER
 from vgi.catalog.catalog_interface import AttachOpaqueData, SchemaObjectType
 from vgi.client.client import Client
 
@@ -79,7 +80,7 @@ _COVERAGE_MAP: dict[SchemaObjectType, TypeCoverage] = {
 @pytest.fixture(scope="module")
 def attached_example() -> tuple[str, AttachOpaqueData]:
     """Attach to the ``example`` catalog once per module and yield ``(worker, attach_opaque_data)``."""
-    worker = "vgi-fixture-worker"
+    worker = FIXTURE_WORKER
     client = Client(worker)
     result = client.catalog_attach(
         name=EXAMPLE_CATALOG_NAME,
@@ -92,7 +93,7 @@ def attached_example() -> tuple[str, AttachOpaqueData]:
 
 def test_example_catalog_is_attachable() -> None:
     """Sanity: the example worker advertises a catalog named ``example``."""
-    client = Client("vgi-fixture-worker")
+    client = Client(FIXTURE_WORKER)
     names = [c.name for c in client.catalogs()]
     assert EXAMPLE_CATALOG_NAME in names, (
         f"Example worker should advertise the {EXAMPLE_CATALOG_NAME!r} catalog; got {names!r}"
@@ -149,7 +150,7 @@ def test_fixture_worker_registers_at_least_one_per_category(
     broken — both are drift we want to catch.
     """
     _worker, attach_opaque_data = attached_example
-    client = Client("vgi-fixture-worker")
+    client = Client(FIXTURE_WORKER)
     infos = client.schema_contents(
         attach_opaque_data=attach_opaque_data,
         path=[EXAMPLE_SCHEMA_NAME],

{vgi_python-0.34.1 → vgi_python-0.35.0}/tests/conftest.py

@@ -3,6 +3,12 @@
 """Shared fixtures for VGI tests."""
 
 import logging
+import os
+import shlex
+import shutil
+import subprocess
+import sys
+import uuid
 from typing import Any
 
 import pyarrow as pa
@@ -10,6 +16,73 @@ import pytest
 
 from vgi import schema
 
+# =============================================================================
+# Fixture-worker transport
+# =============================================================================
+
+# How tests reach the fixture workers. ``launch`` (the default wherever AF_UNIX
+# exists) routes every fixture-worker ``Client`` through ``vgi_rpc.launcher``:
+# one warm worker per command, shared by every test process, so ``pytest -n 48``
+# talks to one worker instead of each xdist process growing its own pool (and
+# the matrix's ``subprocess-direct`` leg spawning a fresh worker per test) —
+# which put hundreds of ``vgi-fixture-worker`` processes on a 48-core box.
+# ``VGI_TEST_CLIENT_TRANSPORT=subprocess`` restores the per-process pools.
+TEST_TRANSPORT = os.environ.get("VGI_TEST_CLIENT_TRANSPORT") or ("subprocess" if sys.platform == "win32" else "launch")
+if TEST_TRANSPORT not in ("launch", "subprocess"):
+    raise pytest.UsageError(f"VGI_TEST_CLIENT_TRANSPORT must be 'launch' or 'subprocess', got {TEST_TRANSPORT!r}")
+
+# Part of the launcher's hash domain (it hashes every ``VGI_RPC_*`` variable), so
+# each session gets its own workers: never a warm one left by an earlier run of
+# older code, and never one another checkout on the machine is using. Set here,
+# before xdist spawns its workers, so every process of one session agrees on it.
+_SESSION_ENV = "VGI_RPC_TEST_SESSION"
+os.environ.setdefault(_SESSION_ENV, uuid.uuid4().hex)
+
+_LAUNCHED: list[list[str]] = []
+
+
+def _fixture_command(*argv: str) -> str:
+    """Return the ``Client`` worker string for a fixture command under ``TEST_TRANSPORT``."""
+    if TEST_TRANSPORT == "subprocess":
+        # Unquoted, as these commands always were: Windows splits server_path
+        # non-POSIX, so shlex quoting around a backslashed python.exe path
+        # stayed on the argv and the executable was not found.
+        return " ".join(argv)
+    # Every test process shares the one worker, so its connection cap must sit
+    # above anything the suite opens: at the default 64 a scan holding its
+    # connections while its next one waits in the backlog can wait on the others
+    # doing the same, forever. Finite because ``Worker.main`` refuses 0.
+    launch_argv = [shutil.which(argv[0]) or argv[0], *argv[1:], "--max-connections", "4096"]
+    _LAUNCHED.append(launch_argv)
+    return "launch:" + shlex.join(launch_argv)
+
+
+#: The protocol fixture worker, and the catalog fixture worker.
+FIXTURE_WORKER = _fixture_command("vgi-fixture-worker")
+CATALOG_WORKER = _fixture_command(sys.executable, "-m", "vgi._test_fixtures.catalog")
+
+#: The protocol fixture worker as a plain subprocess, for tests of the
+#: subprocess transport itself (stderr capture, pooling).
+SUBPROCESS_FIXTURE_WORKER = "vgi-fixture-worker"
+
+
+def pytest_unconfigure(config: pytest.Config) -> None:
+    """Stop this session's launched workers rather than leaving them to idle out.
+
+    Only the controlling process does it — an xdist worker finishing early must
+    not pull the shared worker out from under the others.
+    """
+    if hasattr(config, "workerinput") or not _LAUNCHED or sys.platform == "win32":
+        return
+    from vgi_rpc.launcher import compute_hash, default_state_dir, gc_state_dir
+
+    for argv in _LAUNCHED:
+        # The worker's argv carries ``--unix <state dir>/<hash>.sock``, and the
+        # session variable makes that hash this session's alone.
+        subprocess.run(["pkill", "-TERM", "-f", f"{compute_hash(argv)}.sock"], check=False)
+    gc_state_dir(default_state_dir())
+
+
 # =============================================================================
 # Utility Functions (not fixtures, can be imported directly)
 # =============================================================================
@@ -72,8 +145,8 @@ def test_logger() -> logging.Logger:
 
 @pytest.fixture
 def fixture_worker() -> str:
-    """Return the path to the example worker."""
-    return "vgi-fixture-worker"
+    """Return the example worker, as a ``Client`` worker string for ``TEST_TRANSPORT``."""
+    return FIXTURE_WORKER
 
 
 @pytest.fixture(scope="session")
@@ -118,8 +191,11 @@ def http_worker() -> Any:
 # Keys used to identify transport modes in conformance tests. Keeping the
 # literal values here (rather than inside the fixture) makes it easy for
 # individual tests to opt out with ``@pytest.mark.parametrize("client_transport",
-# ["subprocess-pooled"], indirect=True)``.
-_CLIENT_TRANSPORT_MODES = ["subprocess-pooled", "subprocess-direct", "http"]
+# ["subprocess-pooled"], indirect=True)``. The subprocess legs join the default
+# matrix only under ``VGI_TEST_CLIENT_TRANSPORT=subprocess``.
+_CLIENT_TRANSPORT_MODES = (
+    ["launch", "http"] if TEST_TRANSPORT == "launch" else ["subprocess-pooled", "subprocess-direct", "http"]
+)
 
 
 @pytest.fixture(scope="session")
@@ -160,7 +236,8 @@ def client_transport(
     returned client as a context manager.
 
     Modes:
-        subprocess-pooled: Pool-backed subprocess (the default path).
+        launch: The launcher-shared worker (``launch:`` worker string).
+        subprocess-pooled: Pool-backed subprocess.
         subprocess-direct: ``pool=None`` — direct Popen management.
         http: ``Client.from_http(base_url)`` backed by a per-test
             ``vgi-fixture-http`` subprocess. Skips if the HTTP transport
@@ -171,10 +248,14 @@ def client_transport(
     mode = request.param
 
     def _make() -> Client:
+        if mode == "launch":
+            if TEST_TRANSPORT != "launch":
+                pytest.skip("VGI_TEST_CLIENT_TRANSPORT=subprocess")
+            return Client(fixture_worker)
         if mode == "subprocess-pooled":
-            return Client(fixture_worker, pool=_default_pool)
+            return Client(SUBPROCESS_FIXTURE_WORKER, pool=_default_pool)
         if mode == "subprocess-direct":
-            return Client(fixture_worker, pool=None)
+            return Client(SUBPROCESS_FIXTURE_WORKER, pool=None)
         if mode == "http":
             if not _HTTP_TRANSPORT_READY:
                 pytest.skip("Client HTTP transport arrives in Phase 2 of whimsical-mccarthy plan")

{vgi_python-0.34.1 → vgi_python-0.35.0}/tests/table/generator/test_exception_function.py

@@ -5,6 +5,7 @@
 import pyarrow as pa
 import pytest
 
+from tests.conftest import FIXTURE_WORKER
 from vgi.arguments import Arguments
 from vgi.client import Client, ClientError
 
@@ -15,7 +16,7 @@ class TestGeneratorExceptionFunctionViaClient:
     def test_raises_exception_after_batches(self) -> None:
         """Function should raise exception after specified batches via Client."""
         with (
-            Client("vgi-fixture-worker") as client,
+            Client(FIXTURE_WORKER) as client,
             pytest.raises(ClientError) as exc_info,
         ):
             list(
@@ -31,7 +32,7 @@ class TestGeneratorExceptionFunctionViaClient:
     def test_raises_exception_immediately(self) -> None:
         """Function with fail_after=0 should raise immediately via Client."""
         with (
-            Client("vgi-fixture-worker") as client,
+            Client(FIXTURE_WORKER) as client,
             pytest.raises(ClientError) as exc_info,
         ):
             list(
@@ -46,7 +47,7 @@ class TestGeneratorExceptionFunctionViaClient:
 
     def test_outputs_batches_before_failure(self) -> None:
         """Function should output batches before failing via Client."""
-        with Client("vgi-fixture-worker") as client:
+        with Client(FIXTURE_WORKER) as client:
             outputs: list[pa.RecordBatch] = []
             try:
                 for batch in client.table_function(

{vgi_python-0.34.1 → vgi_python-0.35.0}/tests/table/generator/test_filter_echo_function.py

@@ -4,6 +4,7 @@
 
 import pyarrow as pa
 
+from tests.conftest import FIXTURE_WORKER
 from vgi.arguments import Arguments
 from vgi.client import Client
 
@@ -13,7 +14,7 @@ class TestFilterEchoFunction:
 
     def test_no_filter_output(self) -> None:
         """Without filters, pushed_filters should be '(none)' for all rows."""
-        with Client("vgi-fixture-worker") as client:
+        with Client(FIXTURE_WORKER) as client:
             batches = list(
                 client.table_function(
                     function_name="filter_echo",
@@ -36,7 +37,7 @@ class TestFilterEchoFunction:
 
     def test_count_argument(self) -> None:
         """Verify row count matches the count argument."""
-        with Client("vgi-fixture-worker") as client:
+        with Client(FIXTURE_WORKER) as client:
             batches = list(
                 client.table_function(
                     function_name="filter_echo",
@@ -50,7 +51,7 @@ class TestFilterEchoFunction:
 
     def test_s_column_values(self) -> None:
         """The s column should match 'row_{n}' pattern."""
-        with Client("vgi-fixture-worker") as client:
+        with Client(FIXTURE_WORKER) as client:
             batches = list(
                 client.table_function(
                     function_name="filter_echo",

{vgi_python-0.34.1 → vgi_python-0.35.0}/tests/table/generator/test_logging_function.py

@@ -4,6 +4,7 @@
 
 import pyarrow as pa
 
+from tests.conftest import FIXTURE_WORKER
 from vgi.arguments import Arguments
 from vgi.client import Client
 
@@ -13,7 +14,7 @@ class TestLoggingGeneratorFunctionViaClient:
 
     def test_generates_correct_output(self) -> None:
         """Function should generate correct output via Client."""
-        with Client("vgi-fixture-worker") as client:
+        with Client(FIXTURE_WORKER) as client:
             outputs = list(
                 client.table_function(
                     function_name="logging_generator",
@@ -31,7 +32,7 @@ class TestLoggingGeneratorFunctionViaClient:
 
     def test_zero_count_produces_no_output(self) -> None:
         """Function with count=0 should produce no output via Client."""
-        with Client("vgi-fixture-worker") as client:
+        with Client(FIXTURE_WORKER) as client:
             outputs = list(
                 client.table_function(
                     function_name="logging_generator",
@@ -44,7 +45,7 @@ class TestLoggingGeneratorFunctionViaClient:
 
     def test_large_output(self) -> None:
         """Function should handle larger outputs via Client."""
-        with Client("vgi-fixture-worker") as client:
+        with Client(FIXTURE_WORKER) as client:
             outputs = list(
                 client.table_function(
                     function_name="logging_generator",

{vgi_python-0.34.1 → vgi_python-0.35.0}/tests/table/generator/test_partitioned_function.py

@@ -8,6 +8,7 @@ from typing import Any
 
 import pyarrow as pa
 
+from tests.conftest import FIXTURE_WORKER
 from vgi.arguments import Arguments
 from vgi.client import Client
 
@@ -22,7 +23,7 @@ class TestPartitionedSequenceFunctionMultiWorker:
 
     def test_two_workers_produce_complete_sequence(self) -> None:
         """Two workers should together produce the complete sequence."""
-        with Client("vgi-fixture-worker", worker_limit=2) as client:
+        with Client(FIXTURE_WORKER, worker_limit=2) as client:
             outputs = list(
                 client.table_function(
                     function_name="partitioned_sequence",
@@ -39,7 +40,7 @@ class TestPartitionedSequenceFunctionMultiWorker:
 
     def test_three_workers_produce_complete_sequence(self) -> None:
         """Three workers should together produce the complete sequence."""
-        with Client("vgi-fixture-worker", worker_limit=3) as client:
+        with Client(FIXTURE_WORKER, worker_limit=3) as client:
             outputs = list(
                 client.table_function(
                     function_name="partitioned_sequence",
@@ -56,7 +57,7 @@ class TestPartitionedSequenceFunctionMultiWorker:
 
     def test_workers_produce_large_sequence(self) -> None:
         """Multiple workers should handle large sequences."""
-        with Client("vgi-fixture-worker", worker_limit=4) as client:
+        with Client(FIXTURE_WORKER, worker_limit=4) as client:
             outputs = list(
                 client.table_function(
                     function_name="partitioned_sequence",
@@ -73,7 +74,7 @@ class TestPartitionedSequenceFunctionMultiWorker:
 
     def test_uneven_distribution(self) -> None:
         """Workers should handle sequences that don't divide evenly."""
-        with Client("vgi-fixture-worker", worker_limit=3) as client:
+        with Client(FIXTURE_WORKER, worker_limit=3) as client:
             outputs = list(
                 client.table_function(
                     function_name="partitioned_sequence",
@@ -90,7 +91,7 @@ class TestPartitionedSequenceFunctionMultiWorker:
 
     def test_single_worker_fallback(self) -> None:
         """worker_limit=1 should work like single worker mode."""
-        with Client("vgi-fixture-worker", worker_limit=1) as client:
+        with Client(FIXTURE_WORKER, worker_limit=1) as client:
             outputs = list(
                 client.table_function(
                     function_name="partitioned_sequence",
@@ -107,7 +108,7 @@ class TestPartitionedSequenceFunctionMultiWorker:
 
     def test_increment_with_multi_workers(self) -> None:
         """Multiple workers should handle increment parameter."""
-        with Client("vgi-fixture-worker", worker_limit=2) as client:
+        with Client(FIXTURE_WORKER, worker_limit=2) as client:
             outputs = list(
                 client.table_function(
                     function_name="partitioned_sequence",

{vgi_python-0.34.1 → vgi_python-0.35.0}/tests/table/generator/test_projected_data_function.py

@@ -4,6 +4,7 @@
 
 import pyarrow as pa
 
+from tests.conftest import FIXTURE_WORKER
 from vgi.arguments import Arguments
 
 
@@ -14,7 +15,7 @@ class TestProjectedDataFunctionViaClient:
         """Projection should work correctly via Client subprocess."""
         from vgi.client import Client
 
-        with Client("vgi-fixture-worker", worker_limit=1) as client:
+        with Client(FIXTURE_WORKER, worker_limit=1) as client:
             outputs = list(
                 client.table_function(
                     function_name="projected_data",
@@ -36,7 +37,7 @@ class TestProjectedDataFunctionViaClient:
         """All columns should be returned when no projection specified."""
         from vgi.client import Client
 
-        with Client("vgi-fixture-worker", worker_limit=1) as client:
+        with Client(FIXTURE_WORKER, worker_limit=1) as client:
             outputs = list(
                 client.table_function(
                     function_name="projected_data",

{vgi_python-0.34.1 → vgi_python-0.35.0}/tests/table/generator/test_sequence_function.py

@@ -4,6 +4,7 @@
 
 import pyarrow as pa
 
+from tests.conftest import FIXTURE_WORKER
 from vgi.arguments import Arguments
 from vgi.client import Client
 from vgi.invocation import BindResponse
@@ -19,7 +20,7 @@ class TestSequenceFunctionClient:
         def capture_bind_result(result: BindResponse) -> None:
             bind_results.append(result)
 
-        with Client("vgi-fixture-worker") as client:
+        with Client(FIXTURE_WORKER) as client:
             list(
                 client.table_function(
                     function_name="sequence",

{vgi_python-0.34.1 → vgi_python-0.35.0}/tests/table/generator/test_settings_function.py

@@ -5,6 +5,7 @@
 import pyarrow as pa
 import pytest
 
+from tests.conftest import FIXTURE_WORKER
 from vgi._test_fixtures.table import SettingsAwareFunction
 from vgi.arguments import Arguments
 from vgi.client.client import Client, ClientError
@@ -15,7 +16,7 @@ class TestSettingsViaClient:
 
     def test_settings_passed_to_function_verbose_false(self) -> None:
         """Settings should be passed through Client to function (typed values)."""
-        with Client("vgi-fixture-worker") as client:
+        with Client(FIXTURE_WORKER) as client:
             outputs = list(
                 client.table_function(
                     function_name="settings_aware",
@@ -39,7 +40,7 @@ class TestSettingsViaClient:
 
     def test_settings_passed_to_function_verbose_true(self) -> None:
         """Verbose mode should add details column (typed bool)."""
-        with Client("vgi-fixture-worker") as client:
+        with Client(FIXTURE_WORKER) as client:
             outputs = list(
                 client.table_function(
                     function_name="settings_aware",
@@ -63,7 +64,7 @@ class TestSettingsViaClient:
 
     def test_settings_as_strings_backward_compat(self) -> None:
         """String settings should still work for backward compatibility."""
-        with Client("vgi-fixture-worker") as client:
+        with Client(FIXTURE_WORKER) as client:
             outputs = list(
                 client.table_function(
                     function_name="settings_aware",
@@ -87,7 +88,7 @@ class TestSettingsViaClient:
 
     def test_missing_required_setting_fails(self) -> None:
         """Missing required setting should raise error."""
-        with Client("vgi-fixture-worker") as client:
+        with Client(FIXTURE_WORKER) as client:
             with pytest.raises(ClientError) as exc_info:
                 # Call without required settings - worker should send bind error
                 list(

{vgi_python-0.34.1 → vgi_python-0.35.0}/tests/table/generator/test_struct_settings_function.py

@@ -4,6 +4,7 @@
 
 import pyarrow as pa
 
+from tests.conftest import FIXTURE_WORKER
 from vgi.arguments import Arguments
 from vgi.client import Client
 
@@ -13,7 +14,7 @@ class TestStructSettingsFunction:
 
     def test_struct_setting_basic(self) -> None:
         """Struct setting should configure sequence generation."""
-        with Client("vgi-fixture-worker") as client:
+        with Client(FIXTURE_WORKER) as client:
             outputs = list(
                 client.table_function(
                     function_name="struct_settings",
@@ -32,7 +33,7 @@ class TestStructSettingsFunction:
 
     def test_struct_setting_different_values(self) -> None:
         """Different struct values should produce different output."""
-        with Client("vgi-fixture-worker") as client:
+        with Client(FIXTURE_WORKER) as client:
             outputs = list(
                 client.table_function(
                     function_name="struct_settings",

{vgi_python-0.34.1 → vgi_python-0.35.0}/tests/table_in_out/generator/test_substream_partial_sum_function.py

@@ -2,29 +2,37 @@
 
 """Tests for SubstreamPartialSumFunction (parallel streaming finalize, A4).
 
-At the single-worker client level there is exactly one substream, so ``finish()``
-sees all input and emits one partial row equal to the whole sum. The per-substream
-fan-out (many partials re-aggregated by an outer ``SELECT sum()``) is exercised by
-the C++ integration test ``table_in_out/parallel_finalize.test`` over both
-transports; here we assert the worker-side transform/finish contract in isolation.
+The Python client fans the input across its connections, each its own substream
+of one execution, and finalizes once: ``finish()`` receives every substream's
+state and emits one partial row equal to the whole sum. The DuckDB-side fan-out
+(many partials re-aggregated by an outer ``SELECT sum()``) is exercised by the
+C++ integration test ``table_in_out/parallel_finalize.test`` over both transports.
+
+Run over every client transport because the state is keyed per substream: over
+HTTP one process serves every connection of the fan-out, which is where a
+per-process key let the connections overwrite each other's state.
 """
 
 from __future__ import annotations
 
+from typing import Any
+
 import pyarrow as pa
+import pytest
 
 from tests.conftest import filter_non_empty, make_schema
 from vgi.client import Client
+from vgi.client import client as client_module
 
 
 class TestSubstreamPartialSumFunction:
     """Worker-side contract for substream_partial_sum."""
 
-    def test_partial_sum_single_batch(self, fixture_worker: str) -> None:
+    def test_partial_sum_single_batch(self, client_transport: Any) -> None:
         """One substream (single client worker) → one partial = the whole sum."""
         schema = make_schema([pa.field("n", pa.int64())])
         batch = pa.RecordBatch.from_pydict({"n": [1, 2, 3, 4, 5]}, schema=schema)
-        with Client(fixture_worker) as client:
+        with client_transport() as client:
             output = list(
                 client.table_in_out_function(
                     function_name="substream_partial_sum",
@@ -36,14 +44,14 @@ class TestSubstreamPartialSumFunction:
         assert len(non_empty) == 1
         assert non_empty[0].to_pydict() == {"n": [15]}
 
-    def test_partial_sum_many_batches(self, fixture_worker: str) -> None:
+    def test_partial_sum_many_batches(self, client_transport: Any) -> None:
         """Accumulates across many input batches, emits one partial at finalize."""
         schema = make_schema([pa.field("n", pa.int64())])
         batches = [
             pa.RecordBatch.from_pydict({"n": list(range(i * 100, (i + 1) * 100))}, schema=schema) for i in range(20)
         ]
         expected = sum(range(0, 2000))
-        with Client(fixture_worker) as client:
+        with client_transport() as client:
             output = list(
                 client.table_in_out_function(
                     function_name="substream_partial_sum",
@@ -55,11 +63,11 @@ class TestSubstreamPartialSumFunction:
         assert len(non_empty) == 1
         assert non_empty[0].to_pydict() == {"n": [expected]}
 
-    def test_partial_sum_empty_input(self, fixture_worker: str) -> None:
+    def test_partial_sum_empty_input(self, client_transport: Any) -> None:
         """No input rows → the single substream's partial is 0."""
         schema = make_schema([pa.field("n", pa.int64())])
         empty = pa.RecordBatch.from_pydict({"n": []}, schema=schema)
-        with Client(fixture_worker) as client:
+        with client_transport() as client:
             output = list(
                 client.table_in_out_function(
                     function_name="substream_partial_sum",
@@ -71,3 +79,27 @@ class TestSubstreamPartialSumFunction:
         # A single substream with zero rows still finalizes → one 0 partial.
         assert len(non_empty) == 1
         assert non_empty[0].to_pydict() == {"n": [0]}
+
+    def test_a_client_sending_no_substream_id_still_sums_over_subprocess(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        """An older client sends no ``substream_id``; the worker keys it by process, as before.
+
+        Over subprocess every connection is its own process, so that key still
+        separates them — the behavior such a client had before the key moved.
+        """
+        monkeypatch.setattr(client_module, "_substream_id_for", lambda phase: None)
+        schema = make_schema([pa.field("n", pa.int64())])
+        batches = [
+            pa.RecordBatch.from_pydict({"n": list(range(i * 100, (i + 1) * 100))}, schema=schema) for i in range(20)
+        ]
+        # A plain subprocess worker whatever transport the suite runs on; four
+        # connections are enough to share an execution, where a worker per core
+        # would be dozens of processes.
+        with Client("vgi-fixture-worker", worker_limit=4) as client:
+            output = list(
+                client.table_in_out_function(
+                    function_name="substream_partial_sum",
+                    schema_path=["main"],
+                    input=iter(batches),
+                )
+            )
+        assert filter_non_empty(output)[0].to_pydict() == {"n": [sum(range(0, 2000))]}