#!/usr/bin/env python3 """Canonicalize a revision-pinned Parquet holdout with a pinned DuckDB CLI.""" from __future__ import annotations import argparse import gzip import hashlib import hmac import json import os import re import stat import subprocess import tempfile from pathlib import Path from typing import Any, TextIO ROOT = Path(__file__).resolve().parents[1] PRIVATE_ROOT = ROOT / ".gate" / "ctx-ab-private" SHA256 = re.compile(r"^[0-9a-f]{64}$") def _sha256(path: Path) -> str: return hashlib.sha256(path.read_bytes()).hexdigest() def _sql_path(path: Path) -> str: return str(path.resolve()).replace("'", "''") def _private_text_handle(path: Path) -> TextIO: resolved = path.resolve(strict=False) private_root = PRIVATE_ROOT.resolve() if ROOT.resolve() in resolved.parents and private_root not in resolved.parents: raise ValueError("holdout evidence inside the repository must use .gate/ctx-ab-private") path.parent.mkdir(mode=0o700, parents=True, exist_ok=True) if stat.S_IMODE(path.parent.stat().st_mode) != 0o700: raise ValueError("holdout evidence parent must be owner-only") if path.is_symlink() or (path.exists() and not path.is_file()): raise ValueError("holdout evidence path must be a regular file") if path.exists() and path.stat().st_nlink != 1: raise ValueError("holdout evidence path must not be a hard link") if path.exists(): path.chmod(0o600) flags = os.O_WRONLY | os.O_CREAT | os.O_TRUNC if hasattr(os, "O_NOFOLLOW"): flags |= os.O_NOFOLLOW descriptor = os.open(path, flags, 0o600) os.fchmod(descriptor, 0o600) return os.fdopen(descriptor, "w", encoding="utf-8", newline="") def _paths_are_distinct(paths: list[Path]) -> bool: for index, left in enumerate(paths): for right in paths[index + 1 :]: if left.resolve(strict=False) == right.resolve(strict=False): return False if left.exists() and right.exists() and os.path.samefile(left, right): return False return True def _canonicalize_duckdb_rows( raw_jsonl: str, *, required_columns: list[str], expected_rows: int, ) -> str: rows: list[dict[str, str]] = [] for expected_index, line in enumerate(raw_jsonl.splitlines()): item = json.loads(line) if ( not isinstance(item, dict) or list(item) != ["row_idx", *required_columns] or item["row_idx"] != expected_index or not all(isinstance(item[column], str) for column in required_columns) ): raise ValueError("DuckDB Parquet row is not canonical") rows.append({column: item[column] for column in required_columns}) if len(rows) != expected_rows: raise ValueError("DuckDB Parquet row count does not match the frozen universe") return "".join( json.dumps(row, ensure_ascii=False, separators=(",", ":")) + "\n" for row in rows ) def _authenticated_protocol( data: bytes, *, expected_sha256: str | None, ) -> dict[str, Any]: if expected_sha256 is not None and SHA256.fullmatch(expected_sha256) is None: raise SystemExit("expected acquisition protocol SHA-256 must be 64 lowercase hex digits") if expected_sha256 is not None and not hmac.compare_digest( hashlib.sha256(data).hexdigest(), expected_sha256, ): raise SystemExit("acquisition protocol does not match the expected SHA-256") protocol: dict[str, Any] = json.loads(data) if ( protocol.get("schema_version") == 2 or protocol.get("protocol_id") == "production-graph-holdout-v2" ) and expected_sha256 is None: raise SystemExit("V2 acquisition requires --expected-acquisition-protocol-sha256") return protocol def canonicalize_parquet( parquet_path: Path, duckdb_gzip_path: Path, *, required_columns: list[str], expected_rows: int, expected_gzip_sha256: str, expected_version: str, private_root: Path, ) -> tuple[str, str]: if _sha256(duckdb_gzip_path) != expected_gzip_sha256: raise ValueError("DuckDB CLI gzip does not match the frozen SHA-256") private_root.mkdir(mode=0o700, parents=True, exist_ok=True) if stat.S_IMODE(private_root.stat().st_mode) != 0o700: raise ValueError("acquisition work directory must be owner-only") with tempfile.TemporaryDirectory(dir=private_root) as temporary: temp = Path(temporary) duckdb = temp / "duckdb" with gzip.open(duckdb_gzip_path, "rb") as source: duckdb.write_bytes(source.read()) duckdb.chmod(0o700) environment = { "HOME": str(temp), "XDG_CONFIG_HOME": str(temp), "TMPDIR": str(temp), "PATH": os.environ.get("PATH", "/usr/bin:/bin"), "LANG": "C", "LC_ALL": "C", } version = subprocess.run( [str(duckdb), "-version"], check=True, capture_output=True, text=True, timeout=30, env=environment, ).stdout.split(maxsplit=1)[0] if version != expected_version: raise ValueError("DuckDB CLI version does not match the frozen version") raw_json = temp / "rows.jsonl" columns = ", ".join( f'"{column.replace(chr(34), chr(34) * 2)}"' for column in required_columns ) query = ( "SET threads=1; COPY (SELECT file_row_number AS row_idx, " f"{columns} FROM read_parquet('{_sql_path(parquet_path)}', " "file_row_number=true) ORDER BY file_row_number) " f"TO '{_sql_path(raw_json)}' (FORMAT JSON);" ) subprocess.run( [str(duckdb), "-no-stdin", "-c", query], check=True, capture_output=True, text=True, timeout=120, env=environment, ) canonical = _canonicalize_duckdb_rows( raw_json.read_text(encoding="utf-8"), required_columns=required_columns, expected_rows=expected_rows, ) return canonical, _sha256(duckdb) def main(argv: list[str] | None = None) -> int: parser = argparse.ArgumentParser() parser.add_argument("--protocol", type=Path, required=True) parser.add_argument("--expected-acquisition-protocol-sha256") parser.add_argument("--parquet", type=Path, required=True) parser.add_argument("--duckdb-gzip", type=Path, required=True) parser.add_argument("--output", type=Path, required=True) args = parser.parse_args(argv) if not _paths_are_distinct([args.protocol, args.parquet, args.duckdb_gzip, args.output]): raise SystemExit("canonical output must not overwrite an acquisition input") protocol = _authenticated_protocol( args.protocol.read_bytes(), expected_sha256=args.expected_acquisition_protocol_sha256, ) universe = protocol["universe"] if SHA256.fullmatch(str(universe["duckdb_cli_gzip_sha256"])) is None: raise SystemExit("protocol DuckDB gzip SHA-256 is invalid") frozen_parquet = universe.get("raw_parquet_sha256") frozen_duckdb = universe.get("duckdb_cli_sha256") frozen_jsonl = universe.get("selection_jsonl_sha256") if protocol.get("stage") not in { "acquisition-preregistered", "acquisition-frozen", "execution-frozen", }: raise SystemExit("protocol acquisition stage is invalid") if protocol.get("stage") in {"acquisition-frozen", "execution-frozen"} and any( SHA256.fullmatch(str(value or "")) is None for value in (frozen_parquet, frozen_duckdb, frozen_jsonl) ): raise SystemExit("frozen acquisition requires Parquet, DuckDB, and JSONL SHA-256") if protocol.get("stage") == "acquisition-preregistered" and any( value is not None for value in (frozen_parquet, frozen_duckdb, frozen_jsonl) ): raise SystemExit("preregistered acquisition hashes must remain null") if frozen_parquet and _sha256(args.parquet) != frozen_parquet: raise SystemExit("Parquet does not match the frozen SHA-256") canonical, duckdb_sha256 = canonicalize_parquet( args.parquet, args.duckdb_gzip, required_columns=universe["required_columns"], expected_rows=universe["expected_rows"], expected_gzip_sha256=universe["duckdb_cli_gzip_sha256"], expected_version=universe["duckdb_version"], private_root=args.output.parent, ) if frozen_duckdb and duckdb_sha256 != frozen_duckdb: raise SystemExit("DuckDB CLI does not match the frozen SHA-256") canonical_bytes = canonical.encode() if frozen_jsonl and hashlib.sha256(canonical_bytes).hexdigest() != frozen_jsonl: raise SystemExit("canonical JSONL does not match the frozen SHA-256") with _private_text_handle(args.output) as handle: handle.write(canonical) print(json.dumps({"duckdb_cli_sha256": duckdb_sha256}, sort_keys=True)) return 0 if __name__ == "__main__": raise SystemExit(main())