| |
| |
| |
|
|
| """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) |
|
|
