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

{vgi_python-0.34.1 → vgi_python-0.36.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.36.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: vgi-python
-Version: 0.34.1
+Version: 0.36.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.36.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "vgi-python"
-version = "0.34.1"
+version = "0.36.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",
 ]
 
@@ -223,7 +223,12 @@ warn_unused_ignores = false
 python-version = "3.13"
 
 [tool.pytest.ini_options]
-addopts = "--ruff"
+# worksteal: xdist's default "load" hands each worker a contiguous slice of the
+# collection up front, so tests/catalog/test_integration.py (30 tests that each
+# start a fresh catalog worker process, ~0.7 s apiece) all landed on one xdist
+# worker, which then ran for 20 s after the rest had finished. worksteal lets
+# idle workers take queued tests from busy ones. Ignored without -n.
+addopts = "--ruff --dist worksteal"
 testpaths = ["tests"]
 
 [tool.coverage.run]

{vgi_python-0.34.1 → vgi_python-0.36.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.36.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.36.0}/tests/client/test_stop_force.py

@@ -26,8 +26,11 @@ import pytest
 from vgi.arguments import Arguments
 from vgi.client.client import Client, _default_pool
 
-# Long enough that a graceful teardown would have to wait on it if the worker were stuck.
-_SLEEP_MS = 5_000
+# How long the worker sleeps before each row. The first row alone costs this
+# much, so it is kept short; the forced stop is held to half of it (see
+# test_force_returns_promptly_mid_stream), which a teardown that waited out the
+# sleep would miss by a wide margin, and a kill (milliseconds) clears.
+_SLEEP_MS = 2_000
 
 
 def _started_client(**kwargs: Any) -> Client:
@@ -65,10 +68,13 @@ def test_force_returns_promptly_mid_stream(tmp_path: Any) -> None:
     )
     next(gen)  # worker is now mid-stream, sleeping between batches
 
+    # The client's reader thread asks for the next row as soon as it has the
+    # first, so the worker is now inside that row's sleep. A stop that waited
+    # it out would take nearly the whole sleep; hold the kill to half of it.
     started = time.monotonic()
     client.stop(force=True)
     elapsed = time.monotonic() - started
-    assert elapsed < _SLEEP_MS / 1000.0, f"forced stop waited {elapsed:.2f}s on a sleeping worker"
+    assert elapsed < _SLEEP_MS / 2000.0, f"forced stop waited {elapsed:.2f}s on a sleeping worker"
 
 
 def test_graceful_stop_is_unchanged() -> None:

{vgi_python-0.34.1 → vgi_python-0.36.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.36.0}/tests/conftest.py

@@ -2,13 +2,128 @@
 
 """Shared fixtures for VGI tests."""
 
+import contextlib
 import logging
+import os
+import shlex
+import shutil
+import subprocess
+import sys
+import threading
+import uuid
 from typing import Any
 
-import pyarrow as pa
-import pytest
+# pyarrow imports numpy, and numpy's OpenBLAS starts one thread per core at
+# import and busy-waits them: about 2.7 CPU-seconds per process on a 48-core
+# machine. No test does linear algebra. This module is loaded before xdist
+# starts its workers, so every process of the session inherits the setting:
+# xdist workers, fixture and example workers, HTTP servers, CLI runs. On
+# 48 cores it cut the suite's CPU time from 363 s to 208 s.
+os.environ.setdefault("OPENBLAS_NUM_THREADS", "1")
+
+import pyarrow as pa  # noqa: E402
+import pytest  # noqa: E402
+
+from vgi import schema  # noqa: E402
+
+# =============================================================================
+# 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_configure(config: pytest.Config) -> None:
+    """Start the shared fixture worker while the test processes collect.
+
+    Otherwise the first tests to reach it all wait for its start (about a
+    second of imports) and then for the first function listings, which build
+    and encode every function's metadata before it is cached; each costs
+    the one GIL-bound worker 0.2-0.3 s, and the early tests run them all at
+    once. Collection takes several seconds, so warming the worker in the
+    background here costs nothing. Only the controlling process does it.
+    """
+    if hasattr(config, "workerinput") or TEST_TRANSPORT != "launch":
+        return
+    threading.Thread(target=_warm_fixture_worker, name="warm-fixture-worker", daemon=True).start()
+
+
+def _warm_fixture_worker() -> None:
+    """Launch the fixture worker and fill its function-listing caches."""
+    from vgi.catalog import SchemaObjectType
+    from vgi.client import Client
+
+    # Best effort: a worker that cannot start fails the tests that use it, with
+    # the real error.
+    with contextlib.suppress(Exception), Client(FIXTURE_WORKER) as client:
+        attach = client.catalog_attach(name="example", options={}, data_version_spec=None, implementation_version=None)
+        for kind in (
+            SchemaObjectType.TABLE_FUNCTION,
+            SchemaObjectType.SCALAR_FUNCTION,
+            SchemaObjectType.AGGREGATE_FUNCTION,
+        ):
+            list(client.schema_contents(attach_opaque_data=attach.attach_opaque_data, path=["main"], type=kind))
+
+
+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())
 
-from vgi import schema
 
 # =============================================================================
 # Utility Functions (not fixtures, can be imported directly)
@@ -59,6 +174,24 @@ def empty_batch_from_schema(schema: pa.Schema) -> pa.RecordBatch:
     return pa.RecordBatch.from_pydict({field.name: [] for field in schema}, schema=schema)
 
 
+def record_opened_connections(client: Any) -> list[int]:
+    """Record the index of each worker connection a started ``client`` opens from now on.
+
+    The primary connection (index 0) is opened when the client starts, so call
+    this afterwards: the list then holds only secondary connections, which a
+    call opens for fan-out. Only records; each connection is opened for real.
+    """
+    opened: list[int] = []
+    spawn = client._spawn_worker
+
+    def recording_spawn(worker_index: int) -> Any:
+        opened.append(worker_index)
+        return spawn(worker_index)
+
+    client._spawn_worker = recording_spawn
+    return opened
+
+
 # =============================================================================
 # Fixtures
 # =============================================================================
@@ -72,8 +205,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 +251,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 +296,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 +308,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.36.0}/tests/scalar/test_client.py

@@ -4,12 +4,13 @@
 
 from __future__ import annotations
 
+import os
 from typing import cast
 
 import pyarrow as pa
 import pytest
 
-from tests.conftest import assert_total_rows
+from tests.conftest import assert_total_rows, record_opened_connections
 from vgi import schema
 from vgi.arguments import Arguments
 from vgi.client import Client
@@ -388,6 +389,7 @@ class TestScalarFunctionParallel:
         batches = [pa.RecordBatch.from_pydict({"x": list(range(i * 100, (i + 1) * 100))}, schema=s) for i in range(10)]
 
         with Client(fixture_worker, worker_limit=4) as client:
+            opened = record_opened_connections(client)
             outputs = list(
                 client.scalar_function(
                     function_name="double",
@@ -397,6 +399,11 @@ class TestScalarFunctionParallel:
                 )
             )
 
+        # Ten batches dealt round-robin reach every connection the client
+        # allows: four, or one per core on a smaller machine (GitHub's macOS
+        # runners have three).
+        assert opened == list(range(1, min(4, os.cpu_count() or 1)))
+
         # Should get all 1000 rows back
         assert_total_rows(outputs, 1000)
 
@@ -675,9 +682,12 @@ class TestRandomIntFunction:
 class TestScalarMultiWorkerEdgeCases:
     """Tests for edge cases with multiple workers for scalar functions.
 
-    These tests expose timeout/hang bugs when:
+    These tests exposed timeout/hang bugs when:
     - Processing parquet with one batch of zero rows
-    - Additional workers spawned but don't receive batches
+    - Additional workers were spawned but received no batches
+
+    The client now opens a secondary connection only when a batch is dealt to
+    it, so no connection sits idle. The tests check that too.
     """
 
     def test_zero_row_batch_single_worker(self, fixture_worker: str) -> None:
@@ -704,8 +714,9 @@ class TestScalarMultiWorkerEdgeCases:
         s = schema(x=pa.int64())
         zero_row_batch = pa.RecordBatch.from_pydict({"x": []}, schema=s)
 
-        # Force 4 workers even though there's only one batch with zero rows
+        # Allow 4 workers even though there's only one batch with zero rows
         with Client(fixture_worker, worker_limit=4) as client:
+            opened = record_opened_connections(client)
             outputs = list(
                 client.scalar_function(
                     function_name="double",
@@ -715,17 +726,19 @@ class TestScalarMultiWorkerEdgeCases:
                 )
             )
 
-        # Should complete without hanging
+        # Should complete without hanging, on the primary alone
         assert len(outputs) == 1
         assert outputs[0].num_rows == 0
+        assert opened == []
 
     def test_single_batch_multiple_workers(self, fixture_worker: str) -> None:
         """Single normal batch with max_workers=4 should complete without hanging."""
         s = schema(x=pa.int64())
         single_batch = pa.RecordBatch.from_pydict({"x": [1, 2, 3]}, schema=s)
 
-        # Force 4 workers even though there's only 1 batch
+        # Allow 4 workers even though there's only 1 batch
         with Client(fixture_worker, worker_limit=4) as client:
+            opened = record_opened_connections(client)
             outputs = list(
                 client.scalar_function(
                     function_name="double",
@@ -737,6 +750,7 @@ class TestScalarMultiWorkerEdgeCases:
 
         # Should complete without hanging and return correct data
         assert_total_rows(outputs, 3)
+        assert opened == []
 
     def test_fewer_batches_than_workers(self, fixture_worker: str) -> None:
         """2 batches with max_workers=4 should complete without hanging."""
@@ -744,8 +758,9 @@ class TestScalarMultiWorkerEdgeCases:
         batch1 = pa.RecordBatch.from_pydict({"x": [1, 2]}, schema=s)
         batch2 = pa.RecordBatch.from_pydict({"x": [3, 4, 5]}, schema=s)
 
-        # Force 4 workers even though there are only 2 batches
+        # Allow 4 workers even though there are only 2 batches
         with Client(fixture_worker, worker_limit=4) as client:
+            opened = record_opened_connections(client)
             outputs = list(
                 client.scalar_function(
                     function_name="double",
@@ -757,3 +772,5 @@ class TestScalarMultiWorkerEdgeCases:
 
         # Should complete without hanging and return correct data (5 rows total)
         assert_total_rows(outputs, 5)
+        # The second batch opened the one secondary connection it needed.
+        assert opened == [1]

{vgi_python-0.34.1 → vgi_python-0.36.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.36.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.36.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.36.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",