vgi-python 0.17.0__tar.gz → 0.19.0__tar.gz

{vgi_python-0.17.0 → vgi_python-0.19.0}/.github/workflows/integration.yml

@@ -45,8 +45,11 @@ jobs:
       matrix:
         include:
           # stdio:  the subprocess transport (whole suite — the primary lane).
-          # shm:    stdio + the POSIX shared-memory side channel.
-          # launch: the AF_UNIX launcher-only tests.
+          # launch: the whole suite over the AF_UNIX launcher transport.
+          # shm:    launch + the POSIX shared-memory side channel. Rides the
+          #         launcher, not raw subprocess: stdio already covers the
+          #         fork-per-connection path and spends most of its wall-clock
+          #         doing it, so re-paying that cost to test shm is waste.
           # http:   the whole suite over the stateless HTTP transport.
           - { lane: stdio }
           - { lane: shm, shm_bytes: '67108864' }

{vgi_python-0.17.0 → vgi_python-0.19.0}/PKG-INFO

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

{vgi_python-0.17.0 → vgi_python-0.19.0}/ci/README.md

@@ -52,21 +52,47 @@ runs them as a matrix):
   Also boots the versioned and versioned-tables workers as background HTTP
   servers (`VGI_VERSIONED_HTTP_WORKER` / `VGI_VERSIONED_TABLES_HTTP_WORKER`) so
   the `attach/versioned_tables_*_http` and `versioning_http` tests run.
-- **`shm`** — `stdio` plus the POSIX shared-memory side channel
+- **`shm`** — the **`launch`** lane plus the POSIX shared-memory side channel
   (`VGI_RPC_SHM_SIZE_BYTES`); the whole suite. vgi-rpc-python attaches the
-  segment transparently, so the env var alone flips the transport.
-- **`launch`** — the AF_UNIX launcher transport; the launcher-only tests
-  (`launcher/*`), which the other lanes skip via `require-env`.
+  segment transparently, so the env var alone flips the side channel on.
+  This deliberately differs from the vgi Makefile's `test_shm`, which layers shm
+  on raw subprocess: `stdio` already covers the fork-per-connection path and
+  spends most of its wall-clock doing it, so paying that cost twice just to
+  exercise shm is waste. The side channel is transport-independent — negotiated
+  via the `__transport_options__` handshake and carried in POSIX shm rather than
+  in the pipe or socket — and engages identically over the launcher (verified:
+  the same 18 `[shm]` transfers under `VGI_RPC_SHM_DEBUG=1` on both).
+- **`launch`** — the AF_UNIX launcher transport; the whole suite, with *every*
+  `VGI_*_WORKER` fronted by `launch:` so traffic flows through the C++ launcher
+  (`ResolveLauncherSocketPath` → AF_UNIX → `UnixSocketWorker`). Mirrors the vgi
+  Makefile's `test_launcher`: the point is that the launcher path produces
+  identical query results to the subprocess path, which only a full-suite run
+  demonstrates. Setting `VGI_REQUIRE_LAUNCHER_TRANSPORT` additionally un-skips
+  the launcher-only tests (`launcher/*`), whose options apply solely to the
+  `launch:` dispatch path and which the other lanes skip via `require-env`.
+  The versioned / versioned-tables *http* worker vars are left unset (as in
+  `test_launcher`), so those tests skip here — stdio covers them. One deliberate
+  divergence from `test_launcher`: see `filter_echo_partitioned.test` below.
 - **`http`** — the whole suite over the stateless HTTP transport. Staging
   injects `LOAD httpfs` before each worker ATTACH (the prebuilt binary doesn't
   statically link httpfs).
 
 The `simple_writable/*.test` write-path tests (INSERT/UPDATE/DELETE/RETURNING)
-run on the subprocess lanes against `VGI_SIMPLE_WRITABLE_WORKER`
+run on **every** lane against `VGI_SIMPLE_WRITABLE_WORKER`
 (`vgi-fixture-simple-writable-worker`), in their own `haybarn-unittest`
 invocation so their warm pooled connections don't perturb the immediately
-following crash-recovery test. They self-skip on the http lane
-(skip-on-error `'HTTP'`).
+following crash-recovery test. That env var is always a spawned binary — a
+`launch:` path on the launch lane, a plain path elsewhere — so these tests run
+over subprocess even on the http lane rather than skipping.
+
+The crash / pool-recovery tests (`table_in_out/table_buffering_*`) are gated on
+`VGI_TEST_DEDICATED_WORKER`, which is set on the **`stdio` lane only**. Their
+`crash_on_process` fixture does `os.kill(getpid(), SIGKILL)`; that is a
+recoverable per-DuckDB-process child kill under subprocess transport, but under
+any shared-worker transport (`http://`, `launch:`) it kills the one process
+serving the whole suite and every later `ATTACH` fails. Because `shm` now rides
+the launcher, `stdio` is the only lane that can host them — worth knowing if you
+ever narrow the stdio lane.
 
 ### Excluded tests
 
@@ -95,8 +121,22 @@ Dropped on the **http** lane only:
   `CLAUDE.md`). `buffer_input/scale.test_slow` is a `.test_slow` file, which the
   harness never stages (it only finds `*.test`).
 
+Nothing is dropped on the **launch** lane. `test_launcher` upstream excludes two
+files, and neither applies:
+
+- `test/sql/vgi_worker_pool.test` lives outside `test/sql/integration`, so the
+  harness never stages it.
+- `table/filter_echo_partitioned.test` is excluded upstream for asserting >1
+  distinct `worker_pid`, which AF_UNIX socket pooling cannot satisfy. That
+  rationale is stale — the test now counts transport-neutral `conn=` ids instead
+  — and it passes over `launch:` against the Python fixture worker. Keeping it
+  preserves coverage of precisely what the launcher changes: connection
+  multiplexing.
+
 The HTTP-attach / bearer-auth / dynamic-code / schema-reconcile-only tests skip
 via their `require-env` gates when we don't set the corresponding worker.
+`bad_enum.test` skips on every lane — `VGI_BAD_ENUM_WORKER` is not wired up here
+even though the fixture (`vgi-fixture-bad-enum-worker`) is installed.
 
 ## Run it locally
 

{vgi_python-0.17.0 → vgi_python-0.19.0}/ci/run-integration.sh

@@ -16,8 +16,11 @@
 #   * No worker coverage (unlike vgi-go's GOCOVERDIR) — pass/fail only.
 #
 # This mirrors the env wiring of the vgi repo's Makefile `test_subprocess` /
-# `test_shm` / `test_launcher` / `test_http` targets (the canonical local way to
-# run this suite against the Python worker — see vgi-python/CLAUDE.md).
+# `test_launcher` / `test_http` targets (the canonical local way to run this
+# suite against the Python worker — see vgi-python/CLAUDE.md). The `shm` lane
+# deliberately differs from Makefile `test_shm`: it layers the shm side channel
+# on the LAUNCHER rather than on raw subprocess, to avoid re-forking a Python
+# worker per connection. See the shm|launch case below.
 #
 # Required environment:
 #   VGI_SRC           path to a Query-farm/vgi checkout (contains test/sql/integration)
@@ -59,6 +62,16 @@ done
 # ---------------------------------------------------------------------------
 AWK_HTTP=0
 EXTRA_SKIP=()
+# Nothing is dropped on the launch lane. The vgi Makefile's test_launcher
+# excludes two files, and neither applies here:
+#   * test/sql/vgi_worker_pool.test — outside test/sql/integration, so it is
+#     never staged by the find below.
+#   * table/filter_echo_partitioned.test — excluded upstream for asserting >1
+#     distinct worker_pid, which AF_UNIX socket pooling can't satisfy. That
+#     rationale is stale: the test now counts transport-neutral `conn=` ids
+#     instead (see its own comment), and it passes over launch: against the
+#     Python fixture worker. Keeping it preserves coverage of exactly what the
+#     launcher changes — connection multiplexing.
 if [ "$TRANSPORT" = "http" ]; then
   AWK_HTTP=1
   # Dropped on the http lane only:
@@ -120,20 +133,38 @@ export VGI_SYNC_INIT_GLOBAL=1
 SCHEMA_RECONCILE_DIR="$(mktemp -d)"
 export VGI_SCHEMA_RECONCILE_DB="$SCHEMA_RECONCILE_DIR/vgi_schema_reconcile.sqlite"
 
-# Presence gate for the crash / pool-recovery tests
-# (table_in_out/table_buffering_*). The value is not used as a worker spec —
-# the SQL attaches the normal pooled worker; this just un-skips the tests.
-export VGI_TEST_DEDICATED_WORKER=1
-
 # Background workers (http servers) are tracked in a file and SIGTERMed on exit.
+# Each line is "<pid>\t<logfile>".
 BG_PIDS_FILE="$(mktemp)"
 # shellcheck disable=SC2329  # invoked indirectly via `trap cleanup EXIT` below
 cleanup() {
   [ -f "$BG_PIDS_FILE" ] || return 0
-  while read -r p; do [ -n "$p" ] && kill "$p" 2>/dev/null || true; done < "$BG_PIDS_FILE"
+  while IFS="$(printf '\t')" read -r p _; do
+    [ -n "$p" ] && kill "$p" 2>/dev/null || true
+  done < "$BG_PIDS_FILE"
 }
 trap cleanup EXIT
 
+# assert_bg_workers_alive — fail if any background http worker died during a
+# run, dumping its log. A dead shared worker is otherwise near-invisible: the
+# runner's default error handling turns the resulting cascade of failed ATTACHes
+# into skips, so the lane still prints "All tests passed" having tested nothing
+# past the point of death (the failure mode that hid 136 voided files in run
+# 29979884253). Cheap insurance against a green-but-empty lane.
+assert_bg_workers_alive() {
+  local rc=0 p log
+  [ -s "$BG_PIDS_FILE" ] || return 0
+  while IFS="$(printf '\t')" read -r p log; do
+    [ -n "$p" ] || continue
+    kill -0 "$p" 2>/dev/null && continue
+    echo "::error::background http worker (pid $p) died during the run — everything" \
+         "attached to it after that point was not really tested. Its log follows."
+    [ -n "$log" ] && [ -f "$log" ] && sed -n '1,200p' "$log"
+    rc=1
+  done < "$BG_PIDS_FILE"
+  return "$rc"
+}
+
 # boot_http_worker <binary> — start it as an HTTP server on an ephemeral port and
 # set BOOTED_PORT to the port it reports (PORT:<n>, the worker's readiness
 # contract). Sets a global rather than echoing so the backgrounded worker stays a
@@ -156,7 +187,7 @@ boot_http_worker() {
   log="$(mktemp)"
   ( cd "$STAGE" && exec "$exe" --http --port 0 ) >"$log" 2>&1 &
   pid=$!
-  echo "$pid" >> "$BG_PIDS_FILE"
+  printf '%s\t%s\n' "$pid" "$log" >> "$BG_PIDS_FILE"
   for _ in $(seq 1 60); do
     kill -0 "$pid" 2>/dev/null || { echo "::error::http worker '$exe' exited" >&2; cat "$log" >&2; return 1; }
     port="$(sed -n 's/.*PORT:\([0-9]*\).*/\1/p' "$log" | head -1)"
@@ -167,20 +198,45 @@ boot_http_worker() {
   BOOTED_PORT="$port"
 }
 
+# On the launcher-family lanes EVERY worker is fronted by `launch:` so the C++
+# launcher serves it (ResolveLauncherSocketPath -> AF_UNIX -> UnixSocketWorker),
+# as the vgi Makefile's test_launcher does. A worker left unprefixed would
+# silently run over stdio inside a launcher lane. Empty on stdio and http.
+LAUNCH_PREFIX=""
+case "$TRANSPORT" in shm|launch) LAUNCH_PREFIX="launch:" ;; esac
+
 # version_mismatch.test attaches a worker that advertises an incompatible
 # protocol_version; set on the subprocess lanes (skips elsewhere via require-env).
-export VGI_BAD_PROTOCOL_WORKER="$BAD_PROTOCOL"
+export VGI_BAD_PROTOCOL_WORKER="${LAUNCH_PREFIX}${BAD_PROTOCOL}"
 
 # The simple_writable fixture worker un-skips the cross-language
-# simple_writable/*.test write-path tests. Set on every lane; they self-skip
-# over http (skip-on-error 'HTTP').
-export VGI_SIMPLE_WRITABLE_WORKER="$SIMPLE_WRITABLE"
+# simple_writable/*.test write-path tests. Set on every lane — on the http lane
+# it stays a binary path, so those tests run over subprocess there (they do NOT
+# self-skip: the http lane passes all 5 files).
+export VGI_SIMPLE_WRITABLE_WORKER="${LAUNCH_PREFIX}${SIMPLE_WRITABLE}"
 
 case "$TRANSPORT" in
-  stdio|shm)
-    # Subprocess transport (the primary lane). shm is identical plus the POSIX
-    # shared-memory side channel via VGI_RPC_SHM_SIZE_BYTES.
+  stdio)
+    # Subprocess transport (the primary lane) — the only lane that spawns a
+    # fresh worker process per DuckDB connection, and so the only one that can
+    # host the crash / pool-recovery tests below.
     export VGI_TEST_WORKER="$WORKER"
+    # Presence gate for the crash / pool-recovery tests
+    # (table_in_out/table_buffering_{worker_crash,pool_recovery}). The value is
+    # not a worker spec — the SQL attaches the normal pooled worker; this just
+    # un-skips the tests.
+    #
+    # DEDICATED (subprocess) LANE ONLY. Those tests call the `crash_on_process`
+    # fixture, which does os.kill(getpid(), SIGKILL). Under subprocess transport
+    # that kills the per-DuckDB-process worker child and the pool recovers —
+    # exactly what the tests assert. Under a SHARED-worker transport (http://,
+    # unix://, launch:) it kills the single process serving the whole suite, and
+    # every later ATTACH fails. Exporting it unconditionally silently voided 136
+    # of 286 files on the http lane while still printing "All tests passed"
+    # (run 29979884253) — the crash landed at file 132 and the runner's default
+    # error handling swallowed the cascade. Since shm now runs over the launcher
+    # (a shared worker), stdio is the ONLY lane that may set this.
+    export VGI_TEST_DEDICATED_WORKER=1
     export VGI_VERSIONED_WORKER="$VERSIONED"
     export VGI_VERSIONED_TABLES_WORKER="$VERSIONED_TABLES"
     export VGI_ATTACH_OPTIONS_WORKER="$ATTACH_OPTIONS"
@@ -192,12 +248,33 @@ case "$TRANSPORT" in
     export VGI_VERSIONED_HTTP_WORKER="http://localhost:${vh_port}"
     SUITE_GLOB="test/sql/integration/*"
     ;;
-  launch)
-    # AF_UNIX launcher transport. Only the launcher-only tests opt in here
-    # (the rest of the suite runs on the stdio lane); mirrors make test-launcher.
+  shm|launch)
+    # AF_UNIX launcher transport — the WHOLE suite with every worker fronted by
+    # `launch:`, mirroring the vgi Makefile's test_launcher. Validates that the
+    # launcher path produces identical query results to the subprocess path;
+    # running only launcher/* here would leave the transport almost untested.
+    # VGI_REQUIRE_LAUNCHER_TRANSPORT additionally un-skips launcher/*, whose
+    # options only apply to the launch: dispatch path (the other lanes skip them).
+    #
+    # `shm` is this same lane plus the POSIX shared-memory side channel
+    # (VGI_RPC_SHM_SIZE_BYTES, exported by the workflow). It rides the launcher
+    # rather than raw subprocess because stdio spends most of its wall-clock
+    # fork+exec'ing a fresh Python worker per connection; the launcher keeps one
+    # warm worker per argv and reuses it, so the lane exercises the same shm
+    # paths far faster. The side channel is transport-independent — it is
+    # negotiated via the __transport_options__ handshake and carried in POSIX
+    # shm, not in the pipe/socket — and engages identically here (verified: the
+    # same 18 [shm] transfers under VGI_RPC_SHM_DEBUG on stdio and on launch).
+    #
+    # The versioned / versioned_tables *http* worker env vars are deliberately
+    # left UNSET (as in test_launcher), so attach/versioned_tables_*_http and
+    # versioning_http skip — they're covered over http on the stdio lane.
     export VGI_TEST_WORKER="launch:${WORKER}"
+    export VGI_VERSIONED_WORKER="launch:${VERSIONED}"
+    export VGI_VERSIONED_TABLES_WORKER="launch:${VERSIONED_TABLES}"
+    export VGI_ATTACH_OPTIONS_WORKER="launch:${ATTACH_OPTIONS}"
     export VGI_REQUIRE_LAUNCHER_TRANSPORT=1
-    SUITE_GLOB="test/sql/integration/launcher/*"
+    SUITE_GLOB="test/sql/integration/*"
     ;;
   http)
     # Whole-suite-over-HTTP (mirrors make test_http). Every ATTACH goes over
@@ -253,8 +330,8 @@ rm -f "$STAGE/test/_warm.test"
 # pool). Its table-in-out write workers otherwise leave warm pooled connections
 # that perturb the immediately-following crash-recovery test
 # (table_in_out/table_buffering_pool_recovery). A separate process gives the
-# crash test a clean pool. The launcher lane runs only launcher/* (no
-# simple_writable); the http lane's writes self-skip.
+# crash test a clean pool. Every lane does the split: simple_writable always
+# attaches a spawned binary (VGI_SIMPLE_WRITABLE_WORKER), even on the http lane.
 echo "Running suite ($SUITE_GLOB, transport=$TRANSPORT) ..."
 suite_rc=0
 
@@ -288,12 +365,11 @@ run_unittest() {
   return "$rc"
 }
 
-if [ "$TRANSPORT" = "launch" ]; then
-  run_unittest "$SUITE_GLOB" || suite_rc=$?
-else
-  run_unittest "$SUITE_GLOB" "~test/sql/integration/simple_writable/*" || suite_rc=$?
-  echo "Running simple_writable (isolated process) ..."
-  run_unittest "test/sql/integration/simple_writable/*" || suite_rc=$?
-fi
+run_unittest "$SUITE_GLOB" "~test/sql/integration/simple_writable/*" || suite_rc=$?
+assert_bg_workers_alive || suite_rc=1
+
+echo "Running simple_writable (isolated process) ..."
+run_unittest "test/sql/integration/simple_writable/*" || suite_rc=$?
+assert_bg_workers_alive || suite_rc=1
 
 exit "$suite_rc"

{vgi_python-0.17.0 → vgi_python-0.19.0}/docs/catalog-interface.md

@@ -307,6 +307,52 @@ class MyReadOnlyCatalog(ReadOnlyCatalogInterface):
 
 ---
 
+## Function Name Scoping
+
+A function name is **not** a global key. The worker resolves a call by the pair
+`(schema, function name)`, so the same name may be declared in more than one
+schema of a catalog, and a schema-qualified call reaches the implementation in
+that schema:
+
+```python test="lint"
+Catalog(
+    name="example",
+    default_schema="main",
+    schemas=[
+        Schema(name="main", functions=[ProdLookup]),   # Meta.name = "lookup"
+        Schema(name="staging", functions=[StagingLookup]),  # Meta.name = "lookup"
+    ],
+)
+```
+
+```sql
+SELECT example.main.lookup(1);     -- ProdLookup
+SELECT example.staging.lookup(1);  -- StagingLookup
+```
+
+The DuckDB extension carries the owning schema on every bind request
+(`BindRequest.schema_name`), taken from the schema entry the function was
+registered into. Two consequences worth knowing:
+
+- **Overloads still work.** Several classes sharing a name *within one schema*
+  are overloads, disambiguated by argument signature as before. Only the
+  cross-schema case is resolved by schema.
+- **Callers without a schema must be unambiguous.** The pure-Python `Client`
+  and the CLI send no schema. If the name is unique across the worker they
+  resolve normally; if two schemas declare it, the worker raises an ambiguity
+  error naming the schemas involved.
+
+Functions declared via the legacy `Worker.functions` list have no schema of
+their own, so they are registered into the catalog's `default_schema` — the
+same schema DuckDB registers them into.
+
+Across **catalogs**, the key is the attachment rather than the name: two
+catalogs served by one worker process (see `vgi.meta_worker.MetaWorker`) may
+each declare `main.lookup`, and each attachment's `attach_opaque_data` routes
+its calls to the right catalog.
+
+---
+
 ## Declarative Catalogs
 
 For most use cases, the declarative catalog API provides a simpler way to define catalogs using Python dataclasses instead of implementing `CatalogInterface` directly.
@@ -483,13 +529,19 @@ class MyWorker(Worker):
 
 To disable the catalog interface entirely:
 
-```python
+```python test="lint"
 class MyWorker(Worker):
     catalog_interface = None
     catalog_name = None  # Required to fully disable
     functions = [...]
 ```
 
+A catalog-less worker is reachable only from the pure-Python [`Client`][], which
+binds by `(schema, function name)` and needs no attachment — its functions
+register into the default `main` schema. It is **not** reachable from DuckDB:
+`ATTACH ... (TYPE vgi)` requires a catalog, and there is no standalone
+call form. If the worker should be usable from SQL, give it a catalog.
+
 ---
 
 ## Client Usage

{vgi_python-0.17.0 → vgi_python-0.19.0}/pyproject.toml

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

{vgi_python-0.17.0 → vgi_python-0.19.0}/tests/client/test_broken_pipe.py

@@ -40,6 +40,7 @@ class TestClientWorkerExitHandling:
             list(
                 client.table_in_out_function(
                     function_name="test",
+                    schema_name="main",
                     arguments=Arguments(),
                     input=iter([_make_test_batch()]),
                 )
@@ -56,6 +57,7 @@ class TestClientWorkerExitHandling:
             list(
                 client.table_in_out_function(
                     function_name="test",
+                    schema_name="main",
                     arguments=Arguments(),
                     input=iter([_make_test_batch()]),
                 )

{vgi_python-0.17.0 → vgi_python-0.19.0}/tests/client/test_worker_debug.py

@@ -68,6 +68,7 @@ class TestStderrInErrorMessages:
             list(
                 client.table_function(
                     function_name="nonexistent",
+                    schema_name="main",
                     arguments=Arguments(),
                 )
             )
@@ -87,6 +88,7 @@ class TestStderrInErrorMessages:
             list(
                 client.table_function(
                     function_name="nonexistent",
+                    schema_name="main",
                     arguments=Arguments(),
                 )
             )
@@ -108,6 +110,7 @@ class TestStderrInErrorMessages:
             list(
                 client.table_in_out_function(
                     function_name="nonexistent",
+                    schema_name="main",
                     input=iter([batch]),
                 )
             )
@@ -126,6 +129,7 @@ class TestStderrInErrorMessages:
             list(
                 client.scalar_function(
                     function_name="nonexistent",
+                    schema_name="main",
                     input=iter([batch]),
                 )
             )

{vgi_python-0.17.0 → vgi_python-0.19.0}/tests/conformance/test_function_inventory.py

@@ -178,6 +178,7 @@ def test_scalar_function_end_to_end(attached_example: tuple[str, bytes]) -> None
         out_batches = list(
             client.scalar_function(
                 function_name="double",
+                schema_name="main",
                 arguments=Arguments(positional=(pa.scalar("x"),)),
                 input=iter([input_batch]),
             )
@@ -199,6 +200,7 @@ def test_table_function_end_to_end(attached_example: tuple[str, bytes]) -> None:
         out_batches = list(
             client.table_function(
                 function_name="sequence",
+                schema_name="main",
                 arguments=Arguments(positional=(pa.scalar(5),)),
             )
         )

{vgi_python-0.17.0 → vgi_python-0.19.0}/tests/conformance/test_http_client.py

@@ -102,6 +102,7 @@ def test_scalar_function_over_http(http_example_base_url: str) -> None:
         out = list(
             client.scalar_function(
                 function_name="double",
+                schema_name="main",
                 arguments=Arguments(positional=(pa.scalar("x"),)),
                 input=iter([batch]),
             )
@@ -119,6 +120,7 @@ def test_table_function_over_http(http_example_base_url: str) -> None:
         out = list(
             client.table_function(
                 function_name="sequence",
+                schema_name="main",
                 arguments=Arguments(positional=(pa.scalar(5),)),
             )
         )

{vgi_python-0.17.0 → vgi_python-0.19.0}/tests/conformance/test_http_external_location.py

@@ -83,6 +83,7 @@ def test_pointer_batch_auto_resolved(demo_storage_base_url: str) -> None:
         out = list(
             client.scalar_function(
                 function_name="random_bytes",
+                schema_name="main",
                 arguments=Arguments(positional=(pa.scalar(seed), pa.scalar(payload_bytes))),
                 input=iter([input_batch]),
             )
@@ -116,6 +117,7 @@ def test_http_client_uses_default_external_config(demo_storage_base_url: str) ->
         list(
             client.scalar_function(
                 function_name="random_bytes",
+                schema_name="main",
                 arguments=Arguments(positional=(pa.scalar(0), pa.scalar(payload_bytes))),
                 input=iter([input_batch]),
             )

{vgi_python-0.17.0 → vgi_python-0.19.0}/tests/conformance/test_http_upload_url.py

@@ -85,6 +85,7 @@ def test_oversize_input_auto_externalized(small_request_limit_base_url: str) ->
         out = list(
             client.scalar_function(
                 function_name="double",
+                schema_name="main",
                 arguments=Arguments(positional=(pa.scalar("x"),)),
                 input=iter([input_batch]),
             )
@@ -115,6 +116,7 @@ def test_small_input_not_externalized(small_request_limit_base_url: str) -> None
         out = list(
             client.scalar_function(
                 function_name="double",
+                schema_name="main",
                 arguments=Arguments(positional=(pa.scalar("x"),)),
                 input=iter([input_batch]),
             )

{vgi_python-0.17.0 → vgi_python-0.19.0}/tests/conformance/test_protocol_version.py

@@ -32,18 +32,19 @@ CLIENT_PROTOCOL_VERSION = VgiProtocol.protocol_version
 
 def test_client_protocol_version_is_canonical() -> None:
     """Sanity-check the constants this test reasons about haven't drifted apart."""
-    assert CLIENT_PROTOCOL_VERSION == "1.0.0"
+    assert CLIENT_PROTOCOL_VERSION == "1.1.0"
     # The fixture must be a genuine mismatch in the major/minor that the
     # framework compares; a patch-only difference would (correctly) pass.
     assert BAD_PROTOCOL_VERSION.split(".")[:2] != CLIENT_PROTOCOL_VERSION.split(".")[:2]
 
 
 def test_mismatched_worker_protocol_version_raises() -> None:
-    """A worker enforcing 99.0.0 must reject the 1.0.0 client at dispatch."""
+    """A worker enforcing 99.0.0 must reject the 1.1.0 client at dispatch."""
     with Client("vgi-fixture-bad-protocol-worker") as client, pytest.raises(ClientError) as exc_info:
         list(
             client.table_function(
                 function_name="sequence",
+                schema_name="main",
                 arguments=Arguments(positional=(pa.scalar(5),)),
             )
         )
@@ -53,5 +54,5 @@ def test_mismatched_worker_protocol_version_raises() -> None:
     assert "protocol_version mismatch" in message
     assert CLIENT_PROTOCOL_VERSION in message
     assert BAD_PROTOCOL_VERSION in message
-    # Directional hint: the client (1.0.0) is older than the worker (99.0.0).
+    # Directional hint: the client (1.1.0) is older than the worker (99.0.0).
     assert "upgrade the VGI extension/client" in message

{vgi_python-0.17.0 → vgi_python-0.19.0}/tests/conformance/test_resumable_scan.py

@@ -50,7 +50,7 @@ def _reference_rows(base_url: str) -> list[int]:
     with Client.from_http(base_url) as client:
         return [
             v
-            for b in client.table_function(function_name="sequence", arguments=_ARGS)
+            for b in client.table_function(function_name="sequence", schema_name="main", arguments=_ARGS)
             for v in b.column("n").to_pylist()
         ]
 
@@ -62,7 +62,7 @@ def test_resumable_scan_matches_table_function(http_base_url: str) -> None:
 
     rows: list[int] = []
     with Client.from_http(http_base_url) as client:
-        cur = client.table_scan_resumable(function_name="sequence", arguments=_ARGS)
+        cur = client.table_scan_resumable(function_name="sequence", schema_name="main", arguments=_ARGS)
         while True:
             batch, _token = cur.next()
             if batch is None:
@@ -81,7 +81,7 @@ def test_resume_on_fresh_client_after_node_hop(http_base_url: str) -> None:
     token: bytes | None = None
     # Read the first few batches, then abandon the connection (as if the LB node died).
     with Client.from_http(http_base_url) as client:
-        cur = client.table_scan_resumable(function_name="sequence", arguments=_ARGS)
+        cur = client.table_scan_resumable(function_name="sequence", schema_name="main", arguments=_ARGS)
         for _ in range(3):
             batch, token = cur.next()
             assert batch is not None
@@ -91,7 +91,9 @@ def test_resume_on_fresh_client_after_node_hop(http_base_url: str) -> None:
 
     # A brand-new client resumes from the serialized token alone.
     with Client.from_http(http_base_url) as client2:
-        cur2 = client2.table_scan_resumable(function_name="sequence", arguments=_ARGS, resume_token=token)
+        cur2 = client2.table_scan_resumable(
+            function_name="sequence", schema_name="main", arguments=_ARGS, resume_token=token
+        )
         while True:
             batch, token = cur2.next()
             if batch is None:
@@ -116,7 +118,7 @@ def test_continue_on_fresh_client_skips_rebind(http_base_url: str) -> None:
     rows: list[int] = []
     token: bytes | None = None
     with Client.from_http(http_base_url) as client:
-        cur = client.table_scan_resumable(function_name="sequence", arguments=_ARGS)
+        cur = client.table_scan_resumable(function_name="sequence", schema_name="main", arguments=_ARGS)
         for _ in range(3):
             batch, token = cur.next()
             assert batch is not None
@@ -153,4 +155,4 @@ def test_resumable_scan_rejected_on_subprocess() -> None:
     client = Client("/nonexistent/worker")  # subprocess transport, never started
     assert client.supports_resumable_scan is False
     with pytest.raises(ResumeUnsupported):
-        client.table_scan_resumable(function_name="sequence", arguments=_ARGS)
+        client.table_scan_resumable(function_name="sequence", schema_name="main", arguments=_ARGS)

{vgi_python-0.17.0 → vgi_python-0.19.0}/tests/conformance/test_scalar.py

@@ -23,6 +23,9 @@ skip_area(
         "hash_seed.test",
         "null_handling.test",
         "random_int.test",
+        # Covered on the Python side by tests/test_schema_scoped_functions.py.
+        "same_name_catalogs.test",
+        "same_name_schemas.test",
         "sum_values.test",
         "unnest_tensor.test",
         "upper_case.test",