chtypes 2.0.0.dev5__tar.gz → 2.0.0.dev6__tar.gz

{chtypes-2.0.0.dev5 → chtypes-2.0.0.dev6}/CHANGELOG.md

@@ -33,6 +33,17 @@ The four bindings in this repository are released together and give one answer,
 - **Enforcement gate lifted** for `26.7` on `darwin-arm64`.
 - **Enforcement gate lifted** for `26.8` on `darwin-arm64`.
 - **Enforcement gate lifted** for `26.9` on `darwin-arm64`.
+- **Enforcement gate restored** for `26.3` on `linux-amd64`.
+- **Enforcement gate restored** for `26.3` on `linux-arm64`.
+- **Enforcement gate restored** for `26.7` on `linux-amd64`.
+- **Enforcement gate restored** for `26.7` on `linux-arm64`.
+- **Enforcement gate restored** for `26.8` on `linux-amd64`.
+- **Enforcement gate restored** for `26.8` on `linux-arm64`.
+- **Enforcement gate restored** for `26.9` on `linux-amd64`.
+- **Enforcement gate restored** for `26.9` on `linux-arm64`.
+- **Enforcement gate restored** for `26.7` on `darwin-arm64`.
+- **Enforcement gate restored** for `26.8` on `darwin-arm64`.
+- **Enforcement gate restored** for `26.9` on `darwin-arm64`.
 
 ### Removed
 
@@ -42,6 +53,7 @@ The four bindings in this repository are released together and give one answer,
 
 - A 2.0.0-dev SDK whose own-fingerprint alias has expired, with a cached build of that fingerprint for the request, now says so in the `CHTYPES_ARTIFACT_UNPUBLISHED` message of `fetch` (#581): `; a cached build for this fingerprint (build <id>) is still usable by open; upgrade the SDK to get newer builds` is appended. The code, the exit status (4) and the cache are unchanged, and all four bindings give the same message (`fp-ahead-cached-own-fp`).
 - A 2.0.0-dev SDK whose fingerprint no published build carries yet now fails closed with a precise message (#578). When every base answers its own alias 404 and the tag names a build signed for another fingerprint, `fetch` is `CHTYPES_ARTIFACT_UNPUBLISHED` (exit status 4): `no published build for this SDK's fingerprint <own fp>; newest published on this channel is <fp> (build <id>)`. It used to install that build, or report it already installed, and the lookup at open then answered `CHTYPES_ARTIFACT_MISSING` with advice to run `fetch`: a loop with no pointer to the cause. Nothing is downloaded or installed and the cache is unchanged. An alias that answers, a tag at the SDK's own fingerprint and the v1 contract are unchanged. All four bindings run the same fetch conformance cases, `fp-ahead-*`, and the rule is `docs/guides/fetch-v1.md` section 3.
+- Opening a line no longer waits for another line's fetch: the registry never holds its lock across network I/O, and concurrent opens of one request share one fetch (#491).
 
 ## [1.1.0] — 2026-10-06
 

{chtypes-2.0.0.dev5 → chtypes-2.0.0.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: chtypes
-Version: 2.0.0.dev5
+Version: 2.0.0.dev6
 Summary: Python binding for the chtypes artifacts: ClickHouse's own type system, per version, behind the frozen chs_* C ABI
 Project-URL: Homepage, https://github.com/wave-rf/chtypes
 Project-URL: Repository, https://github.com/wave-rf/chtypes

{chtypes-2.0.0.dev5 → chtypes-2.0.0.dev6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "chtypes"
-version = "2.0.0.dev5"
+version = "2.0.0.dev6"
 description = "Python binding for the chtypes artifacts: ClickHouse's own type system, per version, behind the frozen chs_* C ABI"
 readme = "README.md"
 license = "Apache-2.0"

{chtypes-2.0.0.dev5 → chtypes-2.0.0.dev6}/src/chtypes/_ocifetch/_channel.py

@@ -79,6 +79,7 @@ __all__ = [
     "visible",
     "use_dev_channel_for_tests",
     "use_fetch_v1_for_tests",
+    "use_prod_v2_for_tests",
 ]
 
 # The dev channel's registry and key (spec/abi-v2/docs.md, rule r6).
@@ -165,6 +166,25 @@ FETCH_V1_CHANNEL: Final = Channel(
     pinnable=True,
 )
 
+# The production generation-2 channel a 2.0.0 SDK speaks after the lock: the v1
+# contract with v2 values, from the generated constants (docs/guides/fetch-v1.md,
+# "Generation 2 after the lock"). It trusts the release key, honors every
+# override and pin, and has no alias step. NOT the default: only
+# use_prod_v2_for_tests selects it, until the lock change makes it active()'s
+# fallback.
+PROD_V2_CHANNEL: Final = Channel(
+    name=C.PROD_V2_NAME,
+    abi=C.PROD_V2_ABI_GENERATION,
+    record_schema=C.PROD_V2_RECORD_SCHEMA,
+    root_leaf=C.PROD_V2_CACHE_DIR,
+    subroot=C.PROD_V2_CACHE_DIR,
+    system_dirs=C.PROD_V2_SYSTEM_DIRS,
+    bases=C.PROD_V2_BASES,
+    keys=C.RELEASE_KEYS,
+    overridable=True,
+    pinnable=True,
+)
+
 _lock = threading.Lock()
 _current: Channel | None = None
 
@@ -224,6 +244,14 @@ def use_fetch_v1_for_tests() -> Callable[[], None]:
     return _use(FETCH_V1_CHANNEL)
 
 
+def use_prod_v2_for_tests() -> Callable[[], None]:
+    """Make this TEST run speak the production generation-2 channel
+    (`PROD_V2_CHANNEL`): the v1 contract with abi 2, schema-2 records and the
+    `v2` subroot. Returns the restore function; raises outside a test run."""
+    _test_only("use_prod_v2_for_tests")
+    return _use(PROD_V2_CHANNEL)
+
+
 def allow_overrides_for_tests() -> Callable[[], None]:
     """Make this TEST run's dev channel honor the base, trust and unsigned
     overrides, so a test can reach a fixture registry signed with the test key;

{chtypes-2.0.0.dev5 → chtypes-2.0.0.dev6}/src/chtypes/_ocifetch/_constants.py

@@ -1,6 +1,6 @@
 # Code generated by scripts/fetch-v1/gen-constants.py from
 # spec/fetch-v1/constants.json. DO NOT EDIT.
-# Source sha256: 4554956faeb154fc324a6120b7b35976222c6bc8ecbce7fd0147502e3073611d
+# Source sha256: 82afa8d6cba96c10b5945c6f7c1c8360a504cc8ac6231e74017cc6c20b908df6
 """The v1 fetch constants, generated: see docs/guides/fetch-v1.md."""
 
 from __future__ import annotations
@@ -101,6 +101,12 @@ RETIRED_MESSAGE_MAX_CODE_POINTS: Final[int] = 256
 
 CACHE_ROOT_TEMPLATE: Final[str] = "${XDG_CACHE_HOME:-$HOME/.cache}/chtypes/v1"
 SYSTEM_CACHE_DIRS: Final[tuple[str, ...]] = ("/usr/local/share/chtypes/v1", "/opt/chtypes/v1")
+PROD_V2_NAME: Final[str] = "v2"
+PROD_V2_ABI_GENERATION: Final[int] = 2
+PROD_V2_RECORD_SCHEMA: Final[int] = 2
+PROD_V2_CACHE_DIR: Final[str] = "v2"
+PROD_V2_BASES: Final[tuple[str, ...]] = ("https://registry.wavehouse.dev/chtypes/v2",)
+PROD_V2_SYSTEM_DIRS: Final[tuple[str, ...]] = ("/usr/local/share/chtypes/v2", "/opt/chtypes/v2")
 CACHE_UNPACKED_DIR: Final[str] = "unpacked/sha256"
 CACHE_VERIFIED_RECORD: Final[str] = "verified.json"
 CACHE_ANNOTATION_PREFIX: Final[str] = "dev.wavehouse.chtypes."

{chtypes-2.0.0.dev5 → chtypes-2.0.0.dev6}/src/chtypes/registry.py

@@ -15,13 +15,19 @@ The sequence of `for_version(request)`:
 Construction opens nothing. The binding orders and matches no versions itself:
 which installed build a floating request means, and the spelling rules, are the
 fetch layer's.
+
+Opens of different requests never wait for each other's fetch (public issue
+#491): the registry's lock guards its memo and the attempts in progress, and is
+never held across steps 2 to 5. Concurrent opens of one request share one
+attempt, and so one fetch, and each gets that attempt's `Library` or its error;
+a failed attempt is never remembered, so the next open starts a new one.
 """
 
 from __future__ import annotations
 
 import os
 import threading
-from collections.abc import Sequence
+from collections.abc import Callable, Sequence
 from dataclasses import dataclass
 from pathlib import Path
 
@@ -168,6 +174,19 @@ def _wrap(exc: FetchError) -> errors.ArtifactError:
     return wrapped
 
 
+class _Flight:
+    """One attempt to open one request: the installed lookup, the fetch when
+    there is one, and the load. Every open of that request made while it is in
+    progress waits on it and gets its answer."""
+
+    __slots__ = ("done", "error", "library")
+
+    def __init__(self) -> None:
+        self.done = threading.Event()
+        self.library: Library | None = None
+        self.error: BaseException | None = None
+
+
 class Registry:
     """Opens versions. Safe across threads. `autofetch` defaults to
     `CHTYPES_AUTOFETCH`, and is off when that is unset.
@@ -175,6 +194,9 @@ class Registry:
     Construction opens nothing: only `for_version` and `preload` open an
     artifact. `preload` opens each listed request through the loader at
     construction, in list order, and never fetches, even with autofetch on.
+
+    An open never waits for another request's fetch, and concurrent opens of
+    one request share one fetch (public issue #491).
     """
 
     def __init__(
@@ -189,8 +211,14 @@ class Registry:
             env = os.environ.get(_fetch_constants.ENV_AUTOFETCH_NAME, "")
             autofetch = env.strip().lower() in _TRUTHY
         self._autofetch = autofetch
-        self._lock = threading.RLock()
+        # Guards the memo and the attempts in progress, never a lookup, a fetch
+        # or a load.
+        self._lock = threading.Lock()
         self._memo: dict[str, Library] = {}
+        self._flights: dict[str, _Flight] = {}
+        # A test hook, None outside tests: called each time an open starts
+        # waiting on an attempt, its own or another open's.
+        self._on_wait: Callable[[str], None] | None = None
         if isinstance(preload, str):
             raise TypeError("preload must be a sequence of requests, not a single string")
         for request in preload:
@@ -221,30 +249,63 @@ class Registry:
             return tuple(seen)
 
     def _open(self, request: str, *, allow_fetch: bool) -> Library:
+        with self._lock:
+            hit = self._memo.get(request)
+        if hit is not None:
+            return hit
+        # A refused version spelling is the caller's own misuse, refused before
+        # anything is attempted, and unlocks nothing.
+        try:
+            fetch_request = Request(request)
+        except ValueError as exc:
+            raise errors.misuse(str(exc)) from None
+        # So is a pinning request on the dev channel (rule r6).
+        _refuse_pinning(self._fetch._to_options())
         with self._lock:
             hit = self._memo.get(request)
             if hit is not None:
                 return hit
-            # A refused version spelling is the caller's own misuse, refused
-            # before anything is attempted, and unlocks nothing. An open that
-            # attempted a load and failed unlocks the setup record while no
-            # image has completed load step 7, whatever failed: the resolve,
-            # the fetch, the signature or any load step (bindings-v1.md
-            # section 6, rule 4).
-            try:
-                fetch_request = Request(request)
-            except ValueError as exc:
-                raise errors.misuse(str(exc)) from None
-            # So is a pinning request on the dev channel (rule r6).
-            _refuse_pinning(self._fetch._to_options())
-            began = _setup.generation()
-            try:
-                library = self._resolve_and_open(request, fetch_request, allow_fetch)
-            except Exception:
-                _setup.open_failed(began)
-                raise
-            self._memo[request] = library
-            return library
+            flight = self._flights.get(request)
+            lead = flight is None
+            if flight is None:
+                flight = self._flights[request] = _Flight()
+        on_wait = self._on_wait
+        if on_wait is not None:
+            on_wait(request)
+        if lead:
+            self._attempt(flight, request, fetch_request, allow_fetch)
+        else:
+            flight.done.wait()
+        if flight.error is not None:
+            raise flight.error
+        assert flight.library is not None
+        return flight.library
+
+    def _attempt(
+        self, flight: _Flight, request: str, fetch_request: Request, allow_fetch: bool
+    ) -> None:
+        """Run an attempt on the leading open's thread, with no lock held, then
+        release every open waiting on it. An attempt that tried a load and
+        failed unlocks the setup record while no image has completed load step
+        7, whatever failed: the resolve, the fetch, the signature or any load
+        step (bindings-v1.md section 6, rule 4). It is never remembered."""
+        began = _setup.generation()
+        library: Library | None = None
+        error: BaseException | None = None
+        try:
+            library = self._resolve_and_open(request, fetch_request, allow_fetch)
+        except Exception as exc:
+            _setup.open_failed(began)
+            error = exc
+        except BaseException as exc:
+            error = exc
+        with self._lock:
+            del self._flights[request]
+            if error is None:
+                assert library is not None
+                self._memo[request] = library
+            flight.library, flight.error = library, error
+        flight.done.set()
 
     def _resolve_and_open(self, request: str, fetch_request: Request, allow_fetch: bool) -> Library:
         try:

chtypes-2.0.0.dev6/tests/abi2/test_registry_flight.py

@@ -0,0 +1,189 @@
+"""An open never waits for another request's fetch, and concurrent opens of one
+request share one fetch (public issue #491).
+
+Each test serves the stub, signed with the fetch fixtures' TEST key, from the
+fetch fixture server (scripts/fetch-v1/server.py) over HTTP, and holds a fetch
+in flight with the server's test-only gate: the request is logged and parked
+until the test opens the gate. Every wait is on an event (the server's parked
+count, the registry's wait hook, a future), never on a clock; a bound only
+turns a hang into a failure. The verdicts come from what the server logged and
+what each open returned. Python has no cancellation of an open, so there is no
+cancellation case here.
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+import threading
+import urllib.request
+from collections import Counter
+from collections.abc import Iterator
+from concurrent.futures import ThreadPoolExecutor
+from concurrent.futures import TimeoutError as FutureTimeout
+from contextlib import contextmanager
+from dataclasses import dataclass
+from pathlib import Path
+
+import pytest
+
+from chtypes import ArtifactError, FetchOptions, Registry
+
+from ._stub_tree import build_stub_tree
+
+REPO_ROOT = Path(__file__).resolve().parents[3]
+SERVER = REPO_ROOT / "scripts" / "fetch-v1" / "server.py"
+CASES = ("flight-install", "flight-held", "flight-one-fetch", "flight-fails")
+BOUND = 30.0  # turns a hang into a failure; a working registry answers at once
+N = 8
+
+
+@dataclass
+class Flight:
+    origin: str
+    cache: Path
+    trusted: object
+    layer_path: str
+
+    def registry(self, case_id: str) -> Registry:
+        """Autofetch on, the one base `case_id`'s repository on the server."""
+        return Registry(
+            fetch=FetchOptions(
+                bases=(f"{self.origin}/s-{case_id}/chtypes/v1",),
+                cache_dir=self.cache,
+                system_dirs=(),
+                trusted_keys=(self.trusted,),  # type: ignore[arg-type]
+            ),
+            autofetch=True,
+        )
+
+    def control(self, path: str) -> object:
+        with urllib.request.urlopen(self.origin + path, timeout=BOUND + 5) as r:
+            return json.loads(r.read())
+
+    @contextmanager
+    def gate(self, case_id: str) -> Iterator[None]:
+        """Hold `case_id`'s requests at the server; the gate opens on exit,
+        whatever happened, so no thread is left parked."""
+        self.control(f"/_gate/close/s-{case_id}")
+        try:
+            yield
+        finally:
+            self.open_gate(case_id)
+
+    def open_gate(self, case_id: str) -> None:
+        self.control(f"/_gate/open/s-{case_id}")
+
+    def wait_parked(self, case_id: str, n: int) -> int:
+        """Once n of `case_id`'s requests are parked at its gate: how many are."""
+        doc = self.control(f"/_gate/parked/s-{case_id}?n={n}")
+        assert isinstance(doc, dict)
+        return doc["parked"]
+
+    def requests(self, case_id: str) -> Counter[str]:
+        """`case_id`'s logged requests, "METHOD path" relative to its segment."""
+        log = self.control(f"/_log/s-{case_id}")
+        assert isinstance(log, list)
+        prefix = f"/v2/s-{case_id}"
+        return Counter(f"{e['method']} {e['path'].removeprefix(prefix)}" for e in log)
+
+
+@pytest.fixture
+def flight(stub_copy, tmp_path) -> Iterator[Flight]:
+    path, predicate = stub_copy()
+    fixtures = tmp_path / "fixtures"
+    tree = build_stub_tree(fixtures / "trees" / "stub", path, predicate, tag="26.8")
+    cases = [{"id": case_id, "tree": "stub"} for case_id in CASES]
+    (fixtures / "cases.json").write_text(json.dumps({"schema": 1, "cases": cases}))
+    repo = fixtures / "trees" / "stub" / "v2" / "chtypes" / "v1"
+    (platform,) = json.loads((repo / "manifests" / "26.8").read_text())["manifests"]
+    manifest = json.loads((repo / "manifests" / platform["digest"]).read_text())
+    (layer,) = manifest["layers"]
+    proc = subprocess.Popen(
+        [sys.executable, str(SERVER), "--fixtures", str(fixtures), "--port", "0"],
+        stdout=subprocess.PIPE,
+        text=True,
+    )
+    try:
+        line = proc.stdout.readline() if proc.stdout else ""
+        parts = line.split()
+        assert len(parts) == 3 and parts[0] == "LISTENING", f"server.py printed {line!r}"
+        yield Flight(
+            origin=f"http://127.0.0.1:{parts[1]}",
+            cache=tmp_path / "cache",
+            trusted=tree.trusted,
+            layer_path=f"/chtypes/v1/blobs/{layer['digest']}",
+        )
+    finally:
+        proc.kill()
+        proc.wait()
+
+
+def test_an_installed_line_never_waits_for_another_lines_fetch(flight: Flight) -> None:
+    """The issue's regression: with 26.3's fetch held at the gate, an open of
+    26.8, which the cache answers, returns while 26.3's request is parked."""
+    flight.registry("flight-install").for_version("26.8")  # install 26.8
+    registry = flight.registry("flight-held")
+    with ThreadPoolExecutor(2) as pool, flight.gate("flight-held"):
+        held = pool.submit(registry.for_version, "26.3")
+        flight.wait_parked("flight-held", 1)
+        installed = pool.submit(registry.for_version, "26.8")
+        try:
+            library = installed.result(timeout=BOUND)
+        except FutureTimeout:
+            pytest.fail(f"for_version('26.8'), installed, waited {BOUND} s for 26.3's fetch")
+        assert library.version == "26.8.15.10"
+        assert not held.done(), f"for_version('26.3') returned while its fetch was held: {held}"
+        assert flight.wait_parked("flight-held", 1) == 1
+        flight.open_gate("flight-held")
+        assert isinstance(held.exception(timeout=BOUND), ArtifactError)
+    made = [r for r in flight.requests("flight-held") if "/manifests/26.8" in r]
+    assert made == [], f"the open of installed 26.8 made requests: {made}"
+
+
+def test_concurrent_opens_of_one_request_share_one_fetch(flight: Flight) -> None:
+    """N opens of one uninstalled request, all waiting while its fetch is
+    held, make one fetch and all get its Library."""
+    registry = flight.registry("flight-one-fetch")
+    waiting = threading.Semaphore(0)
+    registry._on_wait = lambda _request: waiting.release()
+    with ThreadPoolExecutor(N) as pool, flight.gate("flight-one-fetch"):
+        futures = [pool.submit(registry.for_version, "26.8") for _ in range(N)]
+        for i in range(N):
+            assert waiting.acquire(timeout=BOUND), f"open {i + 1} of {N} never waited"
+        parked = flight.wait_parked("flight-one-fetch", 1)
+        assert parked == 1, f"{parked} requests parked with {N} opens waiting"
+        flight.open_gate("flight-one-fetch")
+        libraries = [f.result(timeout=BOUND) for f in futures]
+    assert all(lib is libraries[0] for lib in libraries), "one request, one Library"
+    requests = flight.requests("flight-one-fetch")
+    assert requests["GET /chtypes/v1/manifests/26.8"] == 1, requests
+    assert requests["GET " + flight.layer_path] == 1, requests
+    assert set(requests.values()) == {1}, f"a path requested twice: {requests}"
+    assert registry.for_version("26.8") is libraries[0]
+    assert registry.libraries() == (libraries[0],)
+
+
+def test_a_failed_fetch_reaches_every_waiter_and_is_not_remembered(flight: Flight) -> None:
+    """N opens of a request nothing serves share one failing fetch and all
+    raise its error; the next open makes a new request."""
+    registry = flight.registry("flight-fails")
+    waiting = threading.Semaphore(0)
+    registry._on_wait = lambda _request: waiting.release()
+    with ThreadPoolExecutor(N) as pool, flight.gate("flight-fails"):
+        futures = [pool.submit(registry.for_version, "26.3") for _ in range(N)]
+        for i in range(N):
+            assert waiting.acquire(timeout=BOUND), f"open {i + 1} of {N} never waited"
+        flight.wait_parked("flight-fails", 1)
+        flight.open_gate("flight-fails")
+        raised = [f.exception(timeout=BOUND) for f in futures]
+    first = raised[0]
+    assert isinstance(first, ArtifactError), raised
+    assert all(exc is first for exc in raised), f"one attempt, one error: {raised}"
+    tag = "GET /chtypes/v1/manifests/26.3"
+    assert flight.requests("flight-fails")[tag] == 1
+    with pytest.raises(type(first)) as again:
+        registry.for_version("26.3")
+    assert str(again.value) == str(first)
+    assert flight.requests("flight-fails")[tag] == 2, "a failure is never remembered"

{chtypes-2.0.0.dev5 → chtypes-2.0.0.dev6}/tests/ocifetch/test_conformance.py

@@ -53,6 +53,37 @@ from chtypes._ocifetch._unpack import unpack_tar_zst
 
 FIXTURES_ENV = "CHTYPES_V1_CONFORMANCE"
 REPORT_ENV = "CHTYPES_V1_REPORT"
+# The same cases regenerated for generation 2 (tests/fixtures/fetch-v2: ABI 2
+# predicates, schema-2 records), run under the production generation-2 channel
+# (docs/guides/fetch-v1.md, "Generation 2 after the lock").
+V2_FIXTURES_ENV = "CHTYPES_V2_CONFORMANCE"
+V2_REPORT_ENV = "CHTYPES_V2_REPORT"
+
+
+class _Corpus:
+    """One conformance run: which corpus, which report, which channel."""
+
+    def __init__(self, name: str, fixtures_env: str, report_env: str, channel: str, subroot: str):
+        self.name = name
+        self.fixtures_env = fixtures_env
+        self.report_env = report_env
+        self.channel = channel
+        self.subroot = subroot  # where an explicit cache directory's layout lives
+
+
+CORPORA = {
+    "v1": _Corpus("v1", FIXTURES_ENV, REPORT_ENV, "v1", ""),
+    "prod-v2": _Corpus(
+        "prod-v2", V2_FIXTURES_ENV, V2_REPORT_ENV, C.PROD_V2_NAME, C.PROD_V2_CACHE_DIR
+    ),
+}
+
+
+@pytest.fixture(scope="module", params=list(CORPORA), ids=list(CORPORA))
+def corpus(request) -> _Corpus:
+    return CORPORA[request.param]
+
+
 BINDING = "python"
 
 
@@ -70,22 +101,22 @@ def _toolchain() -> str:
     )
 
 
-def _fixtures_root() -> Path:
-    raw = os.environ.get(FIXTURES_ENV)
+def _fixtures_root(env: str) -> Path:
+    raw = os.environ.get(env)
     if not raw:
         pytest.skip(
-            f"{FIXTURES_ENV} is not set. Set it to an absolute tests/fixtures/fetch-v1 path "
+            f"{env} is not set. Set it to an absolute tests/fixtures/fetch-v1 (or fetch-v2) path "
             f'to run this suite (docs/guides/fetch-v1.md "Conformance").'
         )
     root = Path(raw).resolve()
     if not (root / "cases.json").is_file():
-        pytest.skip(f"{FIXTURES_ENV}={root} has no cases.json yet — nothing to run")
+        pytest.skip(f"{env}={root} has no cases.json yet — nothing to run")
     return root
 
 
 @pytest.fixture(scope="module")
-def fixtures_root() -> Path:
-    return _fixtures_root()
+def fixtures_root(corpus: _Corpus) -> Path:
+    return _fixtures_root(corpus.fixtures_env)
 
 
 @pytest.fixture(scope="module")
@@ -427,6 +458,7 @@ def _run_case(
     http_port: int | None,
     http_port2: int | None,
     request_log: _RequestLog,
+    subroot: str = "",
 ) -> tuple[str, str]:
     """Drives one (case, transport) pair through `ensure()`. Returns
     (verdict, detail) for the report (schema: "pass"/"fail")."""
@@ -449,18 +481,21 @@ def _run_case(
     )
 
     cache_dir = tmp_path / "cache"
+    # An explicit cache directory is used through the contract's subroot, so
+    # that is where a seeded layout lives (none for the v1 contract).
+    layout_dir = cache_dir / subroot if subroot else cache_dir
     if setup.get("cache") and setup["cache"] != "empty":
         seed = fixtures_root / "layouts" / setup["cache"]
         if seed.is_dir():
-            shutil.copytree(seed, cache_dir)
-            installed_doc_path = cache_dir / "installed.json"
+            shutil.copytree(seed, layout_dir)
+            installed_doc_path = layout_dir / "installed.json"
             if installed_doc_path.is_file():
                 installed = json.loads(installed_doc_path.read_text())
                 for digest in installed.get("installed", []):
                     _preinstall_from_layout(
-                        layout_dir=cache_dir,
+                        layout_dir=layout_dir,
                         manifest_digest=digest,
-                        cache_root=cache_dir,
+                        cache_root=layout_dir,
                         trusted_keys=trusted_keys,
                     )
 
@@ -487,11 +522,11 @@ def _run_case(
         hook_factory = _BEFORE_INDEX_RENAME_HOOKS.get(hook_name)
         if hook_factory is None:
             return "fail", f"unknown before_index_rename_hook {hook_name!r} — not implemented"
-        before_index_rename = hook_factory(cache_dir)
+        before_index_rename = hook_factory(layout_dir)
 
     # records_intact: each named install's directory, as the pre-install left
     # it, compared after the call.
-    intact_before = {d: _snapshot_install(cache_dir, d) for d in expect["records_intact"]}
+    intact_before = {d: _snapshot_install(layout_dir, d) for d in expect["records_intact"]}
     for d, snap in intact_before.items():
         if not snap:
             return "fail", f"records_intact: {d} is not installed before the call"
@@ -619,7 +654,7 @@ def _run_case(
                     )
 
     for d, snap in intact_before.items():
-        after = _snapshot_install(cache_dir, d)
+        after = _snapshot_install(layout_dir, d)
         if after != snap:
             mismatches.append(
                 f"records_intact: the install of {d} changed "
@@ -658,7 +693,8 @@ def _run_case(
     return "pass", ""
 
 
-def test_conformance_v1(
+def test_conformance(
+    corpus: _Corpus,
     fixtures_root: Path,
     cases_doc: dict,
     cases_sha256: str,
@@ -666,16 +702,39 @@ def test_conformance_v1(
     tmp_path_factory,
     request_log: _RequestLog,
 ) -> None:
-    # This directory runs under the v1 fetch contract (conftest.py): the cases
-    # are its specification. The ABI v2 dev channel narrows it, and its own
-    # rules (r5, r6) are test_devchannel.py.
-    print(
-        f"fetch contract: {_channel.channel_name()} (the fetch-v1 cases' own; the dev channel "
-        "this binding ships is tested by tests/ocifetch/test_devchannel.py)"
-    )
-    assert _channel.channel_name() == "v1", (
-        f"the fetch-v1 conformance cases must run under the v1 contract, not "
-        f"{_channel.channel_name()!r}"
+    # The v1 corpus runs under the v1 fetch contract (conftest.py): its cases
+    # are that contract's specification. The ABI v2 dev channel narrows it, and
+    # its own rules (r5, r6) are test_devchannel.py. The prod-v2 corpus runs
+    # under the production generation-2 channel.
+    restore = _channel.use_prod_v2_for_tests() if corpus.name == "prod-v2" else None
+    try:
+        _run_corpus(
+            corpus,
+            fixtures_root,
+            cases_doc,
+            cases_sha256,
+            http_server,
+            tmp_path_factory,
+            request_log,
+        )
+    finally:
+        if restore is not None:
+            restore()
+
+
+def _run_corpus(
+    corpus: _Corpus,
+    fixtures_root: Path,
+    cases_doc: dict,
+    cases_sha256: str,
+    http_server,
+    tmp_path_factory,
+    request_log: _RequestLog,
+) -> None:
+    print(f"fetch contract: {_channel.channel_name()} (corpus {corpus.name})")
+    assert _channel.channel_name() == corpus.channel, (
+        f"the {corpus.name} conformance cases must run under the {corpus.channel!r} contract, "
+        f"not {_channel.channel_name()!r}"
     )
     results = []
     for case in cases_doc["cases"]:
@@ -692,6 +751,7 @@ def test_conformance_v1(
                     http_port=http_port,
                     http_port2=http_port2,
                     request_log=request_log,
+                    subroot=corpus.subroot,
                 )
             except pytest.skip.Exception:
                 continue
@@ -699,7 +759,7 @@ def test_conformance_v1(
                 {"id": case["id"], "transport": transport, "verdict": verdict, "detail": detail}
             )
 
-    report_path = os.environ.get(REPORT_ENV)
+    report_path = os.environ.get(corpus.report_env)
     if report_path:
         report = {
             "schema": 1,
@@ -711,9 +771,13 @@ def test_conformance_v1(
         with open(report_path, "w", encoding="utf-8") as f:
             json.dump(report, f, indent=2, sort_keys=True)
 
+    n_cases = len(cases_doc["cases"])
+    print(f"{corpus.name} conformance: {len(results)} result(s) over {n_cases} case(s)")
     failures = [r for r in results if r["verdict"] == "fail"]
     if failures:
         detail = "\n".join(f"  {r['id']} ({r['transport']}): {r['detail']}" for r in failures)
-        pytest.fail(f"{len(failures)}/{len(results)} v1 conformance cases failed:\n{detail}")
+        pytest.fail(
+            f"{len(failures)}/{len(results)} {corpus.name} conformance cases failed:\n{detail}"
+        )
     if not results:
         pytest.fail("0 cases ran — the fixtures tree is present but produced no results")

chtypes-2.0.0.dev6/tests/ocifetch/test_prodv2_smoke.py

@@ -0,0 +1,63 @@
+"""A live smoke of the production generation-2 channel against a real registry,
+opt-in: `CHTYPES_PRODV2_SMOKE_BASE` names the repository (the staging dev
+repository, whose builds are abi 2 and signed with the staging key) and
+`CHTYPES_PRODV2_SMOKE_KEY` the key it is signed with. It skips loudly when either
+is unset, and the sandboxed CI runs never set them. It proves the channel honors
+a base and a trust override, writes a schema-2 record signed by that key, and that
+a lock then a frozen fetch pin one manifest.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from pathlib import Path
+
+import pytest
+
+from chtypes._ocifetch import _channel
+from chtypes._ocifetch._dsse import TrustedKey
+from chtypes._ocifetch._ensure import Options, Request, ensure
+
+
+def test_prod_v2_live_smoke(tmp_path: Path) -> None:
+    base = os.environ.get("CHTYPES_PRODV2_SMOKE_BASE")
+    key = os.environ.get("CHTYPES_PRODV2_SMOKE_KEY")
+    if not base or not key:
+        pytest.skip("CHTYPES_PRODV2_SMOKE_BASE and CHTYPES_PRODV2_SMOKE_KEY are not set")
+    spelling = os.environ.get("CHTYPES_PRODV2_SMOKE_SPELLING", "26.9")
+    restore = _channel.use_prod_v2_for_tests()
+    try:
+        lock = tmp_path / "chtypes.lock"
+        raw_key = bytes.fromhex(key)
+        keyid = hashlib.sha256(raw_key).hexdigest()[:16]  # the constants' sha256-first16hex
+        trust = (TrustedKey(keyid=keyid, public_key=raw_key),)
+
+        def options(cache: str, **kw: bool) -> Options:
+            return Options(
+                bases=(base,),
+                trusted_keys=trust,
+                cache_dir=tmp_path / cache,
+                system_dirs=(),
+                lock_path=lock,
+                **kw,
+            )
+
+        first = ensure(Request(spelling), options("cache1", lock_write=True))
+        record = json.loads((Path(first.dir) / "verified.json").read_text())
+        manifest = first.digests["manifest"]
+        print(f"fetched {spelling}: {first.version} build {first.build} manifest {manifest}")
+        print(
+            f"record: schema {record['schema']}, signed_by {record['signed_by']}, "
+            f"predicate abi {record['predicate']['abi']}, under {Path(first.dir).parents[2].name}"
+        )
+        assert record["schema"] == 2 and record["predicate"]["abi"] == 2
+        assert record["signed_by"]
+        assert Path(first.dir).parents[2].name == "v2"
+
+        again = ensure(Request(spelling), options("cache2", frozen=True))
+        print(f"frozen: manifest {again.digests['manifest']}")
+        assert again.digests["manifest"] == first.digests["manifest"]
+    finally:
+        restore()

chtypes-2.0.0.dev6/tests/ocifetch/test_prodv2channel.py

@@ -0,0 +1,70 @@
+"""The production generation-2 channel (`chtypes._ocifetch._channel.PROD_V2_CHANNEL`;
+docs/guides/fetch-v1.md, "Generation 2 after the lock"), built and tested but not
+the default. The fetch conformance cases run under it in `test_conformance.py`;
+these are the pins those cases do not reach. Nothing here reaches the network.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from pathlib import Path
+
+import pytest
+
+from chtypes._ocifetch import _channel
+from chtypes._ocifetch import _constants as C
+from chtypes._ocifetch._ensure import Options, search_roots
+from chtypes._ocifetch._layout import resolve_cache_root
+
+
+@pytest.fixture(autouse=True)
+def prod_v2(monkeypatch: pytest.MonkeyPatch) -> Iterator[None]:
+    restore = _channel.use_prod_v2_for_tests()
+    for name in (
+        C.ENV_BASES_NAME,
+        C.ENV_TRUSTED_KEYS_NAME,
+        C.ENV_ALLOW_UNSIGNED_NAME,
+        C.ENV_CACHE_NAME,
+    ):
+        monkeypatch.delenv(name, raising=False)
+    try:
+        yield
+    finally:
+        restore()
+
+
+def test_the_production_v2_channel_carries_the_v2_values() -> None:
+    c = _channel.active()
+    assert (c.name, c.abi, c.record_schema, c.root_leaf, c.subroot) == ("v2", 2, 2, "v2", "v2")
+    assert c.overridable and c.pinnable and c.own_fingerprint == ""
+    assert c.system_dirs == ("/usr/local/share/chtypes/v2", "/opt/chtypes/v2")
+    options = Options()
+    assert options.resolved_bases() == ("https://registry.wavehouse.dev/chtypes/v2",)
+    trust = options.resolved_trusted_keys()
+    assert [k.keyid for k in trust] == ["deb275922dbff76e"]
+    assert not {k.public_key.hex() for k in trust} & {_channel.DEV_KEY_HEX}
+
+
+def test_the_production_v2_channel_honors_overrides(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv(C.ENV_BASES_NAME, "https://mirror.example/chtypes/v2")
+    assert Options().resolved_bases() == ("https://mirror.example/chtypes/v2",)
+
+
+def test_the_production_v2_channel_cache_roots(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setenv("XDG_CACHE_HOME", str(tmp_path / "xdg"))
+    assert resolve_cache_root() == tmp_path / "xdg" / "chtypes" / "v2"
+    assert resolve_cache_root(tmp_path / "opt") == tmp_path / "opt" / "v2"
+    roots = search_roots(tmp_path / "opt")
+    assert roots[1:] == (Path("/usr/local/share/chtypes/v2"), Path("/opt/chtypes/v2"))
+
+
+def test_the_production_v2_channel_is_not_the_default() -> None:
+    # What an ordinary process speaks, with no seam selected.
+    restore = _channel.use_dev_channel_for_tests()
+    try:
+        assert _channel.channel_name() == "v2-dev"
+    finally:
+        restore()
+    assert _channel.channel_name() == "v2"

{chtypes-2.0.0.dev5 → chtypes-2.0.0.dev6}/uv.lock

@@ -74,7 +74,7 @@ wheels = [
 
 [[package]]
 name = "chtypes"
-version = "2.0.0.dev5"
+version = "2.0.0.dev6"
 source = { editable = "." }
 dependencies = [
     { name = "backports-zstd", marker = "python_full_version < '3.14'" },