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

vgi/_test_fixtures/bad_protocol.py

@@ -44,6 +44,14 @@ BAD_PROTOCOL_VERSION = "99.0.0"
 class BadProtocol(VgiProtocol):
     """VgiProtocol surface with a deliberately incompatible version."""
 
+    # The *only* thing this fixture varies is the version. As of vgi-rpc
+    # 0.46.0 the protocol name is the dispatch routing key, and it defaults to
+    # the class name -- so without this line subclassing alone renames the
+    # protocol to ``BadProtocol``, the client's request for ``VgiProtocol``
+    # finds no such protocol hosted, and the caller gets
+    # ``ProtocolNotSupportedError`` before the version gate it came to test
+    # ever runs.
+    protocol_name: ClassVar[str] = "vgi.v2"
     protocol_version: ClassVar[str] = BAD_PROTOCOL_VERSION
 
 

vgi/_test_fixtures/table_in_out.py

@@ -51,7 +51,7 @@ from vgi_rpc import ArrowSerializableDataclass, ArrowType
 from vgi_rpc.log import Level
 from vgi_rpc.rpc import OutputCollector
 
-from vgi.arguments import Arg, Setting, TableInput
+from vgi.arguments import AnyArrow, Arg, Setting, TableInput
 from vgi.cache_control import CacheControl
 from vgi.invocation import BindResponse
 from vgi.metadata import FunctionExample
@@ -94,6 +94,8 @@ __all__ = [
     "GeoEncode3Function",
     "RowSumFunction",
     "BlendedDropFunction",
+    "BlendedAnyFunction",
+    "BlendedAnyVarargsFunction",
     "SubstreamPartialSumFunction",
     "MultiBatchFinishFunction",
     "SumAllColumnsFunction",
@@ -1880,6 +1882,87 @@ class BlendedExplodeFunction(RowTransformFunction[_ExplodeArgs]):
         cast("VgiOutputCollector", out).emit(out_batch, parent_rows=parent_rows)
 
 
+@dataclass(slots=True, frozen=True, kw_only=True)
+class _AnyArgs:
+    """One positional ANY-typed input column."""
+
+    value: Annotated[AnyArrow, Arg(0, doc="Input column of any type (echoed back unchanged)")]
+
+
+class BlendedAnyFunction(RowTransformFunction[_AnyArgs]):
+    """Blended 1->1 echo of a single ANY-typed input column.
+
+    Proves a blended positional arg may be declared ANY: the declared type names
+    no concrete Arrow type, so the client must build the worker's input schema
+    from the type DuckDB actually resolved for the call (a STRUCT built per row,
+    a whole-row struct, a LIST, a plain VARCHAR ...) rather than from the
+    declaration. The output column ``value`` is bound to that resolved input
+    type at bind time and the column is passed through untouched, so a test
+    asserts on DuckDB's own ``typeof(value)`` and on the round-tripped values —
+    nothing here depends on how an SDK happens to render a type name.
+    """
+
+    class Meta:
+        name = "blended_any"
+        description = "Blended 1->1 echo of one ANY-typed input column (output typed from the input)"
+        categories = ["blended", "test"]
+
+    @classmethod
+    def on_bind(cls, params: BindParams[_AnyArgs]) -> BindResponse:
+        input_schema = params.bind_call.input_schema
+        assert input_schema is not None
+        return BindResponse(output_schema=pa.schema([pa.field("value", input_schema.field(0).type)]))
+
+    @classmethod
+    def process(
+        cls,
+        params: ProcessParams[_AnyArgs],
+        state: None,
+        batch: pa.RecordBatch,
+        out: OutputCollector,
+    ) -> None:
+        out.emit(pa.record_batch([batch.column(0)], schema=params.output_schema))
+
+
+@dataclass(slots=True, frozen=True, kw_only=True)
+class _AnyVarargsArgs:
+    """N positional ANY-typed input columns, each free to be a different type."""
+
+    values: Annotated[list[AnyArrow], Arg(0, varargs=True, doc="Input columns of any types (echoed back)")]
+
+
+class BlendedAnyVarargsFunction(RowTransformFunction[_AnyVarargsArgs]):
+    """Blended 1->1 echo of N ANY-typed VARARGS input columns.
+
+    The varargs counterpart of ``blended_any``: every runtime column may resolve
+    to a different concrete type, so the client must take each column's type
+    from the call rather than from the (ANY) vararg element type. Output columns
+    are ``col0..colN-1`` — the names the client generates for varargs blended
+    input — each bound to its own resolved input type.
+    """
+
+    class Meta:
+        name = "blended_any_varargs"
+        description = "Blended 1->1 echo of N ANY-typed varargs input columns (col0..colN-1)"
+        categories = ["blended", "test"]
+
+    @classmethod
+    def on_bind(cls, params: BindParams[_AnyVarargsArgs]) -> BindResponse:
+        input_schema = params.bind_call.input_schema
+        assert input_schema is not None
+        return BindResponse(output_schema=pa.schema([pa.field(f"col{i}", f.type) for i, f in enumerate(input_schema)]))
+
+    @classmethod
+    def process(
+        cls,
+        params: ProcessParams[_AnyVarargsArgs],
+        state: None,
+        batch: pa.RecordBatch,
+        out: OutputCollector,
+    ) -> None:
+        out.emit(pa.record_batch(cls.input_columns(batch), schema=params.output_schema))
+
+
 class CachedExplodeFunction(RowTransformFunction[_ExplodeArgs]):
     """Cacheable blended 1->N fan-out advertising vgi.cache.per_value.
 

vgi/_test_fixtures/worker.py

@@ -267,6 +267,8 @@ from vgi._test_fixtures.table.tt_pushdown import (
 )
 from vgi._test_fixtures.table_in_out import (
     BatchIndexBufferInputFunction,
+    BlendedAnyFunction,
+    BlendedAnyVarargsFunction,
     BlendedDropFunction,
     BlendedExplodeFunction,
     BufferEmitWideFunction,
@@ -432,6 +434,8 @@ _EXAMPLE_CATALOG = Catalog(
                 GeoEncode3Function,
                 RowSumFunction,
                 BlendedDropFunction,
+                BlendedAnyFunction,
+                BlendedAnyVarargsFunction,
                 BlendedExplodeFunction,
                 CachedExplodeFunction,
                 ProjectableBlendedFunction,

vgi/argument_spec.py

@@ -19,7 +19,8 @@ import warnings
 from collections.abc import Sequence
 from dataclasses import dataclass
 from functools import cache
-from typing import Annotated, Any, get_args, get_origin, get_type_hints
+from types import UnionType
+from typing import Annotated, Any, Union, get_args, get_origin, get_type_hints
 
 import pyarrow as pa
 
@@ -395,14 +396,22 @@ def parameter_default_values_from_specs(
     arrays: list[pa.Array[Any]] = []
     names: list[str] = []
     for spec in default_specs:
-        if pa.types.is_null(spec.arrow_type):
-            raise ValueError(
-                f"Parameter {spec.name!r} has a default but no concrete Arrow type; "
-                "typed defaults require an explicit parameter type"
-            )
         value = spec.default_value
         if isinstance(value, pa.Scalar):
             value = value.as_py()
+        # An ANY-typed parameter (AnyArrow) has no concrete Arrow type, so a
+        # VALUE default cannot be represented. `None` still can: a null-typed
+        # array holds nulls, and it is column PRESENCE, not the value, that
+        # marks a parameter as having a default. Allowing it lets a required
+        # ANY parameter be declared `default=None` so that omitting it reaches
+        # the function's own on_bind() validation — which can name the argument
+        # and show its shape — instead of raising a bare KeyError during
+        # argument parsing, before any user code runs.
+        if pa.types.is_null(spec.arrow_type) and value is not None:
+            raise ValueError(
+                f"Parameter {spec.name!r} has a non-null default but no concrete Arrow type; "
+                "a typed default requires an explicit parameter type (None is allowed)"
+            )
         try:
             arrays.append(pa.array([value], type=spec.arrow_type))
         except (pa.ArrowException, TypeError, ValueError) as exc:
@@ -538,6 +547,30 @@ def _format_range(
     return f"{low}, {high}"
 
 
+def _unwrap_optional(annotation: Any) -> Any:
+    """``T | None`` -> ``T``; anything else unchanged.
+
+    A special marker type (``AnyArrow``, ``TableInput``) is recognised by
+    identity, so an Optional wrapper would hide it — an ``AnyArrow | None``
+    parameter would silently become a NULL-typed one, and DuckDB then cannot
+    cast anything into it. Unwrapping first lets a marker be declared nullable,
+    which is how a REQUIRED ANY argument opts into reaching its function's own
+    ``on_bind()`` validation (with ``default=None``) instead of being rejected
+    during parsing. Mirrors what ``_accepts_none`` already looks for.
+
+    Args:
+        annotation: The declared type of an ``Annotated[T, Arg(...)]`` field.
+
+    Returns:
+        The single non-``None`` member of an optional union, else ``annotation``.
+    """
+    origin = get_origin(annotation)
+    if origin is not Union and origin is not UnionType:
+        return annotation
+    members = [a for a in get_args(annotation) if a is not type(None)]
+    return members[0] if len(members) == 1 else annotation
+
+
 def _constraint_kwargs(arg: Arg[Any]) -> dict[str, Any]:
     """Extract discovery-facing constraint metadata from an [`Arg`][] descriptor.
 
@@ -744,6 +777,7 @@ def _extract_argument_specs(
                 if type_args:
                     infer_type = type_args[0]
 
+            infer_type = _unwrap_optional(infer_type)
             is_table_input = infer_type is TableInput
             is_any_type = infer_type is AnyArrow or infer_type is AnyArrowValue
 
@@ -790,8 +824,8 @@ def _extract_argument_specs(
                 # Check for special types (AnyArrow, TableInput)
                 # Priority: Arg subscript type (Arg[AnyArrow]) > class type hint
                 # Also check _returns_any_arrow_value for Annotated[AnyArrowValue, ...]
-                hint = hints.get(attr_name)
-                type_param = getattr(arg_legacy, "_type_param", None)
+                hint = _unwrap_optional(hints.get(attr_name))
+                type_param = _unwrap_optional(getattr(arg_legacy, "_type_param", None))
                 is_table_input = type_param is TableInput or hint is TableInput
                 is_any_type = (
                     type_param is AnyArrow

vgi/auth.py

@@ -9,7 +9,7 @@ HTTP auth factories (require ``vgi[http]``):
     bearer_authenticate, bearer_authenticate_static, chain_authenticate,
     OAuthResourceMetadata, AuthUnavailableError
 
-Token introspection (requires ``vgi[http]``):
+Token introspection (always available):
     TokenIdentity, TokenResolver
 
 JWT auth (requires ``vgi[oauth]``):
@@ -19,12 +19,28 @@ JWT auth (requires ``vgi[oauth]``):
 from __future__ import annotations
 
 import contextlib
+from collections.abc import Callable
 
 from vgi_rpc.rpc import AuthContext, CallContext
 
+# ``vgi_rpc.Identity.v1`` lives at the RPC layer as of vgi-rpc 0.46.0 -- it was
+# an HTTP JSON route (``POST {prefix}/__introspect_token__``) through 0.45.x,
+# which meant it existed on exactly one transport.  So this is no longer gated
+# on the ``http`` extra.  Still not re-exported by ``vgi_rpc.rpc`` itself, so
+# the private module remains the only import path; re-exported here so a worker
+# that implements ``resolve_token`` never has to name one.
+from vgi_rpc.rpc._token_identity import TokenIdentity
+
+#: What :meth:`vgi.worker.Worker.resolve_token` is.  Upstream dropped its own
+#: alias when identity moved to the RPC layer; it is spelled out here so the
+#: name ``vgi.auth.TokenResolver`` keeps working.
+TokenResolver = Callable[[str], "TokenIdentity | None"]
+
 __all__ = [
     "AuthContext",
     "CallContext",
+    "TokenIdentity",
+    "TokenResolver",
 ]
 
 # HTTP auth helpers — available when vgi[http] is installed.
@@ -41,16 +57,9 @@ with contextlib.suppress(ImportError):
         parse_device_code_client_secret,
     )
 
-    # Not re-exported by ``vgi_rpc.http`` itself, so the private module is the
-    # only import path.  Re-exported here so a worker that implements
-    # ``resolve_token`` never has to name a private module.
-    from vgi_rpc.http.server._introspect import TokenIdentity, TokenResolver  # noqa: F401
-
     __all__ += [
         "AuthUnavailableError",
         "OAuthResourceMetadata",
-        "TokenIdentity",
-        "TokenResolver",
         "bearer_authenticate",
         "bearer_authenticate_static",
         "chain_authenticate",

vgi/protocol.py

@@ -3077,10 +3077,26 @@ class VgiProtocol(Protocol):
     a dedicated generator so this version doesn't pollute the byte-key constants).
 
     Attributes:
+        protocol_name: Wire name used as the ``vgi_rpc.protocol`` routing key
+            and as the ``{protocol}`` HTTP path segment. Carries the major
+            version, so an incompatible major is a different name and therefore
+            a 404 rather than a confusing dispatch.
         protocol_version: The VGI protocol version integer, declared as the
             canonical semver (MAJOR.MINOR.PATCH) of the method-and-schema contract.
     """
 
+    # The wire name carries the major version, so an incompatible major is a
+    # *different* protocol and therefore a 404 -- an answer every proxy, WAF and
+    # load balancer understands without an Arrow parser, and one that lets
+    # ``vgi.v2`` and a future ``vgi.v3`` be served side by side while clients
+    # migrate. That matters here specifically: the DuckDB extension ships to
+    # users and cannot be flag-dayed.
+    #
+    # Declared rather than derived. Without it the name defaults to the class
+    # name, which left the six implementations disagreeing four ways -- Python
+    # ``VgiProtocol``, Java and C# ``VgiService``, Go the framework default
+    # ``Service``, TypeScript ``vgi`` -- so no client could address them all.
+    protocol_name: ClassVar[str] = "vgi.v2"
     protocol_version: ClassVar[str] = "2.0.0"
 
     def bind(self, request: BindRequest) -> BindResponse:

vgi/secret_protocol.py

@@ -126,10 +126,17 @@ class VgiSecretProtocol(Protocol):
     backwards-incompatible change, minor for additive, patch for worker-side fixes.
 
     Attributes:
+        protocol_name: Wire name used as the ``vgi_rpc.protocol`` routing key.
+            Independent of :class:`vgi.protocol.VgiProtocol`'s, so this service
+            can be co-hosted beside it or deployed on its own.
         protocol_version: Canonical semver (MAJOR.MINOR.PATCH) of this contract,
             enforced as an exact major+minor match at the dispatch boundary.
     """
 
+    # Its own name and its own major, independent of ``vgi.v2``: this contract
+    # versions on a separate cadence, which is why ``protocol_version_override``
+    # exists on the client side at all.
+    protocol_name: ClassVar[str] = "vgi.secret.v1"
     protocol_version: ClassVar[str] = "1.0.0"
 
     def secret_lookup(self, path: str, type: str) -> SecretLookupResponse:  # noqa: A002

vgi/serve.py

@@ -43,6 +43,7 @@ if TYPE_CHECKING:
     import falcon
     from vgi_rpc.otel import OtelConfig
     from vgi_rpc.rpc import AuthContext, PeerAuthenticationPolicy, PeerIdentityProvider
+    from vgi_rpc.rpc._token_identity import IdentityImpl
 
     from vgi.worker import Worker
 
@@ -275,8 +276,8 @@ def create_app(
             escape, because bytes already uploaded cannot be un-uploaded.
             ``None`` (the default) means no cap.
         introspect_principals: Principals permitted to call
-            ``__introspect_token__``.  Only consulted when the worker class
-            overrides ``resolve_token``.  ``None`` reads
+            ``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
@@ -321,19 +322,13 @@ def create_app(
     worker._signing_key = signing_key
     from vgi.worker import _get_vgi_version
 
-    server = RpcServer(VgiProtocol, worker, enable_describe=describe, server_version=_get_vgi_version())
-
-    # Absent unless the worker class actually implements the lookup. Passing
-    # ``None`` leaves the route unrouted rather than routed-and-refusing, which
-    # is what keeps a dependency upgrade from growing a credential oracle.
-    introspect_resolver = worker_cls._introspect_resolver()
-    introspect_kwargs: dict[str, Any] = {}
-    if introspect_resolver is not None:
-        introspect_kwargs = {
-            "introspect_resolver": introspect_resolver,
-            "introspect_principals": _resolve_introspect_principals(introspect_principals),
-            "introspect_rate_limit": _resolve_introspect_rate_limit(introspect_rate_limit),
-        }
+    server = RpcServer(
+        VgiProtocol,
+        worker,
+        enable_describe=describe,
+        server_version=_get_vgi_version(),
+        identity=_build_identity(worker_cls, introspect_principals, introspect_rate_limit),
+    )
 
     effective_peer_identity_providers = tuple(peer_identity_providers)
     effective_peer_authentication_policy = peer_authentication_policy
@@ -370,7 +365,6 @@ def create_app(
         max_stream_response_bytes=max_stream_response_bytes,
         max_externalized_response_bytes=max_externalized_response_bytes,
         enable_landing_page=False,
-        **introspect_kwargs,
     )
 
     # Frontend: either redirect to external CDN or serve pre-rendered worker page
@@ -500,7 +494,7 @@ def main() -> None:
             None,
             "--introspect-principals",
             help=(
-                "Comma-separated principals permitted to call __introspect_token__. "
+                "Comma-separated principals permitted to call introspect_token. "
                 "Only used when the worker implements resolve_token(); required in "
                 "that case, with no permissive default. Env: VGI_INTROSPECT_PRINCIPALS."
             ),
@@ -805,6 +799,53 @@ def _resolve_authenticate() -> Callable[..., Any] | None:
     return require_all(gate, inner)
 
 
+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``.
+
+    ``None`` unless the worker class actually implements the lookup, and that
+    is the point: ``RpcServer`` then does not host the protocol at all, rather
+    than hosting it and refusing every call. Absent beats routed-and-refusing —
+    it is what keeps a dependency upgrade from growing a
+    credential-to-identity oracle on every existing worker.
+
+    As of vgi-rpc 0.46.0 identity is an RPC-layer protocol hosted on the
+    server, not the HTTP JSON route (``POST {prefix}/__introspect_token__``) it
+    was through 0.45.x. It therefore reaches every transport rather than only
+    HTTP, and a client discovers it through ordinary reflection rather than by
+    calling and reading an error.
+
+    Args:
+        worker_cls: The worker class, consulted for a ``resolve_token``
+            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
+        credentials.
+
+    """
+    resolver = worker_cls._introspect_resolver()
+    if resolver is None:
+        return None
+
+    # Not re-exported by ``vgi_rpc.rpc``, so the private module is the only
+    # import path for the ``vgi_rpc.Identity.v1`` implementation helper.
+    from vgi_rpc.rpc._token_identity import IdentityImpl
+
+    return IdentityImpl(
+        resolve_token=resolver,
+        introspect_principals=_resolve_introspect_principals(introspect_principals),
+        introspect_rate_limit=_resolve_introspect_rate_limit(introspect_rate_limit),
+    )
+
+
 def _resolve_introspect_principals(explicit: Iterable[str] | None) -> list[str]:
     """Resolve the introspector allowlist, or exit with an actionable message.
 
@@ -835,16 +876,16 @@ def _resolve_introspect_principals(explicit: Iterable[str] | None) -> list[str]:
 
     if not principals:
         sys.stderr.write(
-            "Error: this worker implements resolve_token(), which enables the\n"
-            "  POST /__introspect_token__ endpoint, but no introspector allowlist\n"
-            "  was configured. Set VGI_INTROSPECT_PRINCIPALS (comma-separated) or\n"
+            "Error: this worker implements resolve_token(), which hosts the\n"
+            "  vgi_rpc.Identity.v1 protocol, but no introspector allowlist was\n"
+            "  configured. Set VGI_INTROSPECT_PRINCIPALS (comma-separated) or\n"
             "  pass --introspect-principals.\n"
             "\n"
             "  There is no permissive default on purpose: introspection is a\n"
             "  separate capability from authentication, and allowing every\n"
             "  authenticated caller lets any user resolve any other user's\n"
-            "  credential to its owner. Remove resolve_token() to disable the\n"
-            "  endpoint entirely.\n"
+            "  credential to its owner. Remove resolve_token() to leave the\n"
+            "  protocol unhosted entirely.\n"
         )
         sys.exit(1)
     return principals

vgi/worker.py

@@ -172,8 +172,8 @@ if TYPE_CHECKING:
     from collections.abc import Callable
     from ssl import SSLContext
 
-    from vgi_rpc.http.server._introspect import TokenIdentity
     from vgi_rpc.rpc import PeerAuthenticationPolicy, PeerIdentityProvider
+    from vgi_rpc.rpc._token_identity import TokenIdentity
 
     from vgi.catalog.descriptors import Catalog
     from vgi.protocol import (
@@ -1420,13 +1420,17 @@ class Worker:
     def resolve_token(cls, token: str) -> TokenIdentity | None:
         """Resolve an opaque bearer credential to the identity it authenticates as.
 
-        Override to enable ``POST {prefix}/__introspect_token__``, which a
-        reverse proxy calls when it terminates the only public listener and
-        must know *which principal* a credential is before it can authorize
-        anything. Until it is overridden the route does not exist at all —
-        not "exists and refuses", absent — so no worker grows a
+        Override to host ``vgi_rpc.Identity.v1``'s ``introspect_token``,
+        which a reverse proxy calls when it terminates the only public
+        listener and must know *which principal* a credential is before it can
+        authorize anything. Until it is overridden the protocol is not hosted
+        at all — not "hosted and refusing", absent — so no worker grows a
         credential-to-identity oracle by upgrading a dependency.
 
+        Through vgi-rpc 0.45.x this was an HTTP JSON route, ``POST
+        {prefix}/__introspect_token__``. As of 0.46.0 identity lives at the RPC
+        layer, so it reaches every transport rather than only HTTP.
+
         Enabling it also requires an allowlist of principals permitted to ask
         (``--introspect-principals`` / ``VGI_INTROSPECT_PRINCIPALS``). There is
         no permissive default: authenticating and introspecting are different
@@ -1437,7 +1441,7 @@ class Worker:
 
         This is deliberately *not* "run the credential back through the
         worker's own authenticate chain" — see
-        ``vgi_rpc.http.server._introspect`` for the four ways that breaks.
+        ``vgi_rpc.rpc._token_identity`` for the four ways that breaks.
         Write a narrow lookup against whatever store issued the credential.
 
         Args:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: vgi-python
-Version: 0.32.0
+Version: 0.34.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.45.1
+Requires-Dist: vgi-rpc>=0.46.0
 Provides-Extra: azure
 Requires-Dist: azure-identity>=1.16.0; extra == 'azure'
 Requires-Dist: pymssql>=2.3.0; extra == 'azure'

{vgi_python-0.32.0.dist-info → vgi_python-0.34.0.dist-info}/RECORD

@@ -2,10 +2,10 @@ vgi/__init__.py,sha256=8uLMNQcNzWjp8VzYtj2u98_Wp8WpB8c_dKlMv67TH0g,5384
 vgi/_duckdb.py,sha256=YB5D7N3Bwg_xP6X8a5QlumtlAovSej1A1Go5XlNGVko,2162
 vgi/_storage_profile.py,sha256=VkTsXojuE0tHEzurmteQSAiL1vI3CZSgYkL6D_h8GvE,5061
 vgi/aggregate_function.py,sha256=v03wBSy2Rrl9F2pMYvu8GnGrTCQrAVm01HXIFNdjnm4,26886
-vgi/argument_spec.py,sha256=_aO3r6LrRrM7ziOQ27i_ouaofXD_2XMHiwhihNVfj0o,32374
+vgi/argument_spec.py,sha256=SADH97VlFu3asI8CWZ_I7XTuSxwqFciFgdupdAf-tkY,34231
 vgi/arguments.py,sha256=ncnC1CS7KN-2rDjSw9vdf1uHqV5ozebet_eZtcq_ujw,72300
 vgi/attach_header.py,sha256=sxpzCOVa5fl_-kQSCZgeUxS5I9Kuv8VCUjAOF5s1pr0,3782
-vgi/auth.py,sha256=bZq6yWdCI4tP1XglzO-p6t3Dt0b93Am-d57s1aGB_38,1993
+vgi/auth.py,sha256=TlD5bhdyXnFuAoCnoHMU9ffjewVEnpwO5auIvp9GsCA,2486
 vgi/cache_control.py,sha256=IyBp9gZTCc4Y-4V7Rs05_o5lSEjbR2jt6cddXPU0dKw,7812
 vgi/copy_from_function.py,sha256=oroQe5qYzZTJ-ppzQTQ-OruEF1ZlwTBNLBoXYfN-P2o,7133
 vgi/copy_to_function.py,sha256=8l0v_DyEF1EnFwinStrZDQ-yNFfGJsv3Mr5o2jG30f0,9279
@@ -22,26 +22,26 @@ vgi/meta_worker.py,sha256=WggIKvDAlahSrBPaVM7ZqVWk3Xc3JNE70EgeoXdy-3w,31725
 vgi/metadata.py,sha256=M8KZObX1wwCr2lPjgDL0-79gPbeM_NSOIqYCIAAck5M,74719
 vgi/otel.py,sha256=JlUDnk2c0UXSo_j1PJdS67Y--t55sXPg054ADuvHANc,15452
 vgi/profiling.py,sha256=rK7vij3oHhXC3JHI2BsMySsXh7_hrXi0aXpCW8iFSIc,3671
-vgi/protocol.py,sha256=3ln4b0a20is6nPLyZW-Goiexqg6PpeeuzNfKcWoCJHU,163944
+vgi/protocol.py,sha256=m9W00W-c9jv2kqISp_wb8E8Rtity_60_12nzE3_d9Xg,165016
 vgi/protocol_version.txt,sha256=wo_MpTY3vIjhJK8XJd8Ty5jGne3v1i-zzb4c22t2BiQ,6
 vgi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vgi/scalar_function.py,sha256=zj6U1e5mXm4hk_ZB_CAjYmeO1LZBJcEMzNDzhwpXPmQ,53415
 vgi/schema_path.py,sha256=GVlkZlCUj7GbVhgiocSMC6Ff5iTJhKqiYE62hMIEKiI,2403
 vgi/schema_utils.py,sha256=zQCliUgIpO2u77Mhtgg3OFvOEDNgJopu6kj2fw8YP1I,7945
-vgi/secret_protocol.py,sha256=53L01b2KeKGxslniDBOYo299GQmAHm7JaDAC3RNLl6Q,6678
+vgi/secret_protocol.py,sha256=iCDl7nF7Nb4cJV4vpfbldunTDqDJWzCzS7uCmOACf7U,7151
 vgi/secret_service.py,sha256=r7qCzfnOMirf9wSCUe-mgFe3z6v9_cDRzixuSAZG_bs,8973
-vgi/serve.py,sha256=xfiGIlTaLvalFxh233u-BKGdWOBHgza3yFtVGKb5Qjk,64719
+vgi/serve.py,sha256=dyLHzMFdu1AUBtte2mwwYjtQeSF0fOLha1v9MBZbuD0,66163
 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/worker.py,sha256=NdwS5EqVtZ4ZdeDpEr7kinCJ_AX8jMM8SjJ8nd6JwCU,249336
+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
 vgi/_test_fixtures/attach_options.py,sha256=ZNgNTNF1RymSfnU-uVIDTLvCpc283h6O8tZ1UuEa3Lc,12516
 vgi/_test_fixtures/bad_enum.py,sha256=b8l-afmXgGR6iqgIUiVeqHu0C0F8Of8ahEmdQGtqd1g,2916
-vgi/_test_fixtures/bad_protocol.py,sha256=L8kxafWZ-4Sd73F6EpCRo1kWVC-09qzof6OYRXazS_8,2495
+vgi/_test_fixtures/bad_protocol.py,sha256=fPU7rpXEgBxRtPHfuCa0O2AHNRRbZDllLfydHsAKPEg,2992
 vgi/_test_fixtures/cancellable.py,sha256=hetTRLyT4kkazPNcxAdfzj0pYzEmegMksamJbR0w3Ho,12151
 vgi/_test_fixtures/catalog.py,sha256=zjBKBgg4TKoDQ9SYIFj7sx6bOL3_aXHMJHSzTgk1fdA,28526
 vgi/_test_fixtures/companion.py,sha256=Ya_rg2J4tXOYC7zBFOjTTh-4AYuRhJN5BT4tVZULQ-Q,6037
@@ -52,12 +52,12 @@ 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=Ug-n9wvqT5StT7Sm0OQ1MAmOCQr2jzdcpfneiQCpmJM,89813
+vgi/_test_fixtures/table_in_out.py,sha256=sWTSXwH-BUaSNOQsDmDqlFZxZ5GGtD-_xmysD2g7aV8,93148
 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
 vgi/_test_fixtures/versioned_tables.py,sha256=_JHPe6LaiO0x2We28Ion8hh6pSATmHZYvAczB4uwBsA,22272
-vgi/_test_fixtures/worker.py,sha256=5ocHOoa4mksNCTA39LOdvnhDhusam9hVpEb2MQOFSjU,96306
+vgi/_test_fixtures/worker.py,sha256=tAdCcL9x3LwgtY0OG56bapmBCwGZJ-M7paQY9hXjgB8,96440
 vgi/_test_fixtures/accumulate/__init__.py,sha256=4hYT8jqRoVHSjV9TB7v0Z1CMJtdLuPaDWSz4J2fvMDs,868
 vgi/_test_fixtures/accumulate/worker.py,sha256=4a2VaCoOIXPEoJpkNume7FoBlQzs9kRl8b-_ZJMHvnQ,30165
 vgi/_test_fixtures/aggregate/__init__.py,sha256=2GCp80FNrsWFOA2SV3lCffzLjoN5AKwrf57t2YRg8O0,2393
@@ -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.32.0.dist-info/METADATA,sha256=5w0sPJG--crdBQDtvcjDQdPDCr4f89IOXqdPh_PKj5c,25617
-vgi_python-0.32.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-vgi_python-0.32.0.dist-info/entry_points.txt,sha256=3Kz1vgodw3pOL_xjtSyDB55-ZRy-U2X-X_Bdr582x0Q,165
-vgi_python-0.32.0.dist-info/licenses/LICENSE,sha256=pbJb4zZasP6n5ifEV81wFu017TarjydaYVmGbHcehtY,6103
-vgi_python-0.32.0.dist-info/RECORD,,
+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.32.0.dist-info → vgi_python-0.34.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.32.0
+Generator: hatchling 1.32.3
 Root-Is-Purelib: true
 Tag: py3-none-any