vgi-python 0.34.0__py3-none-any.whl → 0.35.0__py3-none-any.whl

vgi/_test_fixtures/table_in_out.py

@@ -138,9 +138,9 @@ class SubstreamPartialSumFunction(TableInOutFunction[SingleTableArguments, Subst
     their finalize outputs, so the caller re-aggregates with an outer
     ``SELECT sum(...)`` to get the global total — correct no matter how the rows
     were partitioned across substreams. Each substream's ``finish()`` reads only
-    its OWN worker's accumulated state (keyed by the substream's execution_id;
-    ``params.substream_id`` is the stable client-owned key available for workers
-    that manage cross-backend state themselves). This is the per-substream
+    its OWN execution's accumulated state — the framework keeps one row per
+    ``params.substream_id`` in storage scoped to that execution, so it is found
+    even when a finalize lands on a different backend. This is the per-substream
     finalize contract A4 enables — it is NOT a global cross-substream combine
     (that is a ``TableBufferingFunction``; see ``SumAllColumnsSimpleDistributed``).
 
@@ -191,8 +191,9 @@ class SubstreamPartialSumFunction(TableInOutFunction[SingleTableArguments, Subst
         params: ProcessParams[SingleTableArguments],
         states: list[SubstreamPartialSumState],
     ) -> list[pa.RecordBatch]:
-        # `states` are THIS substream's accumulated states (one per worker pid that
-        # handled this substream's batches); their sum is this substream's partial.
+        # `states` are this execution's accumulated states, one per substream that
+        # saw input (the Python client fans one execution across several); their
+        # sum is this finalize's partial.
         total = sum(st.total for st in states)
         name = params.output_schema.names[0]
         return [pa.RecordBatch.from_pydict({name: [total]}, schema=params.output_schema)]

vgi/client/client.py

@@ -78,7 +78,9 @@ import io
 import itertools
 import logging
 import os
+import shlex
 import subprocess
+import sys
 import threading
 from collections.abc import Callable, Generator, Iterator, Sequence
 from contextlib import AbstractContextManager
@@ -182,7 +184,25 @@ _default_pool = WorkerPool(max_idle=8, idle_timeout=30.0)
 # whether to skip the HTTP leg of the matrix.
 _HTTP_TRANSPORT_READY = True
 
+# ``server_path`` prefix selecting ``transport="launch"`` — the same scheme as
+# the VGI DuckDB extension's ``launch:<argv>`` LOCATION.
+_LAUNCH_SCHEME = "launch:"
+
 _DEFAULT_ACCEPTED_MAX_RESPONSE_BYTES = 256 * 1024 * 1024
+
+
+def _substream_id_for(phase: TableInOutFunctionInitPhase | None) -> bytes | None:
+    """Mint the ``InitRequest.substream_id`` for a connection's table-in-out INPUT stream.
+
+    Each connection a table-in-out call fans out to is its own substream of the
+    one execution — the worker keeps one accumulated state per substream, and
+    the single finalize drains them all. Sharing an id (or sending none, which
+    the worker keys by process) lets connections served by one process
+    overwrite each other's state. ``None`` for every other kind of init.
+    """
+    return os.urandom(16) if phase == TableInOutFunctionInitPhase.INPUT else None
+
+
 _MIN_ACCEPTED_MAX_RESPONSE_BYTES = 65536
 _MAX_SAFE_HTTP_BYTES = (1 << 53) - 1
 
@@ -215,6 +235,8 @@ class WorkerConnection:
         stream: The active streaming session, if any.
         proc: The worker subprocess for direct (non-pooled) subprocess transport.
         connection: The RPC connection for direct subprocess transport.
+        substream_id: The ``InitRequest.substream_id`` this connection's
+            table-in-out stream was opened with, or None.
     """
 
     proxy: VgiProtocol
@@ -223,6 +245,7 @@ class WorkerConnection:
     # Subprocess transport, direct (non-pooled).
     proc: subprocess.Popen[bytes] | None = None
     connection: RpcConnection[VgiProtocol] | None = None
+    substream_id: bytes | None = None
     # Subprocess transport, pooled.
     _pool_ctx: AbstractContextManager[Any] | None = field(default=None, repr=False)
     # HTTP transport: context manager from vgi_rpc.http.http_connect.
@@ -486,6 +509,11 @@ class Client(CatalogClientMixin, AggregateClientMixin):
                 spaces or quotes (``[sys.executable, "-c", script]``). No shell
                 is involved either way, so shell syntax — pipes, redirection,
                 ``VAR=value`` prefixes, ``~`` expansion — is not interpreted.
+                A string of the form ``launch:<argv>`` selects
+                ``transport="launch"`` instead, with ``<argv>`` split the same
+                way into ``launch_argv`` — the VGI DuckDB extension's
+                ``launch:`` LOCATION scheme, so one worker string names the
+                same shared worker in both. ``pool`` does not apply to it.
             passthrough_stderr: Subprocess-only. If True, worker stderr is
                 passed through to the parent process's stderr in real-time.
             worker_limit: Maximum number of parallel worker processes.
@@ -584,6 +612,14 @@ class Client(CatalogClientMixin, AggregateClientMixin):
                 combination is inconsistent.
 
         """
+        if transport == "subprocess" and isinstance(server_path, str) and server_path.startswith(_LAUNCH_SCHEME):
+            if launch_argv is not None:
+                raise ValueError("pass the worker command as a 'launch:' server_path or as launch_argv, not both")
+            launch_argv = shlex.split(server_path[len(_LAUNCH_SCHEME) :], posix=sys.platform != "win32")
+            server_path = None
+            pool = None
+            transport = "launch"
+
         if transport == "subprocess":
             if server_path is None:
                 raise ValueError("subprocess transport requires server_path")
@@ -1618,6 +1654,7 @@ class Client(CatalogClientMixin, AggregateClientMixin):
         finalize_state_id: bytes | None = None,
         split_tokens: list[bytes] | None = None,
         join_keys: list[pa.RecordBatch] | None = None,
+        substream_id: bytes | None = None,
     ) -> StreamSession:
         """Call init on a worker proxy and return a `StreamSession`.
 
@@ -1642,6 +1679,8 @@ class Client(CatalogClientMixin, AggregateClientMixin):
                 looked up by column name — see
                 ``PushdownFilters.get_join_keys_column``), or `None` when not
                 applicable.
+            substream_id: The table-in-out substream this init opens or
+                finalizes (see ``_substream_id_for``), or `None`.
 
         Returns:
             `StreamSession` for data exchange or production.
@@ -1662,6 +1701,7 @@ class Client(CatalogClientMixin, AggregateClientMixin):
             init_opaque_data=init_opaque_data,
             finalize_state_id=finalize_state_id,
             split_tokens=split_tokens,
+            substream_id=substream_id,
         )
         try:
             stream: StreamSession = proxy.init(request=init_request)  # type: ignore[assignment]
@@ -1750,6 +1790,7 @@ class Client(CatalogClientMixin, AggregateClientMixin):
         )
         bind_response = self._do_bind(self._primary.proxy, bind_request, bind_result_callback)
 
+        substream_id = _substream_id_for(phase)
         stream = self._do_init(
             self._primary.proxy,
             bind_request,
@@ -1761,8 +1802,10 @@ class Client(CatalogClientMixin, AggregateClientMixin):
             execution_id=split_execution_id,
             init_opaque_data=split_init_opaque_data,
             join_keys=join_keys,
+            substream_id=substream_id,
         )
         self._primary.stream = stream
+        self._primary.substream_id = substream_id
 
         init_response = stream.typed_header(GlobalInitResponse)
         max_workers = 1 if split_tokens is not None else self._determine_max_workers(init_response.max_workers)
@@ -1838,6 +1881,7 @@ class Client(CatalogClientMixin, AggregateClientMixin):
 
         def do_init(worker: WorkerConnection) -> None:
             try:
+                worker.substream_id = _substream_id_for(phase)
                 stream = self._do_init(
                     worker.proxy,
                     bind_request,
@@ -1848,6 +1892,7 @@ class Client(CatalogClientMixin, AggregateClientMixin):
                     join_keys=join_keys,
                     execution_id=global_init_response.execution_id,
                     init_opaque_data=global_init_response.opaque_data,
+                    substream_id=worker.substream_id,
                 )
                 worker.stream = stream
             except Exception as e:
@@ -2629,6 +2674,7 @@ class Client(CatalogClientMixin, AggregateClientMixin):
             phase=TableInOutFunctionInitPhase.FINALIZE,
             execution_id=init_response.execution_id,
             init_opaque_data=init_response.opaque_data,
+            substream_id=self._primary.substream_id,
         )
 
         try:

vgi/function.py

@@ -21,6 +21,7 @@ from __future__ import annotations
 
 import logging
 import os
+import threading
 from abc import ABC
 from typing import (
     Annotated,
@@ -73,19 +74,32 @@ def _resolve_storage() -> FunctionStorage:
 
 
 class _DefaultStorageDescriptor:
-    """Resolve `FunctionStorage` lazily on first attribute access.
+    """Resolve `FunctionStorage` lazily on first attribute access — exactly once.
 
     This avoids evaluating environment variables at import time. When a
     subclass explicitly sets ``storage = SomeStorage(...)``, the plain
     attribute shadows this descriptor — no interference.
+
+    Resolution is locked because first use is a *request* now, and requests
+    arrive concurrently. Until 0.34.1 the store was resolved as a side effect of
+    ``import vgi``, single-threaded; once that was made lazy, an unguarded
+    check-then-set let two first callers each build a store — and with the
+    ``:memory:`` backend that is two unrelated databases, so state one thread
+    wrote was invisible to the other. Double-checked, so every later access
+    stays lock-free.
     """
 
     _resolved: FunctionStorage | None = None
+    _lock = threading.Lock()
 
     def __get__(self, obj: object | None, objtype: type | None = None) -> FunctionStorage:
-        if self._resolved is None:
-            self._resolved = _resolve_storage()
-        return self._resolved
+        resolved = self._resolved
+        if resolved is None:
+            with self._lock:
+                if self._resolved is None:
+                    self._resolved = _resolve_storage()
+                resolved = self._resolved
+        return resolved
 
 
 # Default max_workers when not explicitly specified (effectively unlimited)

vgi/function_storage.py

@@ -20,6 +20,7 @@ Implementations:
 import contextlib
 import enum
 import functools
+import inspect
 import logging
 import os
 import sqlite3
@@ -944,9 +945,9 @@ class FunctionStorageSqlite:
             self._memory_uri = None
             self._anchor_conn = None
             self.db_path = db_path if db_path is not None else _get_default_db_path()
-        # Shared-cache in-memory DBs need a process-local write lock; file DBs
-        # do not. See `_write_guard`.
-        self._write_lock: threading.Lock | None = threading.Lock() if self._memory_uri is not None else None
+        # Shared-cache in-memory DBs need a process-local lock around every
+        # operation; file DBs do not. See `_op_guard`.
+        self._op_lock: threading.Lock | None = threading.Lock() if self._memory_uri is not None else None
         self._tls = threading.local()
         self._ensure_tables()
 
@@ -986,8 +987,8 @@ class FunctionStorageSqlite:
         return conn
 
     @contextlib.contextmanager
-    def _write_guard(self) -> Iterator[None]:
-        """Serialize writers on a shared-cache in-memory DB; no-op for a file DB.
+    def _op_guard(self) -> Iterator[None]:
+        """Serialize every operation on a shared-cache in-memory DB; no-op for a file DB.
 
         `_conn` gives each thread its own connection so SQLite's own locking
         serializes writers "without a Python-level lock and without forfeiting
@@ -1008,11 +1009,25 @@ class FunctionStorageSqlite:
         Serializing writes costs nothing here. Measured: pops are 0.007 ms and
         concurrency already made them *slower* (128k/s at 1 thread → 79k/s at
         16), so there was never any write parallelism to lose — only the error.
+
+        **Readers too.** This first serialized writers only, which is not
+        enough: shared-cache locks are per *table* and conflict in both
+        directions. A writer cannot modify a table another connection is
+        reading, and a reader cannot read one another connection has written
+        and not yet committed — either is the same unretried `SQLITE_LOCKED`.
+        So a `state_scan` overlapping an `execution_clear` failed exactly as
+        two pops had. It stayed hidden because `vgi-fixture-http`, the one
+        in-tree user of `:memory:`, silently ran on the file DB until 0.34.1:
+        `import vgi` resolved `Function.storage` before the fixture's `main()`
+        could ask for memory. Once it really ran here, 69 cases of the
+        integration suite failed with "database table is locked". Every read
+        fetches eagerly (`fetchall`/`fetchone`), so no statement outlives the
+        guard, and — as above — there was no concurrency to give up.
         """
-        if self._write_lock is None:
+        if self._op_lock is None:
             yield
             return
-        with self._write_lock:
+        with self._op_lock:
             yield
 
     def close(self) -> None:
@@ -1477,40 +1492,37 @@ class FunctionStorageSqlite:
         conn.commit()
 
 
-def _guard_sqlite_writes() -> None:
-    """Route every FunctionStorageSqlite writer through `_write_guard`.
+#: Public methods that run no statement against the shared cache, so they are
+#: left outside `_op_guard`. ``close`` only drops the calling thread's own
+#: connection.
+_UNGUARDED_OPS = frozenset({"close"})
+
 
-    Applied here rather than by editing each method so no writer can be added
-    later and silently miss the guard — a partial fix would be worse than none,
-    since one unguarded writer is enough to re-introduce `SQLITE_LOCKED` for
-    every other one sharing the cache.
+def _guard_sqlite_ops() -> None:
+    """Route every public FunctionStorageSqlite operation through `_op_guard`.
+
+    Derived from the class rather than listed: the previous version named its
+    methods by hand, the four readers were never on the list, and one unguarded
+    operation is enough to re-introduce `SQLITE_LOCKED` for every other one
+    sharing the cache. A new public method is now guarded by default, and
+    `_UNGUARDED_OPS` is the only way out of it.
     """
 
     def guarded(fn: Any) -> Any:
         @functools.wraps(fn)
         def wrapper(self: "FunctionStorageSqlite", *a: Any, **k: Any) -> Any:
-            with self._write_guard():
+            with self._op_guard():
                 return fn(self, *a, **k)
 
         return wrapper
 
-    for name in (
-        "queue_push",
-        "queue_pop",
-        "queue_clear",
-        "state_put_many",
-        "state_drain",
-        "state_delete",
-        "state_append",
-        "execution_clear",
-        "state_counter_add",
-        "state_counter_set",
-        "state_counter_delete",
-    ):
-        setattr(FunctionStorageSqlite, name, guarded(getattr(FunctionStorageSqlite, name)))
+    for name, member in list(vars(FunctionStorageSqlite).items()):
+        if name.startswith("_") or name in _UNGUARDED_OPS or not inspect.isfunction(member):
+            continue
+        setattr(FunctionStorageSqlite, name, guarded(member))
 
 
-_guard_sqlite_writes()
+_guard_sqlite_ops()
 
 
 class ShardedSqliteStorage:

vgi/serve.py

@@ -217,7 +217,6 @@ def create_app(
     max_stream_response_bytes: int | None = None,
     max_externalized_response_bytes: int | None = None,
     introspect_principals: Iterable[str] | None = None,
-    introspect_rate_limit: int | None = None,
     iroh_bridge_issuer: str | None = None,
     iroh_trusted_proxy_addresses: Iterable[str] = (),
     iroh_authenticate: bool = True,
@@ -279,9 +278,6 @@ def create_app(
             ``vgi_rpc.Identity.v1``'s ``introspect_token``.  Only consulted
             when the worker class overrides ``resolve_token``.  ``None`` reads
             ``VGI_INTROSPECT_PRINCIPALS``.
-        introspect_rate_limit: Introspection requests allowed per caller per
-            second.  ``None`` reads ``VGI_INTROSPECT_RATE_LIMIT``, defaulting
-            to 20.
         iroh_bridge_issuer: Operator-controlled identity namespace for an
             ``iroh-http/2`` bridge. ``None`` disables Iroh header trust.
         iroh_trusted_proxy_addresses: Exact immediate bridge addresses.
@@ -327,7 +323,7 @@ def create_app(
         worker,
         enable_describe=describe,
         server_version=_get_vgi_version(),
-        identity=_build_identity(worker_cls, introspect_principals, introspect_rate_limit),
+        identity=_build_identity(worker_cls, introspect_principals),
     )
 
     effective_peer_identity_providers = tuple(peer_identity_providers)
@@ -499,15 +495,6 @@ def main() -> None:
                 "that case, with no permissive default. Env: VGI_INTROSPECT_PRINCIPALS."
             ),
         ),
-        introspect_rate_limit: int | None = typer.Option(  # noqa: B008
-            None,
-            "--introspect-rate-limit",
-            help=(
-                "Introspection requests allowed per caller per second (default 20). "
-                "Bounds, rather than closes, the oracle an allowlisted-but-compromised "
-                "caller has. Env: VGI_INTROSPECT_RATE_LIMIT."
-            ),
-        ),
         access_log_sample: float | None = typer.Option(  # noqa: B008
             None,
             "--access-log-sample",
@@ -591,7 +578,6 @@ def main() -> None:
                 max_stream_response_bytes=max_stream_response_bytes,
                 max_externalized_response_bytes=max_externalized_response_bytes,
                 introspect_principals=introspect_principals,
-                introspect_rate_limit=introspect_rate_limit,
                 server=server,
                 worker_ref=worker_ref,
                 http_workers=http_workers,
@@ -802,7 +788,6 @@ def _resolve_authenticate() -> Callable[..., Any] | None:
 def _build_identity(
     worker_cls: type[Worker],
     introspect_principals: Iterable[str] | None,
-    introspect_rate_limit: int | None,
 ) -> IdentityImpl | None:
     """Build the ``vgi_rpc.Identity.v1`` implementation, or ``None``.
 
@@ -823,8 +808,6 @@ def _build_identity(
             override.
         introspect_principals: Principals permitted to introspect, or ``None``
             to read the environment.
-        introspect_rate_limit: Per-caller, per-second ceiling, or ``None`` to
-            read the environment.
 
     Returns:
         The implementation, or ``None`` when this worker does not resolve
@@ -842,7 +825,6 @@ def _build_identity(
     return IdentityImpl(
         resolve_token=resolver,
         introspect_principals=_resolve_introspect_principals(introspect_principals),
-        introspect_rate_limit=_resolve_introspect_rate_limit(introspect_rate_limit),
     )
 
 
@@ -891,42 +873,6 @@ def _resolve_introspect_principals(explicit: Iterable[str] | None) -> list[str]:
     return principals
 
 
-def _resolve_introspect_rate_limit(explicit: int | None) -> int:
-    """Resolve introspection requests allowed per caller per second.
-
-    Env var: ``VGI_INTROSPECT_RATE_LIMIT``; defaults to 20.
-
-    Args:
-        explicit: Value passed to :func:`create_app`, or None to read the
-            environment.
-
-    Returns:
-        A positive per-caller, per-second request ceiling.
-
-    Raises:
-        SystemExit: When the environment value is not a positive integer. A
-            typo that silently became 0 would refuse every introspection with
-            no diagnostic; one that became huge would remove the bound on an
-            allowlisted-but-compromised caller's guessing rate.
-
-    """
-    if explicit is not None:
-        value = explicit
-    else:
-        raw = os.environ.get("VGI_INTROSPECT_RATE_LIMIT")
-        if not raw:
-            return 20
-        try:
-            value = int(raw)
-        except ValueError:
-            sys.stderr.write(f"Error: VGI_INTROSPECT_RATE_LIMIT must be an integer, got {raw!r}\n")
-            sys.exit(1)
-    if value <= 0:
-        sys.stderr.write(f"Error: introspection rate limit must be positive, got {value}\n")
-        sys.exit(1)
-    return value
-
-
 def _resolve_proxy_proof_gate() -> Any | None:
     """Build a proxy-proof gate from ``VGI_PROXY_PROOF_*`` environment variables.
 
@@ -1506,7 +1452,6 @@ def _serve_http(
     max_stream_response_bytes: int | None = None,
     max_externalized_response_bytes: int | None = None,
     introspect_principals: str | None = None,
-    introspect_rate_limit: int | None = None,
     server: str = "waitress",
     worker_ref: str | None = None,
     http_workers: int | None = None,
@@ -1524,8 +1469,6 @@ def _serve_http(
     # export_serve_config for why the environment is the channel.
     if introspect_principals is not None:
         os.environ["VGI_INTROSPECT_PRINCIPALS"] = introspect_principals
-    if introspect_rate_limit is not None:
-        os.environ["VGI_INTROSPECT_RATE_LIMIT"] = str(introspect_rate_limit)
 
     if server == "granian":
         _serve_http_granian(

vgi/table_function.py

@@ -8,6 +8,7 @@ to `process()` either emits a batch via `out.emit()` or signals completion via `
 
 from __future__ import annotations
 
+import inspect
 import uuid
 from abc import abstractmethod
 from collections.abc import Mapping
@@ -854,8 +855,19 @@ class TableFunctionBase[TArgs](vgi.function.Function):
                             cls.FunctionArguments = type_args[0]
                         break
 
-        # Skip validation for abstract base classes
-        is_abstract = any(getattr(getattr(cls, name, None), "__isabstractmethod__", False) for name in dir(cls))
+        # Skip validation for abstract base classes. Each attribute is read with
+        # getattr_static, which returns the raw class attribute without invoking
+        # descriptors: a plain getattr() here resolved the inherited
+        # `Function.storage` descriptor, whose first access builds the default
+        # SQLite store on disk. Because vgi defines subclasses of its own, that
+        # made `import vgi` alone create a database under the user's state
+        # directory, and fail outright where that directory is not writable (a
+        # container's non-root user, say). The raw attribute answers the same
+        # question: classmethod, staticmethod and property objects all expose
+        # the `__isabstractmethod__` of what they wrap.
+        is_abstract = any(
+            getattr(inspect.getattr_static(cls, name, None), "__isabstractmethod__", False) for name in dir(cls)
+        )
         if is_abstract:
             cls._setting_params = {}
             cls._secret_params = {}

vgi/table_in_out_function.py

@@ -360,7 +360,8 @@ class TableInOutFunction[
 
         Args:
             params: The process parameters — function args, settings, secrets.
-            states: The accumulated per-partition states from ``transform()``.
+            states: The accumulated states from ``transform()``, one per
+                substream of this execution that saw input.
 
         Returns:
             List of pa.RecordBatch to emit as final output.
@@ -412,11 +413,17 @@ class TableInOutFunction[
         """
         result = cls.transform(batch, params, state)
 
-        # Save state for distributed processing (upsert semantics)
+        # Save state for distributed processing (upsert semantics), one row per
+        # substream. Storage is scoped to the execution, which every connection
+        # of a fanned-out scan shares, and one process serves many of those
+        # connections under the launcher, TCP or HTTP — so a per-process key let
+        # them overwrite each other and finish() undercounted. The pid remains
+        # only for a client that sends no substream_id, which it keys as before.
         if state is not None:
-            params.storage.state_put(
-                FrameworkNS.TIO_STATE, BoundStorage.pack_int_key(os.getpid()), state.serialize_to_bytes()
-            )
+            key = params.substream_id
+            if key is None:
+                key = BoundStorage.pack_int_key(os.getpid())
+            params.storage.state_put(FrameworkNS.TIO_STATE, key, state.serialize_to_bytes())
 
         # Handle single batch or list of batches — exchange must emit exactly one
         if isinstance(result, list):

{vgi_python-0.34.0.dist-info → vgi_python-0.35.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: vgi-python
-Version: 0.34.0
+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.0.dist-info → vgi_python-0.35.0.dist-info}/RECORD

@@ -12,8 +12,8 @@ vgi/copy_to_function.py,sha256=8l0v_DyEF1EnFwinStrZDQ-yNFfGJsv3Mr5o2jG30f0,9279
 vgi/exceptions.py,sha256=oX_sZc9xGWi7Xf8cJQf89fX19i3ocDEj_V_76GINgBQ,7294
 vgi/filter_v2.py,sha256=3cW6ukHOb0kx13-mN2UEvfib4_Z2r94zVT2E5zQZwiM,53769
 vgi/filter_v2_builder.py,sha256=8OmyzDI6GDdH4pYm2sJFMidzKusi0I8IGNipolPpjX0,5535
-vgi/function.py,sha256=J8XlHjYsJ-Wg5ePeTosTpnGfGa-YTyYb6Yf00XP1zPM,10934
-vgi/function_storage.py,sha256=ZghNlKndrLjMu200_P_qzUTSk-uOQDp0ikenp5C53m8,66434
+vgi/function.py,sha256=KIfvKk1nzBvRDPXViHNX89tv6gvIMiDj4e8fl6ANqQg,11626
+vgi/function_storage.py,sha256=FjVwxc1BIjWo-82j8YE5qcU8w66sGjwyGsTmCUhn-Kw,67576
 vgi/function_storage_azure_sql.py,sha256=lALZK6FBU-dW4g-PEMtw-zysEfK1o_NNvTX3r6YZu-k,36158
 vgi/function_storage_cf_do.py,sha256=s5LRBLZPC6XOhLkKiXiF_OhW8GiN5zsZesb6rR_g6wY,29425
 vgi/invocation.py,sha256=GQ82v0TlryS0yNfhDjzBi5vNpRo1ApIYO0GwkUSxx_U,5713
@@ -30,12 +30,12 @@ vgi/schema_path.py,sha256=GVlkZlCUj7GbVhgiocSMC6Ff5iTJhKqiYE62hMIEKiI,2403
 vgi/schema_utils.py,sha256=zQCliUgIpO2u77Mhtgg3OFvOEDNgJopu6kj2fw8YP1I,7945
 vgi/secret_protocol.py,sha256=iCDl7nF7Nb4cJV4vpfbldunTDqDJWzCzS7uCmOACf7U,7151
 vgi/secret_service.py,sha256=r7qCzfnOMirf9wSCUe-mgFe3z6v9_cDRzixuSAZG_bs,8973
-vgi/serve.py,sha256=dyLHzMFdu1AUBtte2mwwYjtQeSF0fOLha1v9MBZbuD0,66163
+vgi/serve.py,sha256=5UmvRAGcHj5RKCOUQMXG9RFVYAbLZsHwwk1qVI9fipY,63844
 vgi/split_token.py,sha256=tutcksj-hgWrLY7UW3sSqkyoaD-cMqNTOeff40MGl_g,10850
 vgi/table_buffering_function.py,sha256=O5TcIdqk8-YViCQCkb8bOevO-zhe3IoyzLgwXDO3Cjc,19531
 vgi/table_filter_pushdown.py,sha256=2wJK09OkZZm-WYFsB-um4lbIMZV6gU1fcx8EsHglnA4,61861
-vgi/table_function.py,sha256=lAxWnjBcZBpLoR87Pe-QTK7c8WK_JQh1r_OJ9amI4kk,72746
-vgi/table_in_out_function.py,sha256=UGEeXsGkcx0BLt9RyKP6jQEbK6eFTUG6QIGEhxo_VxA,18865
+vgi/table_function.py,sha256=8Pti3uFnsRaPCVG-CGYl9r3GHJF146Fp_62oXXwHKKw,73502
+vgi/table_in_out_function.py,sha256=F2QEtsbGEYHDVyQ4Cf9OCW7HlWXeqekAyx607foB-bs,19393
 vgi/worker.py,sha256=MGMQmy6PPKCqo5q_9fBS3z3zf4y6-UKdJAJiHGfnk50,249553
 vgi/write_results.py,sha256=-OrUcz6E9ahhC_pnKYAwIMR2LpapwQafLC4IOnPTmec,2851
 vgi/_test_fixtures/__init__.py,sha256=xQq-QQLk8USQ6TZHsPiPcZldNNUdcJ2gToXMPGzScLI,444
@@ -52,7 +52,7 @@ vgi/_test_fixtures/http_server.py,sha256=AviomIEClCEuA9WPgQOzrMtQ484N04rQupK8dWO
 vgi/_test_fixtures/nest_tensor.py,sha256=UjjW9UwipYG3ehQpZOm4hdzsafMyvVc0ZKJCrqiZTPU,24471
 vgi/_test_fixtures/orchard_catalog.py,sha256=8Uv-mKTIgl-OYU9JLgG23owlHGmgniyF2chPoKXGtuI,1643
 vgi/_test_fixtures/simple_writable.py,sha256=OmyENVnsgJmYH0_5sNWMt_Xgj9JoPaOu7uI5_ROZDKg,32020
-vgi/_test_fixtures/table_in_out.py,sha256=sWTSXwH-BUaSNOQsDmDqlFZxZ5GGtD-_xmysD2g7aV8,93148
+vgi/_test_fixtures/table_in_out.py,sha256=AlBBsbwsMfZkCjGxoCub--OJqmQAim5PgWxAdpbO9Ik,93190
 vgi/_test_fixtures/table_in_out_same_name.py,sha256=jdsQNdKn64T54W_TcLB-rhydI69Y0Uzr5n6FU7v9rIU,8649
 vgi/_test_fixtures/twin_catalogs.py,sha256=UFsFuZ_nFpe62HatGnOMru36vk35Xt3Ta1Hkr1aWN9w,4450
 vgi/_test_fixtures/versioned.py,sha256=gnxNejc4cNGPKl_DxJk1SU8Ielj-rwmQYGkiShXzxK4,5786
@@ -139,7 +139,7 @@ vgi/client/cli_table.py,sha256=H1xrKZF5yYmSe55YSrLWXGIXPmuGuzQcncEBvqL43zs,26498
 vgi/client/cli_transaction.py,sha256=TDW0ZrBy8XM_eYSkYk5ewEsnozfzDJOlopd66Fm7OOE,3142
 vgi/client/cli_utils.py,sha256=_JoNiVu12NV4Pg2b1wtWFt0L0uIWJ9p9mBIfIu-QIuM,17387
 vgi/client/cli_view.py,sha256=0qhxoS91-zFMjq8V_Fb0PNW-YDxERu8-zPpxSFEE-G8,8490
-vgi/client/client.py,sha256=iGXmOUN1xl6gdnFZV6pfmgf70S7AgMjC9lnvzMjLZp0,161386
+vgi/client/client.py,sha256=ocboi5d_h4KT1RXMEWMXAWYKSC5OH9IsJ4ah6z6C1JI,163751
 vgi/client/errors.py,sha256=cSN65cyQMk3crwZCz1IdPErK3mtlEkTNpu-nuQUDOQE,1633
 vgi/http/__init__.py,sha256=hlOwOVcoZqmEKVGk7ganOdr5ryRSpEhLBF9sRD7BkYc,608
 vgi/http/demo_storage.py,sha256=830s-H61thozC3eEuqdnwCpYFfvoJRq9vjyuXa5OURo,8769
@@ -152,8 +152,8 @@ vgi/transactor/_duckdb_compat.py,sha256=sXVZ9JLKAQyGR1BjWczSwdQEavtr-TcZPoVZZnTr
 vgi/transactor/client.py,sha256=7DTeMksogsw6ANjQjGOPpKYrV76rg4_kGjktMJf54jg,4486
 vgi/transactor/protocol.py,sha256=v59IvrKnuvwOXvn_HEcBAbCzDVcx0akgKN0R1mChXg0,5034
 vgi/transactor/server.py,sha256=nzsZQxJZdgappdYX8okrFIrjFtUbdM_Hhskl1fZ2nDY,32553
-vgi_python-0.34.0.dist-info/METADATA,sha256=4-WKG1yNlJmW1IRUWKY1kssQ_QLYhOrSlZqQs_7dz28,25617
-vgi_python-0.34.0.dist-info/WHEEL,sha256=THafob7ofN-NsuMN7Mg4qZyHaQI7KkD-QlcQatYhXPo,87
-vgi_python-0.34.0.dist-info/entry_points.txt,sha256=3Kz1vgodw3pOL_xjtSyDB55-ZRy-U2X-X_Bdr582x0Q,165
-vgi_python-0.34.0.dist-info/licenses/LICENSE,sha256=pbJb4zZasP6n5ifEV81wFu017TarjydaYVmGbHcehtY,6103
-vgi_python-0.34.0.dist-info/RECORD,,
+vgi_python-0.35.0.dist-info/METADATA,sha256=lNsV-ESefoEMsTf3l8hEhgiqthtqmbRBHFHRoGDY7VE,25617
+vgi_python-0.35.0.dist-info/WHEEL,sha256=THafob7ofN-NsuMN7Mg4qZyHaQI7KkD-QlcQatYhXPo,87
+vgi_python-0.35.0.dist-info/entry_points.txt,sha256=3Kz1vgodw3pOL_xjtSyDB55-ZRy-U2X-X_Bdr582x0Q,165
+vgi_python-0.35.0.dist-info/licenses/LICENSE,sha256=pbJb4zZasP6n5ifEV81wFu017TarjydaYVmGbHcehtY,6103
+vgi_python-0.35.0.dist-info/RECORD,,