vgi-python 0.36.2__py3-none-any.whl → 0.37.0__py3-none-any.whl

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/serve.py

@@ -791,9 +791,12 @@ def _build_identity(
 ) -> 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 —
+    ``None`` unless the worker class implements at least one of the two
+    methods, and that is the point: ``RpcServer`` then does not host the
+    protocol at all, rather than hosting it and refusing every call. The two
+    are independent — a worker may resolve credentials without minting them,
+    mint without resolving, or do both, and ``offered_methods()`` reports
+    exactly what it wrote. Absent beats routed-and-refusing —
     it is what keeps a dependency upgrade from growing a
     credential-to-identity oracle on every existing worker.
 
@@ -804,8 +807,8 @@ def _build_identity(
     calling and reading an error.
 
     Args:
-        worker_cls: The worker class, consulted for a ``resolve_token``
-            override.
+        worker_cls: The worker class, consulted for ``resolve_token`` and
+            ``mint_grant`` overrides.
         introspect_principals: Principals permitted to introspect, or ``None``
             to read the environment.
 
@@ -815,7 +818,8 @@ def _build_identity(
 
     """
     resolver = worker_cls._introspect_resolver()
-    if resolver is None:
+    minter = worker_cls._grant_minter()
+    if resolver is None and minter is None:
         return None
 
     # Not re-exported by ``vgi_rpc.rpc``, so the private module is the only
@@ -824,7 +828,11 @@ def _build_identity(
 
     return IdentityImpl(
         resolve_token=resolver,
-        introspect_principals=_resolve_introspect_principals(introspect_principals),
+        mint_grant=minter,
+        # Only meaningful for ``introspect_token``, and ``IdentityImpl``
+        # validates it only when a resolver is supplied — a worker that mints
+        # grants but resolves nothing is not an oracle and needs no allowlist.
+        introspect_principals=(_resolve_introspect_principals(introspect_principals) if resolver is not None else None),
     )
 
 

vgi/worker.py

@@ -173,7 +173,7 @@ if TYPE_CHECKING:
     from ssl import SSLContext
 
     from vgi_rpc.rpc import PeerAuthenticationPolicy, PeerIdentityProvider
-    from vgi_rpc.rpc._token_identity import TokenIdentity
+    from vgi_rpc.rpc._token_identity import IssuedGrant, TokenIdentity
 
     from vgi.catalog.descriptors import Catalog
     from vgi.protocol import (
@@ -1478,6 +1478,80 @@ class Worker:
             return None
         return cls.resolve_token
 
+    @classmethod
+    def mint_grant(cls, principal: str, purpose: str, scopes: list[str], ttl_seconds: int) -> IssuedGrant:
+        """Mint a standing delegation credential for *principal*.
+
+        Override to host ``vgi_rpc.Identity.v1``'s ``issue_grant``. Like
+        ``resolve_token``, the method is absent until it is overridden rather
+        than hosted-and-refusing, so no worker grows a credential *issuer* by
+        upgrading a dependency.
+
+        OAuth cannot express durable delegation: it fuses the grant, the
+        credential and the session into one refresh token, so an IdP shortening
+        session lifetime shortens the grant. This mints the durable record —
+        created while the user is present, presented later by unattended
+        automation as an ordinary bearer.
+
+        **There is no subject on the wire.** ``issue_grant`` takes no subject
+        field; the framework passes the *caller's own* authenticated principal,
+        so cross-subject minting is closed by construction rather than by a
+        check that could be forgotten. That is also why this needs no allowlist
+        while ``introspect_token`` has one — it is not an oracle about anybody
+        else. The framework additionally refuses a caller whose authentication
+        is stale (``max_auth_age``, 15 minutes by default), because "minted
+        while the user is present" is the property that makes a grant
+        accountable to them.
+
+        ``IssuedGrant.token`` is **opaque to the framework** — a sealed
+        envelope, a database row, or a credential brokered from the IdP are all
+        equally valid and equally invisible here. It is never parsed and never
+        logged. Note that a self-contained sealed token cannot be revoked
+        individually: with no server-side record there is nothing to delete,
+        and rotating the sealing key invalidates every grant at once. If
+        per-grant revocation matters, the token has to name something the
+        worker can look up and remove.
+
+        Args:
+            principal: The caller's authenticated principal, in the form this
+                worker derives itself. Supplied by the framework, never by the
+                caller.
+            purpose: Free-text reason recorded with the grant, for the audit
+                trail.
+            scopes: Scopes the grant is limited to. A worker that ignores this
+                is issuing a credential broader than the caller asked for.
+            ttl_seconds: Lifetime the caller requested. A worker may issue a
+                shorter one — and should say so in ``expires_at`` — but must
+                never issue a longer one.
+
+        Returns:
+            The minted ``IssuedGrant``. ``expires_at`` is a declaration rather
+            than an enforcement: the real lifetime lives inside the opaque
+            token, so a worker that states one has thought about one.
+
+        Raises:
+            GrantRefusedError: When this caller may not mint this grant —
+                an unsupported scope, a ttl beyond policy, a principal the
+                worker declines to delegate for.
+
+        """
+        from vgi_rpc.rpc._token_identity import GrantRefusedError
+
+        raise GrantRefusedError("this worker does not mint grants")
+
+    @classmethod
+    def _grant_minter(cls) -> Callable[[str, str, list[str], int], IssuedGrant] | None:
+        """Return this worker's grant minter, or ``None`` when it has none.
+
+        Identity comparison against the base implementation, for the same
+        reason ``_introspect_resolver`` uses one: the method must be absent
+        unless a worker actually wrote the minting, and a "supports grants"
+        flag can be set without one.
+        """
+        if cls.mint_grant.__func__ is Worker.mint_grant.__func__:  # type: ignore[attr-defined]
+            return None
+        return cls.mint_grant
+
     @final
     @classmethod
     def main(cls) -> None:

{vgi_python-0.36.2.dist-info → vgi_python-0.37.0.dist-info}/METADATA

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

@@ -5,7 +5,7 @@ vgi/aggregate_function.py,sha256=NYxudbvQ9ZLkP2w5hRdd4YgsGUZ_0cVfqqXnlmJPfls,273
 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=m97hDDR8bXIQRBvqhHQZesBrNkAnKgSH6jhuXtGubjI,4688
+vgi/auth.py,sha256=qMhaLlQfn6F_ovMg4vwD8fl55THalWrSQ9A_V8arGDU,5195
 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
@@ -30,13 +30,13 @@ 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=5UmvRAGcHj5RKCOUQMXG9RFVYAbLZsHwwk1qVI9fipY,63844
+vgi/serve.py,sha256=DfHSp6B30v_EgWoswsqtmfQ4Fwz1PrnJqvUo1GwM2hA,64416
 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=4Qo4OAOLjTYQ5pinNTOjLCDnb96OHqpcxJlbSJo3cJU,67144
 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/worker.py,sha256=0ez46DE5tc1-78ll29lBP7KRKdDJnkOv89gdr4RjLrE,253453
 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
@@ -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.36.2.dist-info/METADATA,sha256=kwE2GNB9zbRBOopkbMvkpJoV6dW7sbz8p6f5CGUtU-s,25617
-vgi_python-0.36.2.dist-info/WHEEL,sha256=THafob7ofN-NsuMN7Mg4qZyHaQI7KkD-QlcQatYhXPo,87
-vgi_python-0.36.2.dist-info/entry_points.txt,sha256=3Kz1vgodw3pOL_xjtSyDB55-ZRy-U2X-X_Bdr582x0Q,165
-vgi_python-0.36.2.dist-info/licenses/LICENSE,sha256=pbJb4zZasP6n5ifEV81wFu017TarjydaYVmGbHcehtY,6103
-vgi_python-0.36.2.dist-info/RECORD,,
+vgi_python-0.37.0.dist-info/METADATA,sha256=aYu1DnoElkICwDeYXEoJ_qTIR962ftJnNxkqMvYet5Y,25617
+vgi_python-0.37.0.dist-info/WHEEL,sha256=THafob7ofN-NsuMN7Mg4qZyHaQI7KkD-QlcQatYhXPo,87
+vgi_python-0.37.0.dist-info/entry_points.txt,sha256=3Kz1vgodw3pOL_xjtSyDB55-ZRy-U2X-X_Bdr582x0Q,165
+vgi_python-0.37.0.dist-info/licenses/LICENSE,sha256=pbJb4zZasP6n5ifEV81wFu017TarjydaYVmGbHcehtY,6103
+vgi_python-0.37.0.dist-info/RECORD,,