vgi-python 0.36.1__tar.gz → 0.37.0__tar.gz

{vgi_python-0.36.1 → vgi_python-0.37.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: vgi-python
-Version: 0.36.1
+Version: 0.37.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.37.0/conformance/filter-v2/cases/positive/boolean-column-predicate.json

@@ -0,0 +1,32 @@
+{
+  "encoding": "vgi.filters.v2",
+  "semantics": "vgi.duckdb.standard.v1",
+  "kind": "snapshot",
+  "predicates": [
+    {
+      "id": "query:bare-boolean-column",
+      "revision": 0,
+      "mode": "required",
+      "source": "query",
+      "expression": {
+        "node": "column_ref",
+        "column_index": 0,
+        "column_name": "flag"
+      }
+    },
+    {
+      "id": "query:negated-boolean-column",
+      "revision": 0,
+      "mode": "required",
+      "source": "query",
+      "expression": {
+        "node": "not",
+        "expression": {
+          "node": "column_ref",
+          "column_index": 1,
+          "column_name": "other_flag"
+        }
+      }
+    }
+  ]
+}

{vgi_python-0.36.1 → vgi_python-0.37.0}/conformance/filter-v2/manifest.json

@@ -30,6 +30,11 @@
       "document": "cases/positive/runtime-filter-snapshot.json",
       "expected": "valid"
     },
+    {
+      "id": "structural.boolean-column-predicate",
+      "document": "cases/positive/boolean-column-predicate.json",
+      "expected": "valid"
+    },
     {
       "id": "structural.and-too-few-children",
       "document": "cases/negative/and-too-few-children.json",

{vgi_python-0.36.1 → vgi_python-0.37.0}/pyproject.toml

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

{vgi_python-0.36.1 → vgi_python-0.37.0}/tests/test_filter_v2.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 
 import json
 from collections.abc import Mapping
-from typing import cast
+from typing import Any, cast
 
 import pyarrow as pa
 import pytest
@@ -531,3 +531,168 @@ def test_unknown_arrow_extension_metadata_is_rejected() -> None:
             _batch(_document([_predicate(_comparison())]), (extension_field, b"opaque")),
             output_schema=pa.schema([("n", pa.int64())]),
         )
+
+
+# ---------------------------------------------------------------------------
+# A boolean column is a predicate on its own
+#
+# `WHERE flag` / `WHERE NOT flag` is idiomatic SQL, and DuckDB pushes it down as
+# a bare `column_ref` rather than rewriting it to `flag = true`. The schema
+# admits that -- `coreExpression` lists `columnRef` first -- but the decoder's
+# boolean gate used to enumerate node *kinds* instead of asking for the resolved
+# *type*, so it refused every one of them: "predicate root must resolve to
+# BOOLEAN", on a node whose type it had already resolved to BOOLEAN and stored.
+# ---------------------------------------------------------------------------
+
+_BOOL_FIELDS: list[pa.Field[Any]] = [pa.field("flag", pa.bool_()), pa.field("n", pa.int64())]
+_BOOL_SCHEMA = pa.schema(_BOOL_FIELDS)
+
+
+def _flag(index: int = 0) -> dict[str, object]:
+    return {"node": "column_ref", "column_index": index, "column_name": "flag"}
+
+
+def test_bare_boolean_column_is_a_valid_predicate_root() -> None:
+    """`WHERE flag` -- the column itself is the predicate."""
+    filters = deserialize_filters(
+        _batch(_document([_predicate(_flag())])),
+        output_schema=_BOOL_SCHEMA,
+    )
+    batch = pa.RecordBatch.from_pydict(
+        {"flag": [True, False, None, True], "n": [1, 2, 3, 4]},
+        schema=_BOOL_SCHEMA,
+    )
+    # evaluate() is the raw three-valued predicate: NULL stays NULL.
+    assert filters.evaluate(batch).to_pylist() == [True, False, None, True]
+    # apply() is what selects rows, and there a NULL predicate is not satisfied
+    # -- the same rows `flag = true` would keep, which is what makes the SQL
+    # rewrite below a projection rather than a change of meaning.
+    assert filters.apply(batch).to_pydict()["n"] == [1, 4]
+
+
+def test_negated_boolean_column_is_a_valid_predicate_root() -> None:
+    """`WHERE NOT flag` -- `not` over a bare column, which the gate also refused."""
+    filters = deserialize_filters(
+        _batch(_document([_predicate({"node": "not", "expression": _flag()})])),
+        output_schema=_BOOL_SCHEMA,
+    )
+    batch = pa.RecordBatch.from_pydict(
+        {"flag": [True, False, None, True], "n": [1, 2, 3, 4]},
+        schema=_BOOL_SCHEMA,
+    )
+    assert filters.evaluate(batch).to_pylist() == [False, True, None, False]
+    # NOT NULL is NULL, so row 3 is not kept -- exactly `flag = false`.
+    assert filters.apply(batch).to_pydict()["n"] == [2]
+
+
+def test_boolean_column_predicates_render_as_sql() -> None:
+    """They must reach SQL, not just the evaluator.
+
+    Left as a generic v2 expression a bare column renders no SQL at all, so a
+    SQL-backed worker loses pushdown on the commonest boolean predicate there
+    is -- and DuckDB does not re-apply what it pushed down, so that is a wrong
+    answer, not a slow one.
+    """
+    positive = deserialize_filters(_batch(_document([_predicate(_flag())])), output_schema=_BOOL_SCHEMA)
+    where, params = positive.to_sql()
+    assert where == '"flag" = ?'
+    assert params == [True]
+
+    negative = deserialize_filters(
+        _batch(_document([_predicate({"node": "not", "expression": _flag()})])),
+        output_schema=_BOOL_SCHEMA,
+    )
+    where, params = negative.to_sql()
+    assert where == '"flag" = ?'
+    assert params == [False]
+
+
+def test_boolean_column_inside_a_conjunction_still_pushes_down() -> None:
+    """The shape that actually showed up: `WHERE other = x AND NOT flag`.
+
+    One unrenderable child used to cost the whole conjunction its pushdown.
+    """
+    document = _document(
+        [
+            _predicate(
+                {
+                    "node": "and",
+                    "children": [
+                        {
+                            "node": "comparison",
+                            "op": "gt",
+                            "left": _column(name="n", index=1),
+                            "right": {"node": "literal", "value_ref": 0},
+                        },
+                        {"node": "not", "expression": _flag()},
+                    ],
+                }
+            )
+        ]
+    )
+    filters = deserialize_filters(
+        _batch(document, (pa.field("value_0", pa.int64()), 2)),
+        output_schema=_BOOL_SCHEMA,
+    )
+    where, params = filters.to_sql()
+    assert where == '("n" > ? AND "flag" = ?)'
+    assert params == [2, False]
+
+
+def test_an_unresolved_column_is_not_assumed_boolean() -> None:
+    """Without a bind schema the column's type is unknown -- refuse, don't guess."""
+    with pytest.raises(FilterDeserializationError, match="predicate root"):
+        deserialize_filters(_batch(_document([_predicate(_flag())])))
+
+
+def test_a_non_boolean_column_is_still_refused() -> None:
+    """`WHERE n` where n is BIGINT is not a predicate."""
+    with pytest.raises(FilterDeserializationError, match="predicate root"):
+        deserialize_filters(
+            _batch(_document([_predicate(_column(name="n", index=1))])),
+            output_schema=_BOOL_SCHEMA,
+        )
+
+
+def test_an_unrenderable_filter_raises_rather_than_vanishing() -> None:
+    """`to_sql()` must never quietly drop a predicate it cannot render.
+
+    DuckDB does not re-apply a filter it pushed into a table function, so the
+    worker's WHERE clause is the only thing standing between the caller and
+    rows the predicate excludes. A skipped filter is therefore a wrong answer,
+    not a slow one -- which is why this raises instead of degrading.
+    """
+    from vgi.table_filter_pushdown import FilterSQLUnsupportedError
+
+    # `n + 1 > 2` -- arithmetic has no legacy leaf shape and no SQL rendering.
+    document = _document(
+        [
+            _predicate(
+                {
+                    "node": "comparison",
+                    "op": "gt",
+                    "left": {
+                        "node": "arithmetic",
+                        "op": "add",
+                        "left": _column(name="n", index=1),
+                        "right": {"node": "literal", "value_ref": 0},
+                    },
+                    "right": {"node": "literal", "value_ref": 1},
+                }
+            )
+        ]
+    )
+    filters = deserialize_filters(
+        _batch(
+            document,
+            (pa.field("value_0", pa.int64()), 1),
+            (pa.field("value_1", pa.int64()), 2),
+        ),
+        output_schema=_BOOL_SCHEMA,
+    )
+    # It evaluates correctly -- there is simply no SQL for it.
+    batch = pa.RecordBatch.from_pydict({"flag": [True, True, True], "n": [0, 2, 5]}, schema=_BOOL_SCHEMA)
+    assert filters.apply(batch).to_pydict()["n"] == [2, 5]
+
+    with pytest.raises(FilterSQLUnsupportedError, match="no SQL rendering"):
+        filters.to_sql()

{vgi_python-0.36.1 → vgi_python-0.37.0}/tests/test_serve.py

@@ -24,7 +24,7 @@ from vgi_rpc import (
 from vgi_rpc.rpc import AuthContext, PeerResolutionContext, peer_identity_primary
 
 from vgi.arguments import Arguments, Auth, Param, Returns
-from vgi.auth import TokenIdentity
+from vgi.auth import IssuedGrant, TokenIdentity
 from vgi.client import Client
 from vgi.scalar_function import ScalarFunction
 from vgi.serve import (
@@ -486,6 +486,32 @@ class _IntrospectingWorker(Worker):
         return None
 
 
+class _MintingWorker(Worker):
+    """Worker that implements only the optional grant-minting hook."""
+
+    functions = [_DoubleFunc]
+
+    @classmethod
+    def mint_grant(cls, principal: str, purpose: str, scopes: list[str], ttl_seconds: int) -> IssuedGrant:
+        # A sealed self-contained credential: the worker owns the format and
+        # the framework never parses it. Capped TTL, to pin that a worker may
+        # issue SHORTER than asked.
+        ttl = min(ttl_seconds, 3600)
+        return IssuedGrant(
+            token=f"sealed:{principal}:{':'.join(scopes)}:{purpose}",
+            expires_at=1_000_000.0 + ttl,
+            grant_id="grant-1",
+        )
+
+
+class _BothWorker(_IntrospectingWorker):
+    """Worker that both resolves credentials and mints grants."""
+
+    @classmethod
+    def mint_grant(cls, principal: str, purpose: str, scopes: list[str], ttl_seconds: int) -> IssuedGrant:
+        return IssuedGrant(token=f"sealed:{principal}", expires_at=1_000_000.0, grant_id="g")
+
+
 class TestIntrospectResolverDetection:
     """``resolve_token`` presence is detected by override, not by a flag."""
 
@@ -516,6 +542,31 @@ def _introspector_ctx(principal: str) -> object:
     )
 
 
+def _minting_ctx(principal: str, *, auth_age_s: float = 0.0) -> object:
+    """Build a ``CallContext`` for a caller who authenticated *auth_age_s* ago.
+
+    Minting reads ``auth_time`` off the credential's claims, and a credential
+    without one cannot mint at all. That single rule is what stops a grant
+    minting another grant — a grant is not IdP-issued, so it carries no
+    ``auth_time`` — and what makes a static bearer token, which proves a
+    machine holds a secret rather than that a human just authenticated,
+    fail closed here.
+    """
+    import time
+
+    from vgi_rpc.rpc import AuthContext, CallContext
+
+    return CallContext(
+        auth=AuthContext(
+            domain="test",
+            authenticated=True,
+            principal=principal,
+            claims={"auth_time": time.time() - auth_age_s},
+        ),
+        emit_client_log=lambda *a, **k: None,
+    )
+
+
 def _hosted_protocols(worker_cls: type[Worker]) -> frozenset[str]:
     """Return the protocol names the server built for *worker_cls* hosts.
 
@@ -655,6 +706,111 @@ class TestTokenIntrospection:
             create_app(_IntrospectingWorker, prefix="/vgi", describe=False)
 
 
+class TestGrantMinting:
+    """``issue_grant`` — the other half of ``vgi_rpc.Identity.v1``.
+
+    Guarded very differently from ``introspect_token``, and deliberately so.
+    Introspection answers a question about *somebody else's* credential, so it
+    needs an allowlist. Minting produces a credential for the *caller* — there
+    is no subject on the wire, so cross-subject minting is closed by
+    construction and no allowlist applies. What this repo owns is the wiring:
+    a ``mint_grant`` override becomes an ``IdentityImpl`` that offers the
+    method, and a worker that never wrote one does not host it.
+    """
+
+    @staticmethod
+    def _identity(worker_cls: type[Worker], **env: str) -> object:
+        from vgi.serve import _build_identity
+
+        with pytest.MonkeyPatch.context() as mp:
+            mp.delenv("VGI_INTROSPECT_PRINCIPALS", raising=False)
+            for key, value in env.items():
+                mp.setenv(key, value)
+            return _build_identity(worker_cls, None)
+
+    def test_base_worker_has_no_minter(self) -> None:
+        """A worker that never wrote the minting gets no issuer."""
+        assert _SingleWorker._grant_minter() is None
+
+    def test_override_is_detected(self) -> None:
+        """Implementing the hook is what enables it."""
+        minter = _MintingWorker._grant_minter()
+        assert minter is not None
+
+    def test_minting_alone_hosts_the_protocol(self) -> None:
+        """A worker may mint without resolving — the two are independent."""
+        assert "vgi_rpc.Identity.v1" in _hosted_protocols(_MintingWorker)
+
+    def test_minting_alone_offers_only_issue_grant(self) -> None:
+        """The protocol describes what the worker does, not what it could do."""
+        identity = self._identity(_MintingWorker)
+        assert identity is not None
+        assert identity.offered_methods() == frozenset({"issue_grant"})  # type: ignore[attr-defined]
+
+    def test_minting_alone_needs_no_introspect_allowlist(self) -> None:
+        """No allowlist is required to mint: a grant is not an oracle.
+
+        Requiring one would be a startup error for a worker that never exposes
+        anybody else's identity — the exact opposite of the guard's purpose.
+        """
+        with pytest.MonkeyPatch.context() as mp:
+            mp.delenv("VGI_INTROSPECT_PRINCIPALS", raising=False)
+            create_app(_MintingWorker, prefix="/vgi", describe=False)
+
+    def test_both_hooks_offer_both_methods(self) -> None:
+        """Resolving and minting compose."""
+        identity = self._identity(_BothWorker, VGI_INTROSPECT_PRINCIPALS="proxy-a")
+        assert identity is not None
+        assert identity.offered_methods() == frozenset({"introspect_token", "issue_grant"})  # type: ignore[attr-defined]
+
+    def test_the_caller_is_the_subject(self) -> None:
+        """The framework supplies the principal; the wire method has no subject field.
+
+        This is the property that makes an allowlist unnecessary, so pin it
+        here rather than trusting the signature to stay that way.
+        """
+        identity = self._identity(_MintingWorker)
+        assert identity is not None
+        grant = identity.issue_grant(  # type: ignore[attr-defined]
+            "nightly-etl", ["read"], 600, _minting_ctx("alice")
+        )
+        assert grant.token.startswith("sealed:alice:")
+        assert grant.grant_id == "grant-1"
+
+    def test_a_worker_may_issue_a_shorter_ttl_than_asked(self) -> None:
+        """A worker may narrow the request; it must never widen it."""
+        identity = self._identity(_MintingWorker)
+        assert identity is not None
+        grant = identity.issue_grant(  # type: ignore[attr-defined]
+            "long", [], 86_400, _minting_ctx("alice")
+        )
+        assert grant.expires_at == 1_000_000.0 + 3600
+
+    def test_stale_authentication_cannot_mint(self) -> None:
+        """Minting while the user is present is enforced, not just documented."""
+        from vgi_rpc.rpc._token_identity import StaleAuthError
+
+        identity = self._identity(_MintingWorker)
+        assert identity is not None
+        with pytest.raises(StaleAuthError):
+            identity.issue_grant("x", [], 60, _minting_ctx("alice", auth_age_s=86_400))  # type: ignore[attr-defined]
+
+    def test_a_credential_with_no_auth_time_cannot_mint(self) -> None:
+        """A grant cannot mint another grant, and a static bearer cannot mint at all.
+
+        Neither carries ``auth_time`` — only an IdP-issued credential does — so
+        the lineage cannot escape the identity provider. This is the rule that
+        makes delegation accountable to a human login rather than to whoever
+        currently holds a machine secret.
+        """
+        from vgi_rpc.rpc._token_identity import StaleAuthError
+
+        identity = self._identity(_MintingWorker)
+        assert identity is not None
+        with pytest.raises(StaleAuthError):
+            identity.issue_grant("x", [], 60, _introspector_ctx("etl-service"))  # type: ignore[attr-defined]
+
+
 class TestAuthUnavailableReExport:
     """``AuthUnavailableError`` is reachable without naming a vgi_rpc module."""
 

{vgi_python-0.36.1 → vgi_python-0.37.0}/uv.lock

@@ -2580,7 +2580,7 @@ requires-dist = [
 
 [[package]]
 name = "vgi-python"
-version = "0.36.1"
+version = "0.37.0"
 source = { editable = "." }
 dependencies = [
     { name = "click" },

{vgi_python-0.36.1 → vgi_python-0.37.0}/vgi/_test_fixtures/table/__init__.py

@@ -65,6 +65,7 @@ from vgi._test_fixtures.table.catalog_scans import (
     ProjectsScanFunction,
 )
 from vgi._test_fixtures.table.filters import (
+    BoolFilterEchoFunction,
     DictFilterEchoFunction,
     DynamicFilterEchoFunction,
     ExpressionFilterTestFunction,
@@ -216,6 +217,7 @@ __all__ = [
     "ConstantColumnsFunction",
     "CountryPartitionedSalesFunction",
     "DepartmentsScanFunction",
+    "BoolFilterEchoFunction",
     "DictFilterEchoFunction",
     "DisjointRangePartitionedFunction",
     "DoubleSequenceFunction",

{vgi_python-0.36.1 → vgi_python-0.37.0}/vgi/_test_fixtures/table/filters.py

@@ -191,6 +191,129 @@ class FilterEchoFunction(TableFunctionGenerator[FilterEchoFunctionArgs, FilterEc
         state.remaining -= size
 
 
+# ============================================================================
+# BoolFilterEchoFunction — a table function with a BOOLEAN column, so the
+# bare-column predicate shapes (`WHERE flag`, `WHERE NOT flag`) can be driven
+# end to end.
+#
+# filter_echo cannot cover these: its schema has no boolean column, so the
+# predicate cannot even be written. The table-in-out `echo` path cannot either
+# — DuckDB does not hand it a bare boolean column as a pushed predicate, so a
+# test written there passes whether or not the worker can decode one. It takes
+# a TABLE FUNCTION with a boolean column to see the shape at all, which is why
+# a decoder that refused every one of them ("predicate root must resolve to
+# BOOLEAN", vgi-python < 0.36.2) went unnoticed by a filter-pushdown suite of
+# 348 files including one dedicated to booleans.
+#
+# `pushed_filters` echoes the SQL rendering, so this covers both halves: the
+# decode (the rows are auto-applied and must be right) and `to_sql()` (a shape
+# that parses but renders nothing would show up here as "(none)").
+# ============================================================================
+
+
+@dataclass(slots=True, frozen=True)
+class _BoolFilterEchoArgs:
+    """Arguments for BoolFilterEchoFunction."""
+
+    count: Annotated[int, Arg(0, doc="Number of rows to generate", ge=0)]
+
+
+@dataclass(kw_only=True)
+class _BoolFilterEchoState(ArrowSerializableDataclass):
+    """Remaining rows plus the echoed SQL rendering of the pushed filters."""
+
+    remaining: int
+    current_index: int = 0
+    filter_str: str = "(none)"
+
+
+@init_single_worker
+@bind_fixed_schema
+@_cardinality_from_count
+class BoolFilterEchoFunction(TableFunctionGenerator[_BoolFilterEchoArgs, _BoolFilterEchoState]):
+    """Rows with a nullable BOOLEAN column, echoing the pushed-down filters.
+
+    SCHEMA
+    ------
+    Output: {"n": int64, "flag": bool, "pushed_filters": string}
+
+    ``flag`` cycles TRUE, FALSE, NULL so every predicate is exercised against
+    all three truth values -- the NULL row is what distinguishes ``WHERE flag``
+    from ``WHERE flag IS NOT FALSE``, and ``WHERE NOT flag`` from
+    ``WHERE flag IS NOT TRUE``.
+
+    Attributes:
+        FIXED_SCHEMA: The fixed Arrow output schema this function always produces.
+
+    """
+
+    class Meta:
+        """Metadata for BoolFilterEchoFunction."""
+
+        name = "bool_filter_echo"
+        description = "Rows with a nullable BOOLEAN column, echoing pushed-down filters"
+        categories = ["generator", "diagnostic"]
+        filter_pushdown = True
+        auto_apply_filters = True
+        projection_pushdown = True
+        examples = [
+            FunctionExample(
+                sql="SELECT * FROM bool_filter_echo(6) WHERE flag",
+                description="A boolean column is a predicate on its own",
+            ),
+        ]
+
+    FIXED_SCHEMA: ClassVar[pa.Schema] = schema({"n": pa.int64(), "flag": pa.bool_(), "pushed_filters": pa.utf8()})
+
+    @classmethod
+    def initial_state(cls, params: ProcessParams[_BoolFilterEchoArgs]) -> _BoolFilterEchoState:
+        """Create initial state, caching the SQL rendering of the pushed filters."""
+        assert params.init_call is not None
+        pf = params.init_call.pushdown_filters
+        filters = (
+            cls.pushdown_filters(
+                pf,
+                join_keys=params.init_call.join_keys,
+                output_schema=params.init_call.output_schema,
+            )
+            if pf is not None
+            else None
+        )
+        return _BoolFilterEchoState(
+            remaining=params.args.count,
+            filter_str=_format_pushed_filters(filters),
+        )
+
+    @classmethod
+    def process(
+        cls,
+        params: ProcessParams[_BoolFilterEchoArgs],
+        state: _BoolFilterEchoState,
+        out: OutputCollector,
+    ) -> None:
+        """Emit rows whose ``flag`` cycles TRUE, FALSE, NULL."""
+        if state.remaining <= 0:
+            out.finish()
+            return
+
+        n_values = list(range(state.current_index, state.current_index + state.remaining))
+        flags: list[bool | None] = [(True, False, None)[i % 3] for i in n_values]
+
+        out.emit(
+            pa.RecordBatch.from_pydict(
+                {
+                    "n": n_values,
+                    "flag": flags,
+                    "pushed_filters": [state.filter_str] * len(n_values),
+                },
+                schema=params.output_schema,
+            )
+        )
+
+        state.current_index += state.remaining
+        state.remaining = 0
+
+
 # ============================================================================
 # ValuePruneFunction — exercises PushdownFilters.get_column_values('n'), the
 # partition-pruning idiom (resolve the discrete value set up front, fetch only

{vgi_python-0.36.1 → vgi_python-0.37.0}/vgi/_test_fixtures/worker.py

@@ -140,6 +140,7 @@ from vgi._test_fixtures.table import (
     RFF_SIMPLE_COLUMNS,
     RFF_STRUCT_COLUMNS,
     BatchIndexOverflowFunction,
+    BoolFilterEchoFunction,
     BrokenMissingPartitionValuesFunction,
     BrokenPartitionColumnAbsentFromBatchFunction,
     BrokenPartitionMinNeqMaxFunction,
@@ -486,6 +487,7 @@ _EXAMPLE_CATALOG = Catalog(
                 # TableFunctionGenerator - generate output without input
                 ConstantColumnsFunction,
                 SlowCancellableFunction,
+                BoolFilterEchoFunction,
                 FilterEchoFunction,
                 FilterEchoPartitionedFunction,
                 FilterEchoTableScanFunction,

{vgi_python-0.36.1 → vgi_python-0.37.0}/vgi/auth.py

@@ -9,8 +9,8 @@ HTTP auth factories (require ``vgi[http]``):
     bearer_authenticate, bearer_authenticate_static, chain_authenticate,
     OAuthResourceMetadata, AuthUnavailableError
 
-Token introspection (always available):
-    TokenIdentity, TokenResolver
+Token introspection and delegation (always available):
+    TokenIdentity, TokenResolver, IssuedGrant, GrantMinter
 
 JWT auth (requires ``vgi[oauth]``):
     jwt_authenticate
@@ -30,16 +30,25 @@ from vgi_rpc.rpc import AuthContext, CallContext
 # 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
+from vgi_rpc.rpc._token_identity import IssuedGrant, 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"]
 
+#: What :meth:`vgi.worker.Worker.mint_grant` is: ``(principal, purpose, scopes,
+#: ttl_seconds) -> IssuedGrant``.  The subject is a *parameter of the call the
+#: framework makes*, never of the wire method — ``issue_grant`` has no subject
+#: field, so a worker is handed the caller's own principal and cannot be asked
+#: to mint for anybody else.
+GrantMinter = Callable[[str, str, list[str], int], "IssuedGrant"]
+
 __all__ = [
     "AuthContext",
     "CallContext",
+    "GrantMinter",
+    "IssuedGrant",
     "TokenIdentity",
     "TokenResolver",
 ]

{vgi_python-0.36.1 → vgi_python-0.37.0}/vgi/filter_v2.py

@@ -740,11 +740,24 @@ class _Parser:
 
     @staticmethod
     def _is_boolean(expression: FilterExpression) -> bool:
-        if isinstance(expression, Literal):
-            return pa.types.is_boolean(expression.field.type)
-        if isinstance(expression, (Comparison, BooleanExpression, Not, IsNull, In, RuntimeFilter)):
-            return True
-        return isinstance(expression, Call)
+        """Whether *expression* resolves to BOOLEAN.
+
+        Ask the type, never the node kind. The two agree for every node whose
+        type is structurally fixed -- a comparison is BOOLEAN whatever its
+        operands -- and that is exactly why enumerating kinds looked sufficient.
+        It is not: ``column_ref``, ``field_ref``, ``cast`` and ``arithmetic``
+        are BOOLEAN or not depending on a type resolved from elsewhere (the
+        bind output schema, or a parent expression), and the schema admits all
+        four as a predicate root -- ``coreExpression`` lists ``columnRef``
+        first. Enumerating kinds rejected the lot, so the idiomatic
+        ``WHERE flag`` / ``WHERE NOT flag`` -- which DuckDB pushes down as a
+        bare column reference rather than rewriting to ``flag = true`` -- was
+        refused as "predicate root must resolve to BOOLEAN" even though the
+        parser had already resolved the column to BOOLEAN and stored it on the
+        node.
+        """
+        data_type = expression_type(expression)
+        return data_type is not None and pa.types.is_boolean(data_type)
 
     def _payload(self, prefix: str, ref: object) -> tuple[pa.Field[Any], pa.Scalar[Any]]:
         index = _uint(ref, f"{prefix}_ref")