vgi-python 0.27.0__tar.gz → 0.28.1__tar.gz

{vgi_python-0.27.0 → vgi_python-0.28.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: vgi-python
-Version: 0.27.0
+Version: 0.28.1
 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.27.0 → vgi_python-0.28.1}/docs/column-statistics.md

@@ -180,6 +180,30 @@ Statistics are transmitted via the `catalog_table_column_statistics_get` RPC met
 
 Cache TTL is carried as IPC batch `custom_metadata` with key `cache_max_age_seconds`.
 
+## Reading Statistics From a Client
+
+DuckDB is not the only caller. A pure-Python [`Client`][vgi.client.Client] reads the same statistics with
+`table_column_statistics`, which issues the RPC and decodes the sparse-union batch for you:
+
+```python test="skip"
+stats = client.table_column_statistics(
+    attach_opaque_data=attach.attach_opaque_data,
+    schema_name="main",
+    name="events",
+)
+for column in stats:
+    print(column.column_name, column.min, column.max, column.distinct_count)
+```
+
+Workers may also inline statistics on `TableInfo.column_statistics` rather than serving them
+lazily; `TableInfo.supports_column_statistics` advertises which. Prefer the inlined copy when
+it is present and fall back to the call above.
+
+To decode bytes you already hold, use `deserialize_column_statistics` — the inverse of
+`serialize_column_statistics`. The `cache_max_age_seconds` TTL travels in the batch's custom
+metadata rather than in the statistics, so read it with `deserialize_record_batch` if you
+need it.
+
 ## Capability Flags
 
 Statistics are opt-in at two levels:

{vgi_python-0.27.0 → vgi_python-0.28.1}/docs/how-to/function-patterns.md

@@ -213,6 +213,31 @@ ATTACH 'buffers' (TYPE vgi, LOCATION 'uv run row_count_worker.py');
 SELECT * FROM buffers.row_count((SELECT * FROM big_table));
 ```
 
+### Getting the input in order
+
+The sink runs in parallel across DuckDB threads, so `process` sees batches in no particular order.
+When output depends on input *order* — a running total, a row pattern match — set
+`Meta.requires_input_batch_index = True` and each `process` call receives `params.batch_index`, a
+monotonic ordinal you can sort the buffered batches by in `finalize`.
+
+Not every source can supply one (a base table scan can; `range()` and `VALUES` cannot). When it
+cannot, the extension serializes the sink and numbers the batches itself, so a worker always gets a
+valid index and callers never have to wrap their input. This example reports the indices it saw, one
+row per buffered batch:
+
+```python
+--8<-- "examples/batch_index_worker.py"
+```
+
+```sql
+ATTACH 'bi' (TYPE vgi, LOCATION 'uv run batch_index_worker.py');
+SELECT * FROM bi.batch_indexes((SELECT * FROM range(5000))) ORDER BY batch_index;
+```
+
+The alternative, `Meta.sink_order_dependent = True`, delivers ordered input by forcing a
+single-threaded sink. It works with any source but gives up parallel ingest, which is usually the
+bulk of a buffering query's wall time. The two flags are mutually exclusive.
+
 ??? info "Buffering vs. table-in-out"
     Both consume a relation, but a **table-in-out** function emits *per input batch* and never
     holds the whole input — use it for streaming transforms (filter, enrich, reshape). Reach for

vgi_python-0.28.1/examples/batch_index_worker.py

@@ -0,0 +1,142 @@
+# /// script
+# requires-python = ">=3.13"
+# dependencies = ["vgi-python"]
+# ///
+"""A buffering function that asks for input order, and reports what it got.
+
+A buffering sink normally runs in parallel across DuckDB threads, so batches
+arrive in no particular order. Setting ``Meta.requires_input_batch_index`` asks
+for DuckDB's per-chunk index alongside each batch, which is what lets a worker
+put the input back in order — the prerequisite for anything order-sensitive,
+like row pattern matching or a running total.
+
+Not every source can supply one: a base table scan can, while ``range()`` and
+``VALUES`` cannot. When it cannot, the extension serializes the sink and numbers
+the batches itself, so a worker sees a valid monotonic index either way and never
+has to care which route produced it.
+
+This function emits one row per buffered batch — its index and its row count — so
+the guarantee is directly observable:
+
+    ATTACH 'bi' (TYPE vgi, LOCATION 'uv run batch_index_worker.py');
+    SELECT * FROM bi.batch_indexes((SELECT * FROM range(5000))) ORDER BY batch_index;
+"""
+
+from dataclasses import dataclass
+from typing import Annotated
+
+import pyarrow as pa
+from vgi_rpc import ArrowSerializableDataclass
+
+from vgi import Arg, Worker
+from vgi.arguments import TableInput
+from vgi.catalog import Catalog, Schema
+from vgi.invocation import BindResponse
+from vgi.table_buffering_function import OutputCollector, TableBufferingFunction, TableBufferingParams
+from vgi.table_function import BindParams
+
+_RESULT = pa.schema([("batch_index", pa.int64()), ("rows", pa.int64())])
+
+# One log entry per buffered batch: the index DuckDB gave us, and the batch size.
+_NS = b"batches"
+
+
+@dataclass(slots=True, frozen=True, kw_only=True)
+class BatchIndexArgs:
+    """Arguments: the input table whose batches should be reported."""
+
+    data: Annotated[TableInput, Arg(0, doc="Input table")]
+
+
+@dataclass(kw_only=True)
+class DrainState(ArrowSerializableDataclass):
+    """Per-finalize-stream cursor: emit the report once, then finish."""
+
+    done: bool = False
+
+
+class BatchIndexes(TableBufferingFunction[BatchIndexArgs, DrainState]):
+    """Report the batch index and row count of every buffered input batch."""
+
+    class Meta:
+        """Function metadata."""
+
+        name = "batch_indexes"
+        # Ask for DuckDB's per-chunk index. Mutually exclusive with
+        # sink_order_dependent, which orders the input by serializing the sink
+        # instead of by numbering it.
+        requires_input_batch_index = True
+
+    @classmethod
+    def on_bind(cls, params: BindParams[BatchIndexArgs]) -> BindResponse:
+        """Output shape is fixed: one row per input batch."""
+        return BindResponse(output_schema=_RESULT)
+
+    @classmethod
+    def process(cls, batch: pa.RecordBatch, params: TableBufferingParams[BatchIndexArgs]) -> bytes:
+        """Sink: record this batch's index and size.
+
+        ``params.batch_index`` is populated because ``Meta`` asked for it; -1
+        stands in for the absent case so an older host that does not supply one
+        degrades to a visible marker instead of a crash.
+        """
+        index = params.batch_index if params.batch_index is not None else -1
+        payload = index.to_bytes(8, "little", signed=True) + batch.num_rows.to_bytes(8, "little")
+        params.storage.state_append(_NS, b"", payload)
+        return params.execution_id
+
+    @classmethod
+    def combine(cls, state_ids: list[bytes], params: TableBufferingParams[BatchIndexArgs]) -> list[bytes]:
+        """Nothing to reduce: the log already holds one entry per batch."""
+        return [params.execution_id]
+
+    @classmethod
+    def initial_finalize_state(
+        cls, finalize_state_id: bytes, params: TableBufferingParams[BatchIndexArgs]
+    ) -> DrainState:
+        """One cursor per finalize stream."""
+        return DrainState()
+
+    @classmethod
+    def finalize(
+        cls,
+        params: TableBufferingParams[BatchIndexArgs],
+        finalize_state_id: bytes,
+        state: DrainState,
+        out: OutputCollector,
+    ) -> None:
+        """Source: emit the report, ordered by batch index."""
+        if state.done:
+            out.finish()
+            return
+        entries = [
+            (
+                int.from_bytes(value[:8], "little", signed=True),
+                int.from_bytes(value[8:16], "little"),
+            )
+            for _id, value in params.storage.state_log_scan(_NS, b"")
+        ]
+        entries.sort()
+        out.emit(
+            pa.RecordBatch.from_pydict(
+                {
+                    "batch_index": [index for index, _rows in entries],
+                    "rows": [rows for _index, rows in entries],
+                },
+                schema=params.output_schema,
+            )
+        )
+        state.done = True
+
+
+class BatchIndexWorker(Worker):
+    """A worker exposing the ``bi`` catalog."""
+
+    catalog = Catalog(
+        name="bi",
+        schemas=[Schema(name="main", functions=[BatchIndexes])],
+    )
+
+
+if __name__ == "__main__":
+    BatchIndexWorker().run()

{vgi_python-0.27.0 → vgi_python-0.28.1}/pyproject.toml

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

{vgi_python-0.27.0 → vgi_python-0.28.1}/tests/catalog/test_column_statistics.py

@@ -12,6 +12,7 @@ from vgi_rpc.utils import deserialize_record_batch
 from vgi.catalog.catalog_interface import (
     ColumnStatistics,
     TableColumnStatisticsResult,
+    deserialize_column_statistics,
     serialize_column_statistics,
 )
 from vgi.catalog.descriptors import ColumnStatisticsInput, Table
@@ -199,6 +200,91 @@ class TestSerializeColumnStatistics:
         assert min_type.num_fields == 1
 
 
+# ============================================================================
+# deserialize_column_statistics
+# ============================================================================
+
+
+def _roundtrip(stats: list[ColumnStatistics]) -> list[ColumnStatistics]:
+    return deserialize_column_statistics(serialize_column_statistics(stats))
+
+
+class TestDeserializeColumnStatistics:
+    """Tests that deserialization is a faithful inverse of serialization."""
+
+    def test_empty_batch(self) -> None:
+        assert _roundtrip([]) == []
+
+    def test_int_column_roundtrips(self) -> None:
+        stats = [
+            ColumnStatistics(
+                column_name="id",
+                min=pa.scalar(1, pa.int64()),
+                max=pa.scalar(100, pa.int64()),
+                has_null=False,
+                has_not_null=True,
+                distinct_count=100,
+            )
+        ]
+        (got,) = _roundtrip(stats)
+        assert got.column_name == "id"
+        assert got.min.as_py() == 1  # type: ignore[union-attr]
+        assert got.max.as_py() == 100  # type: ignore[union-attr]
+        assert got.has_null is False
+        assert got.has_not_null is True
+        assert got.distinct_count == 100
+
+    def test_string_column_roundtrips_with_string_fields(self) -> None:
+        stats = [
+            ColumnStatistics(
+                column_name="name",
+                min=pa.scalar("Alice"),
+                max=pa.scalar("Zoe"),
+                contains_unicode=True,
+                max_string_length=5,
+            )
+        ]
+        (got,) = _roundtrip(stats)
+        assert got.min.as_py() == "Alice"  # type: ignore[union-attr]
+        assert got.max.as_py() == "Zoe"  # type: ignore[union-attr]
+        assert got.contains_unicode is True
+        assert got.max_string_length == 5
+
+    def test_unknown_min_max_stays_none(self) -> None:
+        """A column with no min/max must come back as None, not a null scalar."""
+        (got,) = _roundtrip([ColumnStatistics(column_name="opaque")])
+        assert got.min is None
+        assert got.max is None
+        assert got.distinct_count is None
+        assert got.contains_unicode is None
+        assert got.max_string_length is None
+
+    def test_mixed_types_keep_their_own_union_arm(self) -> None:
+        """Several column types share one sparse union; each must decode to its own type."""
+        stats = [
+            ColumnStatistics(column_name="i", min=pa.scalar(1, pa.int64()), max=pa.scalar(9, pa.int64())),
+            ColumnStatistics(column_name="s", min=pa.scalar("a"), max=pa.scalar("z")),
+            ColumnStatistics(column_name="f", min=pa.scalar(0.5, pa.float64()), max=pa.scalar(9.5, pa.float64())),
+        ]
+        got = _roundtrip(stats)
+        assert [s.column_name for s in got] == ["i", "s", "f"]
+        assert got[0].min.as_py() == 1  # type: ignore[union-attr]
+        assert got[1].min.as_py() == "a"  # type: ignore[union-attr]
+        assert got[2].max.as_py() == 9.5  # type: ignore[union-attr]
+
+    def test_order_is_preserved(self) -> None:
+        stats = [ColumnStatistics(column_name=f"c{i}", min=pa.scalar(i, pa.int64())) for i in range(6)]
+        assert [s.column_name for s in _roundtrip(stats)] == [f"c{i}" for i in range(6)]
+
+    def test_cache_ttl_rides_in_batch_metadata_not_the_stats(self) -> None:
+        """The TTL is out-of-band; deserialization returns only the statistics."""
+        data = serialize_column_statistics([ColumnStatistics(column_name="a")], cache_max_age_seconds=60)
+        _, metadata = deserialize_record_batch(data)
+        assert metadata is not None
+        assert metadata[b"cache_max_age_seconds"] == b"60"
+        assert len(deserialize_column_statistics(data)) == 1
+
+
 # ============================================================================
 # ColumnStatisticsInput
 # ============================================================================

{vgi_python-0.27.0 → vgi_python-0.28.1}/tests/client/test_broken_pipe.py

@@ -9,6 +9,8 @@ input or producing output).
 
 from __future__ import annotations
 
+import sys
+
 import pyarrow as pa
 import pytest
 
@@ -17,6 +19,16 @@ from vgi.client.catalog_mixin import CatalogClientError
 from vgi.client.client import Client, ClientError
 
 
+def _exits_with(code: int) -> list[str]:
+    """Argv for a worker that exits immediately with ``code``, reading no input.
+
+    A real process rather than the shell's ``exit`` builtin: workers are spawned
+    without a shell, so a builtin would not resolve. Returned as argv because no
+    one string quoting convention survives both POSIX and Windows.
+    """
+    return [sys.executable, "-c", f"raise SystemExit({code})"]
+
+
 def _make_test_batch() -> pa.RecordBatch:
     """Create a simple test batch for invoking functions."""
     return pa.RecordBatch.from_pydict({"x": [1, 2, 3]})
@@ -27,9 +39,9 @@ class TestClientWorkerExitHandling:
 
     def test_client_raises_error_when_worker_exits_immediately(self) -> None:
         """Client raises ClientError when worker exits before accepting input."""
-        # Use 'exit 1' which immediately terminates without reading stdin
-        # pool=None required because 'exit 1' is a shell command, not a binary
-        client = Client("exit 1", pool=None)
+        # A worker that terminates without ever reading stdin.
+        # pool=None: the pool is for real, reusable workers.
+        client = Client(_exits_with(1), pool=None)
 
         # Worker exits before sending any output - detected either via BrokenPipeError
         # or via early exit check when reading fails
@@ -48,9 +60,8 @@ class TestClientWorkerExitHandling:
 
     def test_client_raises_error_with_useful_message(self) -> None:
         """Client error message includes useful debugging information."""
-        # Use a specific exit code
-        # pool=None required because 'exit 42' is a shell command, not a binary
-        client = Client("exit 42", pool=None)
+        # Use a specific exit code so the message can be checked for it.
+        client = Client(_exits_with(42), pool=None)
 
         try:
             client.start()
@@ -84,8 +95,8 @@ class TestCatalogMixinWorkerExitHandling:
 
     def test_catalog_invoke_raises_error_when_worker_exits(self) -> None:
         """Catalog invoke raises CatalogClientError when worker exits."""
-        # Use 'exit 1' which immediately terminates without reading stdin
-        client = Client("exit 1")
+        # A worker that terminates without ever reading stdin.
+        client = Client(_exits_with(1))
 
         # Worker exits - detected either via BrokenPipeError (shows "terminated
         # unexpectedly") or via read failure (shows "Failed to read catalog result")
@@ -94,7 +105,7 @@ class TestCatalogMixinWorkerExitHandling:
 
     def test_catalog_invoke_error_includes_useful_info(self) -> None:
         """Catalog error message includes useful debugging information."""
-        client = Client("exit 42")
+        client = Client(_exits_with(42))
 
         try:
             list(client.catalogs())

vgi_python-0.28.1/tests/client/test_stop_force.py

@@ -0,0 +1,101 @@
+# Copyright 2025, 2026 Query Farm LLC - https://query.farm
+
+# ruff: noqa: S101, D102, D103
+"""Tests for ``Client.stop(force=True)``.
+
+A graceful ``stop()`` shuts the RPC connection down and waits for the worker, so it cannot
+be used to abandon a call that has overrun its budget — the wait is exactly what the caller
+is trying to escape. ``force=True`` SIGKILLs a direct subprocess worker first, which unblocks
+any thread waiting on its output immediately.
+
+Only *direct* subprocess workers own their process; pooled workers are returned to the pool
+and HTTP/TCP connections are already prompt to close, so those paths must accept ``force``
+without changing behaviour.
+"""
+
+from __future__ import annotations
+
+import sys
+import time
+from typing import Any
+
+import pyarrow as pa
+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
+
+
+def _started_client(**kwargs: Any) -> Client:
+    client = Client("vgi-fixture-worker", **kwargs)
+    client.start()
+    return client
+
+
+def test_force_kills_a_direct_subprocess(tmp_path: Any) -> None:
+    """The worker process is signalled, not asked to exit."""
+    client = _started_client(pool=None)
+    assert client._primary is not None  # noqa: SLF001 - a started client always has one
+    proc = client._primary.proc  # noqa: SLF001 - asserting the process really died
+    assert proc is not None
+    assert proc.poll() is None, "worker should be running"
+
+    returncode = client.stop(force=True)
+    assert returncode is not None
+    if sys.platform == "win32":
+        # Windows has no signals: TerminateProcess sets an ordinary non-zero code.
+        assert returncode != 0, "a killed process should not report a clean exit"
+    else:
+        assert returncode < 0, "a killed process reports a negative (signal) exit code"
+    assert proc.poll() is not None, "worker process should be reaped"
+
+
+def test_force_returns_promptly_mid_stream(tmp_path: Any) -> None:
+    """Killing while a slow scan is in flight must not wait for the scan."""
+    probe = tmp_path / "probe.txt"
+    client = _started_client(pool=None)
+    gen = client.table_function(
+        function_name="slow_cancellable",
+        schema_name="main",
+        arguments=Arguments(positional=(pa.scalar(str(probe)),), named={"sleep_ms": pa.scalar(_SLEEP_MS)}),
+    )
+    next(gen)  # worker is now mid-stream, sleeping between batches
+
+    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"
+
+
+def test_graceful_stop_is_unchanged() -> None:
+    """Force defaults to False and still reports a clean exit."""
+    client = _started_client(pool=None)
+    assert client.stop() == 0
+
+
+def test_force_is_accepted_by_pooled_workers() -> None:
+    """Pooled workers have no proc to kill, so force must be inert rather than an error."""
+    client = _started_client(pool=_default_pool)
+    assert client._primary is not None  # noqa: SLF001 - a started client always has one
+    assert client._primary.proc is None  # noqa: SLF001 - documents why force is inert here
+    assert client.stop(force=True) == 0
+
+
+def test_stop_still_requires_a_started_client() -> None:
+    client = Client("vgi-fixture-worker", pool=None)
+    with pytest.raises(Exception, match="not started"):
+        client.stop(force=True)
+
+
+def test_client_can_restart_after_a_forced_stop() -> None:
+    """Force must leave the client in the same reusable state as a graceful stop."""
+    client = _started_client(pool=None)
+    client.stop(force=True)
+    client.start()
+    try:
+        assert client._primary is not None  # noqa: SLF001 - restart sanity check
+    finally:
+        client.stop()

vgi_python-0.28.1/tests/client/test_table_column_statistics.py

@@ -0,0 +1,73 @@
+# Copyright 2025, 2026 Query Farm LLC - https://query.farm
+
+# ruff: noqa: S101, D102, D103
+"""Tests for ``Client.table_column_statistics``.
+
+Workers may inline statistics on ``TableInfo`` or serve them lazily through the per-table
+``catalog_table_column_statistics_get`` RPC. This wrapper fetches the lazy form and decodes
+it, so a client never has to reach past the public API to reimplement the sparse-union wire
+layout. Driven against the real ``vgi-fixture-worker`` over every client transport.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import pytest
+
+from vgi.catalog import ColumnStatistics, deserialize_column_statistics
+
+
+@pytest.fixture
+def attached(client_transport: Any) -> Any:
+    """Yield ``(client, attach_opaque_data)`` for the example catalog."""
+    with client_transport() as client:
+        res = client.catalog_attach(name="example", data_version_spec=None, implementation_version=None)
+        yield client, res.attach_opaque_data
+
+
+def test_returns_typed_statistics(attached: Any) -> None:
+    client, aod = attached
+    stats = client.table_column_statistics(attach_opaque_data=aod, schema_name="data", name="numbers")
+    assert stats
+    assert all(isinstance(s, ColumnStatistics) for s in stats)
+
+
+def test_decodes_min_max_for_a_known_table(attached: Any) -> None:
+    """`numbers` holds integers 0-99, so its bounds are known exactly."""
+    client, aod = attached
+    stats = client.table_column_statistics(attach_opaque_data=aod, schema_name="data", name="numbers")
+    value = next(s for s in stats if s.column_name == "value")
+    assert value.min is not None
+    assert value.max is not None
+    assert value.min.as_py() == 0
+    assert value.max.as_py() == 99
+
+
+def test_matches_the_inlined_statistics(attached: Any) -> None:
+    """The lazy RPC and the copy inlined on TableInfo must agree.
+
+    ``TableInfo.column_statistics`` arrives client-side as the raw wire bytes, so this is
+    also the case that motivates a public deserializer: without one, a caller holding an
+    inlined blob has no supported way to read it.
+    """
+    client, aod = attached
+    info = client.table_get(attach_opaque_data=aod, schema_name="data", name="numbers")
+    assert info is not None
+    if not info.column_statistics:
+        pytest.skip("worker does not inline statistics for this table")
+    fetched = client.table_column_statistics(attach_opaque_data=aod, schema_name="data", name="numbers")
+    inlined = {s.column_name: s for s in deserialize_column_statistics(info.column_statistics)}
+    assert {s.column_name for s in fetched} == set(inlined)
+    for s in fetched:
+        other = inlined[s.column_name]
+        assert (s.min is None) == (other.min is None)
+        if s.min is not None and other.min is not None:
+            assert s.min.as_py() == other.min.as_py()
+        assert s.has_null == other.has_null
+
+
+def test_unknown_table_returns_empty_list(attached: Any) -> None:
+    """A missing table yields no statistics rather than raising."""
+    client, aod = attached
+    assert client.table_column_statistics(attach_opaque_data=aod, schema_name="data", name="no_such_table") == []

{vgi_python-0.27.0 → vgi_python-0.28.1}/tests/client/test_worker_debug.py

@@ -5,6 +5,7 @@
 from __future__ import annotations
 
 import os
+import sys
 from unittest.mock import patch
 
 import pyarrow as pa
@@ -14,6 +15,16 @@ from vgi.arguments import Arguments
 from vgi.client.client import Client, ClientError
 
 
+def _stderr_worker(*lines: str) -> list[str]:
+    """Argv for a worker that writes ``lines`` to stderr and exits non-zero.
+
+    An argv list rather than a command string: the ``-c`` body carries spaces and
+    quotes, which no single quoting convention survives on both POSIX and Windows.
+    """
+    body = "import sys; " + "".join(f"sys.stderr.write({line!r} + chr(10)); " for line in lines)
+    return [sys.executable, "-c", body + "sys.stderr.flush(); sys.exit(1)"]
+
+
 class TestWorkerDebugEnvVar:
     """Tests for VGI_WORKER_DEBUG environment variable behavior."""
 
@@ -53,14 +64,7 @@ class TestStderrInErrorMessages:
 
     def test_error_includes_stderr_on_worker_failure(self) -> None:
         """Error messages should include stderr when worker fails (non-pooled)."""
-        worker_script = (
-            'python -c "'
-            "import sys; "
-            "sys.stderr.write('Debug: bind starting\\n'); "
-            "sys.stderr.write('Error: function not found\\n'); "
-            "sys.stderr.flush(); "
-            'sys.exit(1)"'
-        )
+        worker_script = _stderr_worker("Debug: bind starting", "Error: function not found")
 
         client = Client(worker_script, pool=None)
         with pytest.raises(ClientError) as exc_info:
@@ -80,7 +84,7 @@ class TestStderrInErrorMessages:
 
     def test_error_no_stderr_section_when_passthrough(self) -> None:
         """Error messages should NOT include 'Worker stderr:' when passthrough is enabled."""
-        worker_script = "python -c \"import sys; sys.stderr.write('Debug info\\n'); sys.stderr.flush(); sys.exit(1)\""
+        worker_script = _stderr_worker("Debug info")
 
         client = Client(worker_script, passthrough_stderr=True, pool=None)
         with pytest.raises(ClientError) as exc_info:
@@ -99,9 +103,7 @@ class TestStderrInErrorMessages:
 
     def test_stderr_enrichment_on_table_in_out_function(self) -> None:
         """table_in_out_function errors should include stderr."""
-        worker_script = (
-            "python -c \"import sys; sys.stderr.write('worker log line\\n'); sys.stderr.flush(); sys.exit(1)\""
-        )
+        worker_script = _stderr_worker("worker log line")
 
         batch = pa.RecordBatch.from_pydict({"x": [1, 2, 3]})
         client = Client(worker_script, pool=None)
@@ -120,7 +122,7 @@ class TestStderrInErrorMessages:
 
     def test_stderr_enrichment_on_scalar_function(self) -> None:
         """scalar_function errors should include stderr."""
-        worker_script = "python -c \"import sys; sys.stderr.write('scalar debug\\n'); sys.stderr.flush(); sys.exit(1)\""
+        worker_script = _stderr_worker("scalar debug")
 
         batch = pa.RecordBatch.from_pydict({"x": [1, 2, 3]})
         client = Client(worker_script, pool=None)

{vgi_python-0.27.0 → vgi_python-0.28.1}/tests/table_in_out/test_client.py

@@ -4,6 +4,7 @@
 
 from __future__ import annotations
 
+import sys
 import time
 
 import pyarrow as pa
@@ -249,14 +250,17 @@ class TestWorkerStderrCapture:
     def test_stderr_available_on_error(self) -> None:
         """Should be able to access stderr after an error occurs."""
         # Use a worker script that writes to stderr then fails
-        worker_script = (
-            'python -c "'
+        # Argv, not a command string: the -c body carries spaces and quotes, which
+        # no single quoting convention survives on both POSIX and Windows.
+        worker_script = [
+            sys.executable,
+            "-c",
             "import sys; "
-            "sys.stderr.write('Debug: worker starting\\n'); "
-            "sys.stderr.write('Error: something went wrong\\n'); "
+            "sys.stderr.write('Debug: worker starting' + chr(10)); "
+            "sys.stderr.write('Error: something went wrong' + chr(10)); "
             "sys.stderr.flush(); "
-            'sys.exit(1)"'
-        )
+            "sys.exit(1)",
+        ]
 
         client = Client(worker_script, pool=None)
         client.start()