vgi-python 0.13.0__tar.gz → 0.14.0__tar.gz

{vgi_python-0.13.0 → vgi_python-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vgi-python
-Version: 0.13.0
+Version: 0.14.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: httpx>=0.24
 Requires-Dist: platformdirs
 Requires-Dist: pyarrow
 Requires-Dist: typer>=0.9
-Requires-Dist: vgi-rpc>=0.23.0
+Requires-Dist: vgi-rpc>=0.24.0
 Provides-Extra: azure
 Requires-Dist: azure-identity>=1.16.0; extra == 'azure'
 Requires-Dist: pymssql>=2.3.0; extra == 'azure'

{vgi_python-0.13.0 → vgi_python-0.14.0}/ci/run-integration.sh

@@ -73,6 +73,11 @@ if [ "$TRANSPORT" = "http" ]; then
   #   * buffer_input/sizes.test — input buffering semantics differ over HTTP
   #     (same known limitation). (scale.test_slow is a .test_slow file and is
   #     never staged below, which only finds *.test.)
+  # cache/revalidate.test now runs on http too: HTTP conditional revalidation is
+  # implemented (C++ /init-request validators + vgi-rpc >=0.24.0 surfacing them to
+  # the producer's first process()). It needs a community vgi extension carrying
+  # that C++ change; if the http lane fails on it, the community extension predates
+  # the change and needs republishing.
   EXTRA_SKIP=(
     -not -name 'projection_pushdown_repro.test'
     -not -name 'dynamic_filter.test'

{vgi_python-0.13.0 → vgi_python-0.14.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "vgi-python"
-version = "0.13.0"
+version = "0.14.0"
 description = "Vector Gateway Interface - Connect DuckDB to external programs via Apache Arrow"
 readme = "README.md"
 keywords = [
@@ -40,7 +40,7 @@ dependencies = [
     "pyarrow",
     "typer>=0.9",
     "platformdirs",
-    "vgi-rpc>=0.23.0",
+    "vgi-rpc>=0.24.0",
     "httpx>=0.24",
 ]
 

{vgi_python-0.13.0 → vgi_python-0.14.0}/tests/conformance/test_directory_parity.py

@@ -33,6 +33,15 @@ _EXEMPTIONS: dict[str, str] = {
         "lifecycle/schema/table surfaces are mirrored by test_attach.py, "
         "test_table.py, test_view.py, and test_macro.py."
     ),
+    "cache": (
+        "The table-function result cache lives entirely in the C++ extension "
+        "(key/eligibility, in-memory + content-addressed disk tiers, serve/"
+        "capture, conditional revalidation). The Python worker's only role is "
+        "advertising vgi.cache.* metadata + answering 304 not_modified, which is "
+        "unit-tested by tests/test_cache_control.py (rendering, the emit merge "
+        "path, ProcessParams.if_none_match threading, and the revalidatable "
+        "fixture's 304 behavior)."
+    ),
     "filter_pushdown": (
         "Per-type filter-pushdown coverage is mirrored by tests/test_filter_pushdown.py "
         "and tests/test_filter_pushdown_extension.py, which drive the same predicate "

{vgi_python-0.13.0 → vgi_python-0.14.0}/tests/landing/describe.expected.json

@@ -3,9 +3,9 @@
     {
       "attach_options": [],
       "counts": {
-        "functions": 165,
+        "functions": 183,
         "schemas": 2,
-        "tables": 44,
+        "tables": 58,
         "views": 3
       },
       "data_version_spec": null,
@@ -18,6 +18,76 @@
           "functions": [],
           "name": "data",
           "tables": [
+            {
+              "cols": 1,
+              "comment": "Large multi-batch cacheable result (advertises vgi.cache.ttl)",
+              "name": "cache_big"
+            },
+            {
+              "cols": 1,
+              "comment": "Cacheable first batch then an unresolvable external-location pointer",
+              "name": "cache_external_fail"
+            },
+            {
+              "cols": 1,
+              "comment": "Cacheable sequence with static filter pushdown (filter_bytes keying)",
+              "name": "cache_filtered"
+            },
+            {
+              "cols": 3,
+              "comment": "Multi-column cacheable result (projection-coverage reuse)",
+              "name": "cache_multicol"
+            },
+            {
+              "cols": 1,
+              "comment": "Advertises vgi.cache.no_store — must never be cached",
+              "name": "cache_no_store"
+            },
+            {
+              "cols": 1,
+              "comment": "One-row cacheable result whose value changes per real invocation",
+              "name": "cache_nonce"
+            },
+            {
+              "cols": 1,
+              "comment": "Multi-worker order-sensitive cacheable result (batch_index; parallel capture, ordered serve)",
+              "name": "cache_ordered"
+            },
+            {
+              "cols": 1,
+              "comment": "Cacheable first batch then a mid-stream error (never-partial check)",
+              "name": "cache_poison"
+            },
+            {
+              "cols": 3,
+              "comment": "Projection-pushdown cacheable result (SELECT a vs b are distinct keys)",
+              "name": "cache_projection"
+            },
+            {
+              "cols": 1,
+              "comment": "Always-revalidate result (304 not_modified reuses stored bytes)",
+              "name": "cache_revalidatable"
+            },
+            {
+              "cols": 2,
+              "comment": "Advertises vgi.cache.scope=transaction",
+              "name": "cache_scoped_txn"
+            },
+            {
+              "cols": 1,
+              "comment": "Version-specific cacheable rows (AT-keyed cache isolation)",
+              "name": "cache_versioned"
+            },
+            {
+              "cols": 1,
+              "comment": "Cacheable result echoing the caller's auth principal (identity-scoped)",
+              "name": "cache_whoami"
+            },
+            {
+              "cols": 1,
+              "comment": "Cacheable 10-row result advertising vgi.cache.ttl",
+              "name": "cacheable_numbers"
+            },
             {
               "cols": 1,
               "comment": "Function-backed table with inlined cardinality (10000 rows)",
@@ -1256,6 +1326,226 @@
               "name": "broken_partition_values_no_annotation",
               "type": "table"
             },
+            {
+              "args": [
+                {
+                  "desc": "Number of rows to generate",
+                  "name": "rows",
+                  "type": "int64"
+                }
+              ],
+              "doc": "Emits `rows` int64 rows (positional arg); cacheable — scaling bench fixture",
+              "name": "cache_bench",
+              "type": "table"
+            },
+            {
+              "args": [
+                {
+                  "default": "5000",
+                  "desc": "Number of rows to generate",
+                  "name": "rows",
+                  "named": true,
+                  "type": "int64"
+                }
+              ],
+              "doc": "Emits many small batches totaling `rows` rows; cacheable",
+              "name": "cache_big",
+              "type": "table"
+            },
+            {
+              "args": [],
+              "doc": "Cacheable first batch then an unresolvable external-location pointer",
+              "name": "cache_external_fail",
+              "type": "table"
+            },
+            {
+              "args": [
+                {
+                  "default": "100",
+                  "desc": "Total number of rows to generate",
+                  "name": "rows",
+                  "named": true,
+                  "type": "int64"
+                }
+              ],
+              "doc": "Cacheable sequence with static filter pushdown (filter_bytes keying)",
+              "name": "cache_filtered",
+              "type": "table"
+            },
+            {
+              "args": [
+                {
+                  "desc": "Total number of rows to generate",
+                  "name": "rows",
+                  "type": "int64"
+                },
+                {
+                  "default": "20000",
+                  "desc": "Rows per partition",
+                  "name": "chunk_size",
+                  "named": true,
+                  "type": "int64"
+                }
+              ],
+              "doc": "Parallel batch_index-tagged cacheable sequence; cache serve reassembles order",
+              "name": "cache_interleaved",
+              "type": "table"
+            },
+            {
+              "args": [
+                {
+                  "default": "10",
+                  "desc": "Number of rows to generate",
+                  "name": "n",
+                  "named": true,
+                  "type": "int64"
+                }
+              ],
+              "doc": "Emits n rows but advertises no_store (never cached)",
+              "name": "cache_no_store",
+              "type": "table"
+            },
+            {
+              "args": [],
+              "doc": "Emits one row with a per-invocation nonce; cacheable",
+              "name": "cache_nonce",
+              "type": "table"
+            },
+            {
+              "args": [
+                {
+                  "default": "1000",
+                  "desc": "Rows per partition",
+                  "name": "chunk_size",
+                  "named": true,
+                  "type": "int64"
+                },
+                {
+                  "default": "200000",
+                  "desc": "Total number of rows to generate",
+                  "name": "rows",
+                  "named": true,
+                  "type": "int64"
+                }
+              ],
+              "doc": "Multi-worker order-sensitive cacheable sequence (batch_index); order-preservation cache fixture",
+              "name": "cache_ordered",
+              "type": "table"
+            },
+            {
+              "args": [
+                {
+                  "desc": "Total number of rows to generate",
+                  "name": "rows",
+                  "type": "int64"
+                },
+                {
+                  "default": "24000",
+                  "desc": "Rows per output batch",
+                  "name": "batch_size",
+                  "named": true,
+                  "type": "int64"
+                }
+              ],
+              "doc": "Multi-worker cacheable sequence (one substream per worker); parallel-capture fixture",
+              "name": "cache_parallel",
+              "type": "table"
+            },
+            {
+              "args": [
+                {
+                  "desc": "Rows per country partition",
+                  "name": "rows_per_country",
+                  "type": "int64"
+                }
+              ],
+              "doc": "Cacheable single-value-partitioned result (partition_values through the spill blob)",
+              "name": "cache_partitioned",
+              "type": "table"
+            },
+            {
+              "args": [],
+              "doc": "Cacheable first batch then a mid-stream error (never-partial check)",
+              "name": "cache_poison",
+              "type": "table"
+            },
+            {
+              "args": [],
+              "doc": "3-column projection-pushdown generator; cacheable",
+              "name": "cache_projection",
+              "type": "table"
+            },
+            {
+              "args": [],
+              "doc": "Emits one nonce row; always-revalidate (304 not_modified)",
+              "name": "cache_revalidatable",
+              "type": "table"
+            },
+            {
+              "args": [
+                {
+                  "default": "10",
+                  "desc": "Number of rows to generate",
+                  "name": "n",
+                  "named": true,
+                  "type": "int64"
+                }
+              ],
+              "doc": "Emits n rows and advertises scope=transaction",
+              "name": "cache_scoped_txn",
+              "type": "table"
+            },
+            {
+              "args": [
+                {
+                  "desc": "Total number of rows to generate",
+                  "name": "rows",
+                  "type": "int64"
+                }
+              ],
+              "doc": "Nested/wide/NULL cacheable result (STRUCT/LIST/DECIMAL/TIMESTAMP + NULLs)",
+              "name": "cache_types",
+              "type": "table"
+            },
+            {
+              "args": [
+                {
+                  "desc": "Data version, resolved from the AT clause by the catalog",
+                  "name": "version",
+                  "type": "int64"
+                }
+              ],
+              "doc": "Version-specific rows; cacheable (AT-keyed)",
+              "name": "cache_versioned_scan",
+              "type": "table"
+            },
+            {
+              "args": [],
+              "doc": "Emits the caller's auth principal; cacheable (identity-scoped)",
+              "name": "cache_whoami",
+              "type": "table"
+            },
+            {
+              "args": [
+                {
+                  "default": "10",
+                  "desc": "Number of rows to generate",
+                  "name": "n",
+                  "named": true,
+                  "type": "int64"
+                },
+                {
+                  "default": "300",
+                  "desc": "Cache TTL in seconds",
+                  "name": "ttl",
+                  "named": true,
+                  "type": "int64"
+                }
+              ],
+              "doc": "Emits n rows [0..n) and advertises a cache TTL",
+              "name": "cacheable_numbers",
+              "type": "table"
+            },
             {
               "args": [],
               "doc": "Scan colors table (ENUM column)",

vgi_python-0.14.0/tests/test_cache_control.py

@@ -0,0 +1,222 @@
+# Copyright 2025, 2026 Query Farm LLC - https://query.farm
+
+"""Unit tests for CacheControl rendering and the _merge_cache_control emit path."""
+
+from __future__ import annotations
+
+import pyarrow as pa
+import pytest
+
+from vgi.cache_control import (
+    CACHE_ETAG_KEY,
+    CACHE_EXPIRES_KEY,
+    CACHE_LAST_MODIFIED_KEY,
+    CACHE_NO_STORE_KEY,
+    CACHE_REVALIDATABLE_KEY,
+    CACHE_SCOPE_CATALOG,
+    CACHE_SCOPE_KEY,
+    CACHE_SCOPE_TRANSACTION,
+    CACHE_STALE_IF_ERROR_KEY,
+    CACHE_STALE_WHILE_REVALIDATE_KEY,
+    CACHE_TTL_KEY,
+    CacheControl,
+)
+from vgi.protocol import _TrackingOutputCollector
+
+
+class _RecordingCollector:
+    """Minimal inner OutputCollector that records (batch, metadata) per emit."""
+
+    def __init__(self) -> None:
+        """Initialize the recorded-calls list."""
+        self.calls: list[tuple[pa.RecordBatch, dict[str, str] | None]] = []
+
+    def emit(self, batch: pa.RecordBatch, metadata: dict[str, str] | None = None) -> None:
+        """Record the emitted batch and its metadata."""
+        self.calls.append((batch, metadata))
+
+
+def _batch(value: int = 0) -> pa.RecordBatch:
+    """Build a one-row single-column batch for emit testing."""
+    return pa.RecordBatch.from_pydict({"n": [value]})
+
+
+class TestCacheControlRendering:
+    """CacheControl.to_metadata() renders the vgi.cache.* key/value dict."""
+
+    def test_ttl_only(self) -> None:
+        """ttl-only advertisement renders ttl + the always-present scope."""
+        md = CacheControl(ttl=300).to_metadata()
+        assert md[CACHE_TTL_KEY] == "300"
+        # scope is always emitted so the client never infers the default.
+        assert md[CACHE_SCOPE_KEY] == CACHE_SCOPE_CATALOG
+        # Nothing else set.
+        assert set(md) == {CACHE_TTL_KEY, CACHE_SCOPE_KEY}
+
+    def test_all_fields(self) -> None:
+        """Every field renders to its documented vgi.cache.* key."""
+        md = CacheControl(
+            ttl=60,
+            expires="2026-01-01T00:00:00Z",
+            scope=CACHE_SCOPE_TRANSACTION,
+            etag='"abc"',
+            last_modified="2025-12-31T00:00:00Z",
+            revalidatable=True,
+            stale_while_revalidate=10,
+            stale_if_error=20,
+        ).to_metadata()
+        assert md == {
+            CACHE_TTL_KEY: "60",
+            CACHE_EXPIRES_KEY: "2026-01-01T00:00:00Z",
+            CACHE_SCOPE_KEY: CACHE_SCOPE_TRANSACTION,
+            CACHE_ETAG_KEY: '"abc"',
+            CACHE_LAST_MODIFIED_KEY: "2025-12-31T00:00:00Z",
+            CACHE_REVALIDATABLE_KEY: "1",
+            CACHE_STALE_WHILE_REVALIDATE_KEY: "10",
+            CACHE_STALE_IF_ERROR_KEY: "20",
+        }
+
+    def test_no_store_renders_one_and_omits_when_false(self) -> None:
+        """no_store renders "1" when true and is omitted when false."""
+        assert CacheControl(no_store=True).to_metadata()[CACHE_NO_STORE_KEY] == "1"
+        assert CACHE_NO_STORE_KEY not in CacheControl(ttl=1).to_metadata()
+
+    def test_booleans_omitted_when_false(self) -> None:
+        """Boolean fields left false do not emit any key."""
+        md = CacheControl(ttl=1).to_metadata()
+        assert CACHE_REVALIDATABLE_KEY not in md
+        assert CACHE_NO_STORE_KEY not in md
+
+    def test_invalid_scope_rejected(self) -> None:
+        """An unknown scope value is rejected at construction."""
+        with pytest.raises(ValueError, match="scope"):
+            CacheControl(scope="bogus")
+
+    def test_negative_duration_rejected(self) -> None:
+        """A negative duration field is rejected at construction."""
+        with pytest.raises(ValueError, match="ttl"):
+            CacheControl(ttl=-1)
+
+    def test_not_modified_renders_one_and_omits_when_false(self) -> None:
+        """not_modified renders "1" when true (a 304) and is omitted when false."""
+        from vgi.cache_control import CACHE_NOT_MODIFIED_KEY
+
+        md = CacheControl(not_modified=True, ttl=0, etag='"v1"', revalidatable=True).to_metadata()
+        assert md[CACHE_NOT_MODIFIED_KEY] == "1"
+        assert CACHE_NOT_MODIFIED_KEY not in CacheControl(ttl=1).to_metadata()
+
+
+class TestMergeCacheControlEmitPath:
+    """_TrackingOutputCollector folds CacheControl onto the FIRST emitted batch."""
+
+    def test_first_batch_carries_keys(self) -> None:
+        """The first emitted batch carries the rendered vgi.cache.* keys."""
+        inner = _RecordingCollector()
+        out = _TrackingOutputCollector(inner)  # type: ignore[arg-type]
+        out.emit(_batch(0), cache_control=CacheControl(ttl=300))
+
+        (_, metadata) = inner.calls[0]
+        assert metadata is not None
+        assert metadata[CACHE_TTL_KEY] == "300"
+        assert metadata[CACHE_SCOPE_KEY] == CACHE_SCOPE_CATALOG
+
+    def test_subsequent_batches_get_no_cache_keys(self) -> None:
+        """Only the first batch carries cache keys; later batches carry none."""
+        inner = _RecordingCollector()
+        out = _TrackingOutputCollector(inner)  # type: ignore[arg-type]
+        out.emit(_batch(0), cache_control=CacheControl(ttl=300))
+        out.emit(_batch(1))
+        out.emit(_batch(2))
+
+        # First batch carries keys; later batches carry no metadata at all
+        # (so no duplicated/conflicting vgi.cache.* keys downstream).
+        assert inner.calls[0][1] is not None
+        assert inner.calls[0][1][CACHE_TTL_KEY] == "300"
+        assert inner.calls[1][1] is None
+        assert inner.calls[2][1] is None
+
+    def test_cache_control_on_later_batch_raises(self) -> None:
+        """Passing cache_control after the first batch is a programming error."""
+        inner = _RecordingCollector()
+        out = _TrackingOutputCollector(inner)  # type: ignore[arg-type]
+        out.emit(_batch(0))
+        with pytest.raises(RuntimeError, match="first emitted batch"):
+            out.emit(_batch(1), cache_control=CacheControl(ttl=300))
+
+    def test_no_cache_control_leaves_metadata_untouched(self) -> None:
+        """Without cache_control the emitted metadata stays None."""
+        inner = _RecordingCollector()
+        out = _TrackingOutputCollector(inner)  # type: ignore[arg-type]
+        out.emit(_batch(0))
+        assert inner.calls[0][1] is None
+
+    def test_explicit_metadata_preserved_alongside_cache_control(self) -> None:
+        """Explicit metadata keys survive alongside the cache_control keys."""
+        inner = _RecordingCollector()
+        out = _TrackingOutputCollector(inner)  # type: ignore[arg-type]
+        out.emit(_batch(0), metadata={"custom.key": "v"}, cache_control=CacheControl(ttl=5))
+
+        (_, metadata) = inner.calls[0]
+        assert metadata is not None
+        assert metadata["custom.key"] == "v"
+        assert metadata[CACHE_TTL_KEY] == "5"
+
+    def test_no_store_flows_through_emit(self) -> None:
+        """A no_store advertisement reaches the emitted batch metadata."""
+        inner = _RecordingCollector()
+        out = _TrackingOutputCollector(inner)  # type: ignore[arg-type]
+        out.emit(_batch(0), cache_control=CacheControl(no_store=True))
+
+        (_, metadata) = inner.calls[0]
+        assert metadata is not None
+        assert metadata[CACHE_NO_STORE_KEY] == "1"
+
+
+class TestRevalidatableFixture:
+    """CacheRevalidatableFunction answers 304 when if_none_match matches (M6)."""
+
+    @staticmethod
+    def _run(if_none_match: str | None):
+        """Drive the fixture's process() with a duck-typed params stub."""
+        import types
+
+        from vgi._test_fixtures.table.cache import (
+            CacheRevalidatableFunction,
+            _CacheNonceState,
+        )
+        from vgi.cache_control import CACHE_NOT_MODIFIED_KEY
+
+        inner = _RecordingCollector()
+        # The fixture emits via VgiOutputCollector.emit(..., cache_control=...);
+        # _TrackingOutputCollector folds cache_control into the recorded metadata.
+        out = _TrackingOutputCollector(inner)  # type: ignore[arg-type]
+        params = types.SimpleNamespace(
+            if_none_match=if_none_match,
+            output_schema=CacheRevalidatableFunction.FIXED_SCHEMA,
+        )
+        state = _CacheNonceState(nonce=42)
+        CacheRevalidatableFunction.process(params, state, out)  # type: ignore[arg-type]
+        return inner, state, CACHE_NOT_MODIFIED_KEY
+
+    def test_matching_validator_yields_not_modified(self) -> None:
+        """A matching if_none_match yields a 0-row not_modified batch (no data)."""
+        from vgi._test_fixtures.table.cache import CacheRevalidatableFunction
+
+        collector, _state, not_modified_key = self._run(if_none_match=CacheRevalidatableFunction.ETAG)
+
+        assert len(collector.calls) == 1
+        batch, metadata = collector.calls[0]
+        assert batch.num_rows == 0  # 304: no data re-streamed
+        assert metadata is not None
+        assert metadata[not_modified_key] == "1"
+
+    def test_no_validator_yields_fresh_data(self) -> None:
+        """No conditional request → the fixture emits its nonce row (fresh)."""
+        collector, state, not_modified_key = self._run(if_none_match=None)
+
+        assert len(collector.calls) == 1
+        batch, metadata = collector.calls[0]
+        assert batch.num_rows == 1
+        assert batch.column(0)[0].as_py() == state.nonce
+        assert metadata is not None
+        assert not_modified_key not in metadata

{vgi_python-0.13.0 → vgi_python-0.14.0}/uv.lock

@@ -2228,7 +2228,7 @@ requires-dist = [
 
 [[package]]
 name = "vgi-python"
-version = "0.13.0"
+version = "0.14.0"
 source = { editable = "." }
 dependencies = [
     { name = "click" },
@@ -2338,7 +2338,7 @@ requires-dist = [
     { name = "vgi-python", extras = ["test-fixtures"], marker = "extra == 'test-fixtures-writable'" },
     { name = "vgi-python", extras = ["test-fixtures", "test-fixtures-writable", "http", "oauth", "otel", "sentry", "azure"], marker = "extra == 'dev'" },
     { name = "vgi-python", extras = ["transactor"], marker = "extra == 'test-fixtures-writable'" },
-    { name = "vgi-rpc", specifier = ">=0.23.0" },
+    { name = "vgi-rpc", specifier = ">=0.24.0" },
     { name = "vgi-rpc", extras = ["conformance", "external", "http", "oauth", "otel", "sentry"], marker = "extra == 'dev'" },
     { name = "vgi-rpc", extras = ["http"], marker = "extra == 'http'" },
     { name = "vgi-rpc", extras = ["oauth"], marker = "extra == 'oauth'" },
@@ -2367,7 +2367,7 @@ docs = [
 
 [[package]]
 name = "vgi-rpc"
-version = "0.23.0"
+version = "0.24.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "docstring-parser" },
@@ -2375,9 +2375,9 @@ dependencies = [
     { name = "pywin32", marker = "sys_platform == 'win32'" },
     { name = "tzdata", marker = "sys_platform == 'win32'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ac/82/e1d8391c64ebc0f7f928f49837608c1ff50b5398cfd674aed3552d3f51d5/vgi_rpc-0.23.0.tar.gz", hash = "sha256:5874c73ddb36d2305432696a97339735ef150b095bbddabe417d7406ff026a6b", size = 860239, upload-time = "2026-07-07T22:25:32.584Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/63/53/d24648965748f26008dd71495e0330f536ce69f9ddffac431df25bbd3f78/vgi_rpc-0.24.0.tar.gz", hash = "sha256:dac1fd161c04a473f6c4309e94d18f22c8b1476d140be9a789ed710cf6339956", size = 860740, upload-time = "2026-07-09T21:35:44.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/74/34/1c50fe244b7cfc8774957064d76c9d72f866e320754dc24cfc71ce87b3f1/vgi_rpc-0.23.0-py3-none-any.whl", hash = "sha256:9095a4962172459489d4d65d6398b3ccfe17f4b868ad5fed2740099d4003d66c", size = 379578, upload-time = "2026-07-07T22:25:31.059Z" },
+    { url = "https://files.pythonhosted.org/packages/13/1c/04654c95249e936bd027bb58abd0a36b3989c28b1e7aba891e9651eb0323/vgi_rpc-0.24.0-py3-none-any.whl", hash = "sha256:46caf719bc27b156cd30115c790e00c3ad67f3238ed51a7dc7dbe4dffe794391", size = 380110, upload-time = "2026-07-09T21:35:42.65Z" },
 ]
 
 [package.optional-dependencies]

{vgi_python-0.13.0 → vgi_python-0.14.0}/vgi/_test_fixtures/http_server.py

@@ -304,6 +304,32 @@ def main() -> None:
         authenticate = _resolve_authenticate()
         oauth_metadata = _resolve_oauth_resource_metadata()
 
+        if authenticate is None:
+            # Test-only OPTIONAL bearer auth. Lets the cache identity-isolation
+            # test attach the same worker under different principals (alice/bob)
+            # while every other test on this shared server stays anonymous:
+            # no/blank/unknown bearer → anonymous (existing behaviour), a known
+            # token → its principal. Never 401s, so no anonymous test breaks.
+            from vgi_rpc.http import bearer_authenticate_static
+            from vgi_rpc.rpc import AuthContext
+
+            _test_tokens = {
+                "vgi-test-alice": AuthContext(principal="alice", authenticated=True, domain="bearer"),
+                "vgi-test-bob": AuthContext(principal="bob", authenticated=True, domain="bearer"),
+            }
+            _bearer_validate = bearer_authenticate_static(tokens=_test_tokens)
+
+            def _optional_bearer(req: Any) -> AuthContext:
+                header = req.get_header("Authorization") or ""
+                if not header.startswith("Bearer "):
+                    return AuthContext.anonymous()
+                try:
+                    return _bearer_validate(req)
+                except Exception:
+                    return AuthContext.anonymous()
+
+            authenticate = _optional_bearer
+
         from vgi.worker import _get_vgi_version
 
         # Match vgi-fixture-worker (subprocess transport): always serve the