#!/usr/bin/env python3 # Copyright 2026 Emile de Bruyn # SPDX-License-Identifier: Apache-2.0 """Validate the immutable published artifacts without third-party dependencies.""" import csv import hashlib import json import re import sys from pathlib import Path ROOT = Path(__file__).resolve().parents[1] SEGMENT = re.compile(r"^([A-Za-z0-9])(\d+)(?:-(\d+))?$") GAP = re.compile(r"^(\d+)(?:-(\d+))?$") CORRECTED_FILES = {"cluster_membership.csv", "contigs.csv", "contig_specifications.csv"} def table(name): with (ROOT / name).open(newline="") as handle: return list(csv.DictReader(handle)) def residues(spec): result = set() for token in filter(None, spec.split(";")): match = SEGMENT.fullmatch(token) if not match: raise ValueError(f"invalid residue segment {token!r}") chain, first, last = match.groups() start, end = int(first), int(last or first) if start > end: raise ValueError(f"reversed residue segment {token!r}") segment = {(chain, i) for i in range(start, end + 1)} if result & segment: raise ValueError(f"overlapping residue segment {token!r}") result.update(segment) return result def pdb_residues(path): found = set() ca = set() with path.open() as handle: for line in handle: if line.startswith("ATOM "): if len(line) < 54 or line[26] != " ": raise ValueError(f"{path.name}: malformed ATOM or insertion code") key = (line[21], int(line[22:26])) for start in (30, 38, 46): float(line[start:start + 8]) found.add(key) if line[12:16].strip() == "CA": ca.add(key) if not found or found != ca: raise ValueError(f"{path.name}: missing ATOM records or CA atoms") return found def ca_coordinates(path): coordinates = {} with path.open() as handle: for line in handle: if line.startswith("ATOM ") and line[12:16].strip() == "CA": key = (line[21], int(line[22:26])) xyz = tuple(float(line[i:i + 8]) for i in (30, 38, 46)) coordinates.setdefault(key, set()).add(xyz) return coordinates def historical_bytes(path, data): """Reverse only the documented changes to compare to the submission.""" if path == "cluster_membership.csv": lines = data.splitlines(keepends=True) converted = [lines[0]] for line in lines[1:]: fields = line.split(b",") fields[1] = re.sub(rb"_c(\d+)$", rb"_v\1", fields[1]) converted.append(b",".join(fields)) return b"".join(converted) if path in {"contigs.csv", "contig_specifications.csv"}: lines = data.splitlines(keepends=True) changed = 0 for index, line in enumerate(lines): if line.startswith(b"1A22_PS01352_c1,"): expected = 2 if path == "contig_specifications.csv" else 1 if line.count(b"21-25") != expected: raise ValueError(f"{path}: unexpected corrected contig") lines[index] = line.replace(b"21-25", b"25-25") changed += 1 if changed != 1: raise ValueError(f"{path}: expected exactly one corrected case") return b"".join(lines) return data def validate(): cases = table("test_cases.csv") metadata = table("motif_cases_metadata_croissant.csv") contigs = table("contigs.csv") specs = table("contig_specifications.csv") clusters = table("cluster_membership.csv") assert len(cases) == len(metadata) == len(contigs) == len(specs) == 220 assert len({r["motif_entry"] for r in metadata}) == 174 ids = [r["pdb_id"] for r in cases] assert len(set(ids)) == 220 for rows, key in ((metadata, "benchmark_pdb_id"), (contigs, "benchmark_pdb_id"), (specs, "problem")): assert len({r[key] for r in rows}) == 220 and {r[key] for r in rows} == set(ids) assert {r["benchmark_pdb_id"] for r in clusters} == set(ids) meta = {r["benchmark_pdb_id"]: r for r in metadata} spec = {r["problem"]: r for r in specs} assert len({r["case_id"] for r in metadata}) == 220 for row in contigs: assert row["case_id"] == meta[row["benchmark_pdb_id"]]["case_id"] representatives = [r for r in clusters if r["role"] == "representative"] assert len(representatives) == 220 assert {r["benchmark_pdb_id"] for r in representatives} == set(ids) for row in clusters: case = meta[row["benchmark_pdb_id"]] assert row["case_id"] == case["case_id"], row["benchmark_pdb_id"] if row["role"] == "representative": assert row["motif_entry"] == case["motif_entry"] else: assert row["role"] == "member" assert len({(r["benchmark_pdb_id"], r["motif_entry"]) for r in clusters}) == len(clusters) original_contigs = {r["benchmark_pdb_id"]: r["contigs"] for r in contigs} assert {p.stem for p in (ROOT / "motif_pdbs").glob("*.pdb")} == set(ids) assert {p.stem for p in (ROOT / "original_pdbs").glob("*.pdb")} == set(ids) infeasible = [] for row in cases: case = row["pdb_id"] motif = residues(row["motif_residues"]) assert residues(row["redesign_idcs"]) <= motif, case assert motif == residues(meta[case]["motif_segments"]), case assert residues(row["redesign_idcs"]) == residues(meta[case]["redesignable_segments"]), case assert motif == pdb_residues(ROOT / "motif_pdbs" / f"{case}.pdb"), case assert spec[case]["contig_original"] == original_contigs[case], case assert int(spec[case]["length"]) == int(row["length"]), case assert int(meta[case]["motif_length"]) == len(motif), case source_ca = ca_coordinates(ROOT / "original_pdbs" / f"{case}.pdb") motif_ca = ca_coordinates(ROOT / "motif_pdbs" / f"{case}.pdb") original_segments = meta[case]["motif_segments_original"].split(";") normalized_segments = row["motif_residues"].split(";") assert len(original_segments) == len(normalized_segments), case for original, normalized in zip(original_segments, normalized_segments): old, new = sorted(residues(original)), sorted(residues(normalized)) assert len(old) == len(new), case for old_key, new_key in zip(old, new): assert source_ca.get(old_key, set()) & motif_ca.get(new_key, set()), case fixed, minimum, maximum = set(), 0, 0 for token in spec[case]["contig"].split(";"): gap = GAP.fullmatch(token) if gap: lo, hi = gap.groups() minimum += int(lo) maximum += int(hi or lo) assert int(lo) <= int(hi or lo), case else: fixed |= residues(token) assert fixed == motif, case if not minimum + len(motif) <= int(row["length"]) <= maximum + len(motif): infeasible.append(case) if infeasible: raise ValueError(f"infeasible contigs: {infeasible}") with (ROOT / "provenance/huggingface-manifest.json").open() as handle: manifest = {entry["path"]: entry for entry in json.load(handle) if entry["type"] == "file"} with (ROOT / "provenance/release-sha256.txt").open() as handle: release_hashes = dict(line.rstrip("\n").split(" ", 1)[::-1] for line in handle) checked = set() changed = set() with (ROOT / "provenance/published-sha256.txt").open() as handle: for line in handle: expected, path = line.rstrip("\n").split(" ", 1) data = (ROOT / path).read_bytes() if hashlib.sha256(data).hexdigest() != release_hashes[path]: raise ValueError(f"release artifact checksum mismatch: {path}") historical = historical_bytes(path, data) if historical != data: changed.add(path) if hashlib.sha256(historical).hexdigest() != expected: raise ValueError(f"unexpected difference from published artifact: {path}") git_object = hashlib.sha1(b"blob " + str(len(historical)).encode() + b"\0" + historical).hexdigest() entry = manifest[path] if entry["size"] != len(historical) or entry["oid"] != git_object: raise ValueError(f"published Hugging Face object mismatch: {path}") checked.add(path) if checked != set(manifest) - {".gitattributes", "LICENSE", "README.md"}: raise ValueError("published artifact list does not match the Hugging Face manifest") if checked != set(release_hashes) or changed != CORRECTED_FILES: raise ValueError(f"unexpected release artifact list or changed files: {changed}") print("Validated 220 cases, 174 patterns, feasible contigs and 445 release hashes.") print("Historical regression: exactly three documented tables differ from the submission.") if __name__ == "__main__": try: validate() except (AssertionError, ValueError, OSError, KeyError) as exc: print(f"Validation failed: {exc}", file=sys.stderr) sys.exit(1)