chtypes 2.0.0.dev0__tar.gz → 2.0.0.dev2__tar.gz

{chtypes-2.0.0.dev0 → chtypes-2.0.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: chtypes
-Version: 2.0.0.dev0
+Version: 2.0.0.dev2
 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
@@ -20,6 +20,8 @@ Description-Content-Type: text/markdown
 # chtypes — Python SDK
 
 > **2.0.0-dev: UNSTABLE, staging only, not for production.** This is the ABI v2 development binding (public issue #511). It speaks ABI v2's unstable description, pins its dev fingerprint and refuses a library with any other ("update your dev SDK"). It fetches only from the staging dev channel (`https://registry-staging.wavehouse.dev/chtypes/v2-dev`) and trusts only the staging key; `CHTYPES_ARTIFACTS_URL`, `CHTYPES_TRUSTED_KEYS` and `CHTYPES_ALLOW_UNSIGNED`, and the `bases`, `trusted_keys` and `allow_unsigned` fetch options, are ignored, each with one warning; `--lock`, `--frozen` and `--update`, and the `frozen`, `lock_path`, `lock_write` and `update` options, are refused, because a dev build is replaceable and a superseded one expires after 14 days. Its cache is `${XDG_CACHE_HOME:-~/.cache}/chtypes/v2-dev`, or `<CHTYPES_CACHE>/v2-dev` under an explicit cache, which no 1.x SDK reads. Every vocabulary keeps a value it does not list as its `unknown(n)` member (`Outcome("x")`, whose `known` is `False`) instead of failing the document. The rules are r1 to r6 of [`docs/reference/abi-v2.md`](../docs/reference/abi-v2.md). For production, use the 1.x package: `pip install "chtypes<2"`.
+>
+> An explicit cache directory gets the `v2-dev` subroot whether it comes from `CHTYPES_CACHE` or from `FetchOptions(cache_dir=...)`: the layout is under `<cache_dir>/v2-dev`, never in the directory itself, so code that inspects or pre-populates a cache looks there; `chtypes.cache_root` and `chtypes.search_dirs` return the resolved paths. `CHTYPES_OFFLINE=1` is the environment twin of `FetchOptions(offline=True)` and `--offline`: the cache only, no request.
 
 **If this row were inserted into this table on this ClickHouse version, what would happen?** chtypes answers with ClickHouse's own code: the real C++ type machinery, vendored per release into a native library behind the frozen `chs_*` C ABI and reached here through stdlib `ctypes`. Nothing semantic is reimplemented, so _"what does ClickHouse do with `256` into a `UInt8`?"_ is answered by ClickHouse rather than by a model of it. One peer binding among `{go, python, ts, rust}` — no language is privileged, and all four give one answer.
 
@@ -41,18 +43,18 @@ uv add "chtypes>=2.0.0.dev0"            # or: pip install "chtypes>=2.0.0.dev0"
 import chtypes
 from chtypes import Format, Registry
 
-chtypes.setup(timezone="UTC")             # once, before the first open (optional)
+chtypes.setup(timezone="UTC")  # once, before the first open (optional)
 registry = Registry(autofetch=True)
-library = registry.for_version("26.8")    # a release line or an exact version
+library = registry.for_version("26.8")  # a release line or an exact version
 
 ddl = b"CREATE TABLE t (x UInt8, ts DateTime DEFAULT now()) ENGINE = Memory"
 with library.compile_table(ddl) as schema:
     batch = schema.rows(Format.JSON_EACH_ROW, b'{"x":256}\n')
 
 row = batch.rows[0]
-print(batch.outcome)                  # accepted
-print(row.values[0].text)             # b'0'          what would actually be stored
-print(row.transformed[0].reason)      # overflow_wrap which is the product
+print(batch.outcome)  # accepted
+print(row.values[0].text)  # b'0'          what would actually be stored
+print(row.transformed[0].reason)  # overflow_wrap which is the product
 ```
 
 The row is **accepted** and `256` is silently stored as `0`. That report — `transformed` — is why chtypes exists. Names, SQL, messages and renderings come back as `bytes`, never decoded for you: a column name that is not valid UTF-8 round-trips exactly.

{chtypes-2.0.0.dev0 → chtypes-2.0.0.dev2}/README.md

@@ -1,6 +1,8 @@
 # chtypes — Python SDK
 
 > **2.0.0-dev: UNSTABLE, staging only, not for production.** This is the ABI v2 development binding (public issue #511). It speaks ABI v2's unstable description, pins its dev fingerprint and refuses a library with any other ("update your dev SDK"). It fetches only from the staging dev channel (`https://registry-staging.wavehouse.dev/chtypes/v2-dev`) and trusts only the staging key; `CHTYPES_ARTIFACTS_URL`, `CHTYPES_TRUSTED_KEYS` and `CHTYPES_ALLOW_UNSIGNED`, and the `bases`, `trusted_keys` and `allow_unsigned` fetch options, are ignored, each with one warning; `--lock`, `--frozen` and `--update`, and the `frozen`, `lock_path`, `lock_write` and `update` options, are refused, because a dev build is replaceable and a superseded one expires after 14 days. Its cache is `${XDG_CACHE_HOME:-~/.cache}/chtypes/v2-dev`, or `<CHTYPES_CACHE>/v2-dev` under an explicit cache, which no 1.x SDK reads. Every vocabulary keeps a value it does not list as its `unknown(n)` member (`Outcome("x")`, whose `known` is `False`) instead of failing the document. The rules are r1 to r6 of [`docs/reference/abi-v2.md`](../docs/reference/abi-v2.md). For production, use the 1.x package: `pip install "chtypes<2"`.
+>
+> An explicit cache directory gets the `v2-dev` subroot whether it comes from `CHTYPES_CACHE` or from `FetchOptions(cache_dir=...)`: the layout is under `<cache_dir>/v2-dev`, never in the directory itself, so code that inspects or pre-populates a cache looks there; `chtypes.cache_root` and `chtypes.search_dirs` return the resolved paths. `CHTYPES_OFFLINE=1` is the environment twin of `FetchOptions(offline=True)` and `--offline`: the cache only, no request.
 
 **If this row were inserted into this table on this ClickHouse version, what would happen?** chtypes answers with ClickHouse's own code: the real C++ type machinery, vendored per release into a native library behind the frozen `chs_*` C ABI and reached here through stdlib `ctypes`. Nothing semantic is reimplemented, so _"what does ClickHouse do with `256` into a `UInt8`?"_ is answered by ClickHouse rather than by a model of it. One peer binding among `{go, python, ts, rust}` — no language is privileged, and all four give one answer.
 
@@ -22,18 +24,18 @@ uv add "chtypes>=2.0.0.dev0"            # or: pip install "chtypes>=2.0.0.dev0"
 import chtypes
 from chtypes import Format, Registry
 
-chtypes.setup(timezone="UTC")             # once, before the first open (optional)
+chtypes.setup(timezone="UTC")  # once, before the first open (optional)
 registry = Registry(autofetch=True)
-library = registry.for_version("26.8")    # a release line or an exact version
+library = registry.for_version("26.8")  # a release line or an exact version
 
 ddl = b"CREATE TABLE t (x UInt8, ts DateTime DEFAULT now()) ENGINE = Memory"
 with library.compile_table(ddl) as schema:
     batch = schema.rows(Format.JSON_EACH_ROW, b'{"x":256}\n')
 
 row = batch.rows[0]
-print(batch.outcome)                  # accepted
-print(row.values[0].text)             # b'0'          what would actually be stored
-print(row.transformed[0].reason)      # overflow_wrap which is the product
+print(batch.outcome)  # accepted
+print(row.values[0].text)  # b'0'          what would actually be stored
+print(row.transformed[0].reason)  # overflow_wrap which is the product
 ```
 
 The row is **accepted** and `256` is silently stored as `0`. That report — `transformed` — is why chtypes exists. Names, SQL, messages and renderings come back as `bytes`, never decoded for you: a column name that is not valid UTF-8 round-trips exactly.

{chtypes-2.0.0.dev0 → chtypes-2.0.0.dev2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "chtypes"
-version = "2.0.0.dev0"
+version = "2.0.0.dev2"
 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.dev0 → chtypes-2.0.0.dev2}/src/chtypes/__init__.py

@@ -59,7 +59,7 @@ from ._abi2._vocab import (
     Status,
     Verdict,
 )
-from ._input import BytesIn, Settings
+from ._input import BytesIn, ServerProfile, Settings
 from ._setup import setup
 from .errors import (
     CODE_ARTIFACT_CORRUPT,
@@ -92,8 +92,8 @@ from .errors import (
     UnsupportedError,
     UsageError,
 )
-from .library import Block, Filter, Library, Schema, open_unverified
-from .registry import FetchOptions, Registry, Resolved, TrustedKey
+from .library import Block, Filter, Library, Schema, Server, open_unverified
+from .registry import FetchOptions, Registry, Resolved, TrustedKey, cache_root, search_dirs
 from .results import (
     BatchResult,
     BuildInfo,
@@ -111,6 +111,8 @@ from .results import (
     Header,
     RowResult,
     SchemaDescription,
+    SchemaReplicated,
+    SchemaServer,
     Span,
     Transform,
     Value,
@@ -172,6 +174,10 @@ __all__ = [
     "Schema",
     "SchemaDescription",
     "SchemaError",
+    "SchemaReplicated",
+    "SchemaServer",
+    "Server",
+    "ServerProfile",
     "Settings",
     "Source",
     "SourceForbiddenError",
@@ -186,7 +192,9 @@ __all__ = [
     "UsageError",
     "Value",
     "Verdict",
+    "cache_root",
     "open_unverified",
+    "search_dirs",
     "setup",
 ]
 

{chtypes-2.0.0.dev0 → chtypes-2.0.0.dev2}/src/chtypes/__main__.py

@@ -5,7 +5,7 @@
                                          [--frozen] [--offline] [--update] [--strict]
     chtypes verify [--cache <dir>] [--strict]   re-verify every installed build
     chtypes list   [--cache <dir>] [--offline] [--strict]
-    chtypes where  [--cache <dir>] [--strict]   the cache root
+    chtypes where  [--cache <dir>] [--strict] [--all]   the cache root; --all: every search dir
 
 A spelling is `26.8`, `26.8.15` or `26.8.15.10`. Exit statuses come from the
 `errors` table of spec/fetch-v1/constants.json (generated into the fetch layer
@@ -137,7 +137,10 @@ def build_parser() -> argparse.ArgumentParser:
     fetch.add_argument(
         "--offline",
         action="store_true",
-        help="never touch a source: installed and verified, or CHTYPES_ARTIFACT_MISSING",
+        help=(
+            "never touch a source: installed and verified, or CHTYPES_ARTIFACT_MISSING "
+            "(or set CHTYPES_OFFLINE=1)"
+        ),
     )
 
     verify = sub.add_parser(
@@ -154,11 +157,22 @@ def build_parser() -> argparse.ArgumentParser:
     )
     cache_option(listing)
     listing.add_argument(
-        "--offline", action="store_true", help="list only what is installed; no network"
+        "--offline",
+        action="store_true",
+        help="list only what is installed; no network (or set CHTYPES_OFFLINE=1)",
     )
 
-    where = sub.add_parser("where", help="the cache root", description="Print the cache root.")
+    where = sub.add_parser(
+        "where",
+        help="the cache root",
+        description="Print the cache root; with --all, every directory searched.",
+    )
     cache_option(where)
+    where.add_argument(
+        "--all",
+        action="store_true",
+        help="every directory searched, in order, the cache root first (one per line)",
+    )
     return parser
 
 
@@ -294,7 +308,7 @@ def _cmd_list(args: argparse.Namespace) -> int:
         sys.stdout.write(f"installed {r.version} {r.platform} {r.dir}\n")
     sys.stdout.flush()
     _say_notes(options)
-    if not args.offline:
+    if not options.resolved_offline():
         for tag in _published_tags(options):
             sys.stdout.write(f"published {tag} support unknown\n")
     sys.stdout.flush()
@@ -306,6 +320,10 @@ def _cmd_where(args: argparse.Namespace) -> int:
     if options.resolved_strict():
         # Strict mode checks the root before naming it.
         probe_roots(search_roots(options.cache_dir, options.system_dirs), strict=True)
+    if args.all:
+        for directory in search_roots(options.cache_dir, options.system_dirs):
+            sys.stdout.write(f"{directory}\n")
+        return EXIT_OK
     sys.stdout.write(f"{resolve_cache_root(args.cache)}\n")
     return EXIT_OK
 

{chtypes-2.0.0.dev0 → chtypes-2.0.0.dev2}/src/chtypes/_abi2/_decls.py

@@ -1,4 +1,4 @@
-# GENERATED by scripts/abi-v1/gen.py --major 2 from spec/abi-v2/abi.json (CHS_ABI_FINGERPRINT sha256:8ec0c6941f000aa07bfb9fbfef20205d3ee0a588833856bd12270ba42912bfb3) — DO NOT EDIT  # noqa: E501
+# GENERATED by scripts/abi-v1/gen.py --major 2 from spec/abi-v2/abi.json (CHS_ABI_FINGERPRINT sha256:d87e91be2bbe75b985c38224268c2f7dc5d8236dab0a4b4d61357c6dfdc1a232) — DO NOT EDIT  # noqa: E501
 """The Python binding's generated ABI v2 layer: ctypes signatures, the handle
 classes, the two-phase resolve functions and invoke_by_name(), the test-only
 dispatcher the conformance suite drives from tests/fixtures/abi-v2/cases.json.
@@ -19,7 +19,7 @@ from dataclasses import dataclass, field
 from . import _errmap
 
 CHS_ABI_VERSION = 2
-CHS_ABI_FINGERPRINT = "sha256:8ec0c6941f000aa07bfb9fbfef20205d3ee0a588833856bd12270ba42912bfb3"
+CHS_ABI_FINGERPRINT = "sha256:d87e91be2bbe75b985c38224268c2f7dc5d8236dab0a4b4d61357c6dfdc1a232"
 
 # The description's stability: "unstable" while this generation is being
 # designed, so CHS_ABI_FINGERPRINT moves with every change, and "locked" after
@@ -61,6 +61,7 @@ _STATUS_OK = 0
 HANDLE_FREE: dict[str, str] = {
     "chs_buf": "chs_buf_free",
     "chs_error": "chs_error_free",
+    "chs_server": "chs_server_free",
     "chs_schema": "chs_schema_free",
     "chs_filter": "chs_filter_free",
     "chs_block": "chs_block_free",
@@ -102,6 +103,8 @@ ALL_SYMBOLS: tuple[str, ...] = (
     "chs_schema_create",
     "chs_schema_describe",
     "chs_schema_free",
+    "chs_server_create",
+    "chs_server_free",
     "chs_set_defaults",
     "chs_shutdown",
     "chs_type_validate",
@@ -174,6 +177,10 @@ class ErrorHandle(Handle):
     """A `chs_error` the library owns the free function for."""
 
 
+class ServerHandle(Handle):
+    """A `chs_server` the library owns the free function for."""
+
+
 class SchemaHandle(Handle):
     """A `chs_schema` the library owns the free function for."""
 
@@ -189,6 +196,7 @@ class BlockHandle(Handle):
 _HANDLE_CLASS: dict[str, type[Handle]] = {
     "chs_buf": BufHandle,
     "chs_error": ErrorHandle,
+    "chs_server": ServerHandle,
     "chs_schema": SchemaHandle,
     "chs_filter": FilterHandle,
     "chs_block": BlockHandle,
@@ -324,12 +332,24 @@ _add(
     _P("out", "out_handle", "chs_buf"),
     _P("err", "out_error", "chs_error", nullable=True),
 )
+_add(
+    "chs_server_create",
+    "status",
+    "chs_status",
+    _P("profile", "bytes_in", None),
+    _P("options", "bytes_in", None),
+    _P("out", "out_handle", "chs_server"),
+    _P("err", "out_error", "chs_error", nullable=True),
+)
+_add("chs_server_free", "void", None, _P("server", "handle", "chs_server", nullable=True))
 _add(
     "chs_schema_create",
     "status",
     "chs_status",
+    _P("server", "handle", "chs_server", nullable=True),
     _P("create_table", "bytes_in", None),
     _P("settings", "bytes_in", None),
+    _P("options", "bytes_in", None),
     _P("out", "out_handle", "chs_schema"),
     _P("err", "out_error", "chs_error", nullable=True),
 )
@@ -486,6 +506,18 @@ def resolve_abi_version(lib: ctypes.CDLL) -> Callable[..., object]:
     return fn
 
 
+def resolve_build_info(lib: ctypes.CDLL) -> Callable[..., object]:
+    """Loader step 4's dlsym: `chs_build_info` ALONE, so the fingerprint can be
+    compared before step 6's full sweep (rule r6 beats a missing symbol,
+    public issue #537). Absent is MissingSymbol, the step 4 refusal."""
+    try:
+        fn = lib.chs_build_info
+    except AttributeError:
+        raise MissingSymbol("chs_build_info") from None
+    _set_signature(fn, FUNCTIONS["chs_build_info"])
+    return fn
+
+
 class Api:
     """Every described symbol, resolved and signature-typed, step 6
     (plan section 3.2). Constructed ONLY by resolve_all(): the constructor
@@ -703,19 +735,42 @@ class Api:
         self._check(status, err)
         return _read_buf(self, out.value)
 
+    def server_create(
+        self,
+        profile: bytes | None,
+        options: bytes | None,
+    ) -> ServerHandle:
+        """The generated call wrapper for chs_server_create (thread class any).
+
+        Raises the class the status maps to on a non-OK status."""
+        out = ctypes.c_void_p()
+        err = ctypes.c_void_p()
+        status = self._raw["chs_server_create"](
+            *_bytes_in(profile),
+            *_bytes_in(options),
+            ctypes.byref(out),
+            ctypes.byref(err),
+        )
+        self._check(status, err)
+        return ServerHandle(out.value, self._raw["chs_server_free"])
+
     def schema_create(
         self,
+        server: ServerHandle | None,
         create_table: bytes | None,
         settings: bytes | None,
+        options: bytes | None,
     ) -> SchemaHandle:
-        """The generated call wrapper for chs_schema_create (thread class any).
+        """The generated call wrapper for chs_schema_create (thread class shared).
 
         Raises the class the status maps to on a non-OK status."""
         out = ctypes.c_void_p()
         err = ctypes.c_void_p()
         status = self._raw["chs_schema_create"](
+            None if server is None else server.value,
             *_bytes_in(create_table),
             *_bytes_in(settings),
+            *_bytes_in(options),
             ctypes.byref(out),
             ctypes.byref(err),
         )
@@ -925,17 +980,15 @@ _API_KEY = object()
 
 
 def resolve_all(lib: ctypes.CDLL) -> Api:
-    """Every described symbol, in sorted, deterministic order -- chs_abi_version
-    INCLUDED, even though _loader.py's step 3 (resolve_abi_version) already
-    resolved it before this runs: the test-only invoke_by_name() dispatcher
-    below needs every symbol reachable through ONE Api, handshake class
-    included, and re-resolving an already-present symbol is harmless (by the
-    time step 6 runs, step 3 has already proven it exists). The first symbol
-    ctypes cannot dlsym raises MissingSymbol(name); _loader.py's step 6 turns
-    that into "missing_symbol:<name>", matching every missing-<sym> stub
-    variant (tests/fixtures/abi-v2/cases.json), chs_build_info and
-    chs_clickhouse_version included -- loader step 4 needs chs_build_info
-    already resolved, which is exactly why this sweep must run before it."""
+    """Every described symbol, in sorted, deterministic order -- the handshake
+    symbols INCLUDED, even though _loader.py's steps 3 and 4 (resolve_abi_version,
+    resolve_build_info) already resolved theirs before this runs: the test-only
+    invoke_by_name() dispatcher below needs every symbol reachable through ONE
+    Api, and re-resolving an already-present symbol is harmless. The first
+    symbol ctypes cannot dlsym raises MissingSymbol(name); _loader.py's step 6
+    turns that into "missing_symbol:<name>", matching every missing-<sym> stub
+    variant. Step 6 runs AFTER step 4's fingerprint comparison, so a library
+    with another fingerprint is refused with rule r6's message first."""
     raw: dict = {}
     for name in ALL_SYMBOLS:
         try:

{chtypes-2.0.0.dev0 → chtypes-2.0.0.dev2}/src/chtypes/_abi2/_errmap.py

@@ -1,4 +1,4 @@
-# GENERATED by scripts/abi-v1/gen.py --major 2 from spec/abi-v2/abi.json (CHS_ABI_FINGERPRINT sha256:8ec0c6941f000aa07bfb9fbfef20205d3ee0a588833856bd12270ba42912bfb3) — DO NOT EDIT  # noqa: E501
+# GENERATED by scripts/abi-v1/gen.py --major 2 from spec/abi-v2/abi.json (CHS_ABI_FINGERPRINT sha256:d87e91be2bbe75b985c38224268c2f7dc5d8236dab0a4b4d61357c6dfdc1a232) — DO NOT EDIT  # noqa: E501
 """spec/abi-v2/sdk.json's error-mapping tables, as references to the
 public classes (python/src/chtypes/errors.py, re-exported by
 python/src/chtypes/_abi2/_errors.py). Only the MAPPING is generated: the

{chtypes-2.0.0.dev0 → chtypes-2.0.0.dev2}/src/chtypes/_abi2/_loader.py

@@ -9,15 +9,20 @@ wired up; `predicate` is passed through exactly as that seam promises.
 Every `chs_*` spelling in this module is forbidden by
 scripts/abi-v1/check-no-hand-decls.py (it is not a generated file), so this
 calls ONLY python/src/chtypes/_abi2/_decls.py's non-`chs_`-prefixed surface:
-`resolve_abi_version()`, `resolve_all()`, and the `Api` object they return.
-
-Steps 1-6 run in the order plan section 3.2 gives (with step 6's full
-resolve-all sweep run right after step 3, BEFORE step 4's
-`chs_build_info()` call -- step 4 needs that symbol already resolved, and
-`tests/fixtures/abi-v2/cases.json`'s `missing-chs_build_info` and
-`missing-chs_clickhouse_version` stub variants both expect the step 6
-`missing_symbol:<name>` reason, not a step 4 one, which is only possible if
-the full symbol sweep happens before chs_build_info is ever called). Step 7
+`resolve_abi_version()`, `resolve_build_info()`, `resolve_all()`, and the `Api` object they return.
+
+Steps 1-7 run in the documented order, the order Go, TypeScript and Rust
+run: glibc (1), dlopen (2), `chs_abi_version` alone (3), `chs_build_info`
+alone, parsed strictly and its fingerprint compared (4: rule r6's exact
+message wins here), the signed-statement cross-check (5), and only then the
+resolve-every-declared-symbol sweep (6). A library with another fingerprint
+that also lacks a symbol this SDK declares (every fingerprint move that adds
+an export meets one) is therefore refused with r6's message, never as
+`missing_symbol:<name>` (public issue #537; the stub variant
+`fingerprint-other-missing-symbol`). A symbol missing from step 4's own
+`chs_build_info` is still `missing_symbol:chs_build_info`, and
+`tests/fixtures/abi-v2/cases.json`'s other `missing-<sym>` variants still
+expect `missing_symbol:<name>` from step 6. Step 7
 calls the image's once-per-image zone setup (empty zone = UTC unless the
 caller supplies one) and then its default settings.
 """
@@ -198,15 +203,15 @@ def _open(
     if version != _decls.CHS_ABI_VERSION:
         _refuse("abi_version", path, want=_decls.CHS_ABI_VERSION, got=version)
 
+    # Step 4: chs_build_info ALONE, parsed strictly, then the fingerprint
+    # compared. Rule r6 is decided here, before the step 6 sweep can name a
+    # missing symbol instead (#537).
     try:
-        api = _decls.resolve_all(lib)
+        build_info_fn = _decls.resolve_build_info(lib)
     except _decls.MissingSymbol as e:
         _refuse(f"missing_symbol:{e.name}", path, want=e.name, got=None)
-        # _refuse always raises; the following line only satisfies a type
-        # checker that cannot see that. (Never reached.)
-        raise
-
-    raw = api.build_info()
+        raise  # never reached: _refuse always raises
+    raw = build_info_fn()
     if raw is None:
         _refuse("build_info_malformed", path, got="chs_build_info() returned NULL")
     info = _parse_build_info(raw, path)
@@ -214,9 +219,17 @@ def _open(
     if info["abi_fingerprint"] != _decls.CHS_ABI_FINGERPRINT:
         _refuse_fingerprint(path, info.get("abi_fingerprint"))
 
+    # Step 5: the signed predicate against build_info.
     if not skip_step5:
         _cross_check(info, predicate, path)
 
+    # Step 6: resolve every declared symbol.
+    try:
+        api = _decls.resolve_all(lib)
+    except _decls.MissingSymbol as e:
+        _refuse(f"missing_symbol:{e.name}", path, want=e.name, got=None)
+        raise  # never reached: _refuse always raises
+
     # Step 7: the once-per-image setup (docs/reference/bindings-v1.md section
     # 6): the image zone (empty = UTC), then the default settings when there
     # are any. After every handshake check and before any other call. A

{chtypes-2.0.0.dev0 → chtypes-2.0.0.dev2}/src/chtypes/_abi2/_vocab.py

@@ -1,4 +1,4 @@
-# GENERATED by scripts/abi-v1/gen.py --major 2 from spec/abi-v2/abi.json (CHS_ABI_FINGERPRINT sha256:8ec0c6941f000aa07bfb9fbfef20205d3ee0a588833856bd12270ba42912bfb3) — DO NOT EDIT  # noqa: E501
+# GENERATED by scripts/abi-v1/gen.py --major 2 from spec/abi-v2/abi.json (CHS_ABI_FINGERPRINT sha256:d87e91be2bbe75b985c38224268c2f7dc5d8236dab0a4b4d61357c6dfdc1a232) — DO NOT EDIT  # noqa: E501
 """The Python binding's generated vocabularies, from spec/abi-v2/abi.json: the C
 enums (`Format`, `Status`), the document vocabularies (`Outcome`, `FilterOutcome`,
 `Verdict`, `DefaultKind`, `Reason`, `Source`, `DiscoverQueryParam`) with the facts the

{chtypes-2.0.0.dev0 → chtypes-2.0.0.dev2}/src/chtypes/_decode.py

@@ -47,6 +47,8 @@ from .results import (
     Header,
     RowResult,
     SchemaDescription,
+    SchemaReplicated,
+    SchemaServer,
     Span,
     Transform,
     Value,
@@ -449,10 +451,55 @@ def _column(obj: dict[str, Any], where: str) -> Column:
     )
 
 
+def _string_map(obj: Mapping[str, Any], key: str, where: str) -> dict[str, str] | None:
+    """An object of plain JSON strings (a server's settings or macros, the
+    caller's own values given back): None when absent, a dict, even an empty
+    one, when present, so absent and `{}` stay apart."""
+    value = obj.get(key)
+    if value is None:
+        return None
+    inner = _obj(value, where, key)
+    out: dict[str, str] = {}
+    for name, item in inner.items():
+        if not isinstance(item, str):
+            raise _wrong(f"{where}.{key}", name, "a string", item)
+        out[name] = item
+    return out
+
+
+def _server(obj: dict[str, Any], where: str) -> SchemaServer:
+    return SchemaServer(
+        timezone=_text(obj, "timezone", where),
+        settings=_string_map(obj, "settings", where) or {},
+        macros=_string_map(obj, "macros", where),
+    )
+
+
+def _replicated(obj: dict[str, Any], where: str) -> SchemaReplicated:
+    return SchemaReplicated(
+        zookeeper_path=_bytes(obj, "zookeeper_path", where),
+        replica_name=_bytes(obj, "replica_name", where),
+    )
+
+
 def decode_schema_description(raw: bytes) -> SchemaDescription:
     where = "schema_description"
     obj = _obj(strict_loads(raw, where), where)
-    return SchemaDescription(columns=_objects(obj, "columns", where, _column))
+    # Both are absent on a schema compiled without a server, so that document
+    # decodes exactly as it did before servers existed.
+    server = obj.get("server")
+    replicated = obj.get("replicated")
+    return SchemaDescription(
+        columns=_objects(obj, "columns", where, _column),
+        server=None
+        if server is None
+        else _server(_obj(server, where, "server"), f"{where}.server"),
+        replicated=(
+            None
+            if replicated is None
+            else _replicated(_obj(replicated, where, "replicated"), f"{where}.replicated")
+        ),
+    )
 
 
 def _discovered(obj: dict[str, Any], where: str) -> DiscoveredColumn:

{chtypes-2.0.0.dev0 → chtypes-2.0.0.dev2}/src/chtypes/_input.py

@@ -12,10 +12,11 @@ from __future__ import annotations
 import base64
 import json
 from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
 
 from .errors import misuse
 
-__all__ = ["BytesIn", "Settings"]
+__all__ = ["BytesIn", "ServerProfile", "Settings"]
 
 BytesIn = bytes | str
 Settings = Mapping[str, str]
@@ -107,3 +108,43 @@ def columns_json(columns: Sequence[BytesIn] | None) -> bytes | None:
         except UnicodeDecodeError:
             names.append({"name_b64": base64.b64encode(raw).decode("ascii")})
     return _dump(names)
+
+
+@dataclass(frozen=True, slots=True)
+class ServerProfile:
+    """One ClickHouse server, as the library's `input:server_profile` describes
+    it. Every field is optional and passed through as given: the library
+    validates the zone with DateLUT, each setting with the server's own SET
+    check, and the macros with ClickHouse's own reader. The binding validates
+    nothing in it.
+
+    `timezone` is the server's zone, the one its `timezone()` returns; None or
+    "" leaves it undescribed (omitted) and the image zone applies. `settings` is
+    what the server's profile applies to every query, layered under a schema's
+    and a call's own; None omits it, and `{}` is sent as `{}`. `macros` is the
+    server's `<macros>`: None omits it, and the server's macros are UNKNOWN (a
+    schema whose engine reads one is declined); a mapping, even an empty one, is
+    sent (`{}` when empty) and is the server's COMPLETE set."""
+
+    timezone: str | None = None
+    settings: Settings | None = None
+    macros: Settings | None = None
+
+
+def server_profile_json(profile: ServerProfile) -> bytes:
+    """The profile document: an empty or absent zone and an absent map are
+    omitted; a present map is sent as given, `{}` when empty. Absent `macros` is
+    not empty `macros`."""
+    if not isinstance(profile, ServerProfile):
+        raise TypeError(f"profile must be a ServerProfile, not {type(profile).__name__}")
+    doc: dict[str, object] = {}
+    if profile.timezone is not None:
+        if not isinstance(profile.timezone, str):
+            raise TypeError(f"timezone must be str, not {type(profile.timezone).__name__}")
+        if profile.timezone != "":
+            doc["timezone"] = profile.timezone
+    if profile.settings is not None:
+        doc["settings"] = _string_map(profile.settings, "settings")
+    if profile.macros is not None:
+        doc["macros"] = _string_map(profile.macros, "macros")
+    return _dump(doc)

{chtypes-2.0.0.dev0 → chtypes-2.0.0.dev2}/src/chtypes/_ocifetch/_channel.py

@@ -69,6 +69,10 @@ DEV_KEY_ID: Final = "824345f9bcf8e5bf"
 DEV_KEY_HEX: Final = "5cd30c53c65a1ebc2d85836a41deb06661bb0ae7b658adb9eb116ec2db8e9b1c"
 # The dev channel's cache directory name: the default root's last element and
 # an explicit cache's subroot (rule r5).
+# The environment twin of the offline option (public issue #528): CHTYPES_OFFLINE=1
+# reads the cache only and makes no request. It names no source, so rule r6 holds.
+# Not a generated constant: the generated set is the v1 fetch contract's.
+ENV_OFFLINE_NAME: Final = "CHTYPES_OFFLINE"
 DEV_CACHE_DIR: Final = "v2-dev"
 # The verified.json schema the dev channel writes, and the only one it reads (rule r5).
 DEV_RECORD_SCHEMA: Final = 2

{chtypes-2.0.0.dev0 → chtypes-2.0.0.dev2}/src/chtypes/_ocifetch/_ensure.py

@@ -137,6 +137,8 @@ class Options:
     token: str | None = None
     trusted_keys: tuple[TrustedKey, ...] | None = None
     allow_unsigned: bool = False
+    # Offline mode is on when this is set OR CHTYPES_OFFLINE=1; neither turns
+    # the other off (public issue #528).
     offline: bool = False
     frozen: bool = False
     lock_path: str | os.PathLike[str] | None = None
@@ -185,6 +187,9 @@ class Options:
     def resolved_platform(self) -> str:
         return self.platform or detect_host_platform()
 
+    def resolved_offline(self) -> bool:
+        return self.offline or os.environ.get(_channel.ENV_OFFLINE_NAME) == "1"
+
     def resolved_strict(self) -> bool:
         if self.strict_cache is not None:
             return self.strict_cache
@@ -1012,7 +1017,7 @@ def _ensure(
     request: Request, platform_key: str, options: Options, lock: Lock | None, roots: Sequence[Path]
 ) -> Resolved:
     try:
-        if options.offline:
+        if options.resolved_offline():
             resolved = resolve_installed(request, platform_key, options)
             if resolved is None:
                 raise ArtifactMissingError(