"""Check a built SSP (output of build_ssp.py). Read-only; prints a report and exits non-zero on any failure. usage: python -I scripts/validate_ssp.py [build/ssp] Checks 1. every file has exactly the shared schema (same column names and types) 2. per row: every per-residue column as long as the sequence; label alphabets (H E C / G H I B E S T C / + P); ss3 = TAPE's 8->3 reduction of ss8; ss8 = ss8_pp with P replaced by C, T or S; resolved = 0 -> labelled C; rcsb/casp: resolved = 1 -> backbone N, CA, C, O present 3. rcsb/casp: no duplicate sequences within a file (tape: duplicates reported, kept as TAPE has them) 4. tape: identical to TAPE's files (same rows in the same order; every field equal; only ints -> letters) 5. rcsb CASP12: TAPE's 21 chains present (in_tape) and labels agree with TAPE (>= 99.9% on resolved residues) 6. coverage: every CASP-listed target is in an rcsb row or logged as dropped (with a reason) 7. summary: rows per file, dropped targets by reason, polyproline handling Results are saved to {out}/logs/validation.json. """ import os, sys, json, glob, collections sys.path.insert(0, "scripts") import pyarrow.parquet as pq import ssp_lib as L OUT = sys.argv[1] if len(sys.argv) > 1 else "build/ssp" TAPE_DIR = "data/original/tape/secondary_structure/secondary_structure" TAPE_FILES = {"train": "secondary_structure_train.json", "validation": "secondary_structure_valid.json", "cb513": "secondary_structure_cb513.json", "ts115": "secondary_structure_ts115.json", "casp12": "secondary_structure_casp12.json"} PER_RESIDUE = ["ss3", "ss8", "ss8_pp", "resolved", "valid_mask", "rsa", "asa_max", "phi", "psi", "interface", "evolutionary", "n_xyz", "ca_xyz", "c_xyz", "o_xyz", "cb_xyz"] fail, results = [], {"checks": []} def check(ok, msg): print((" ok " if ok else " FAIL ") + msg, flush=True) results["checks"].append({"ok": bool(ok), "check": msg}) if not ok: fail.append(msg) def rows_of(name, batch=200): for b in pq.ParquetFile(f"{OUT}/{name}").iter_batches(batch_size=batch): yield from b.to_pylist() files = sorted(os.path.relpath(f, OUT) for f in glob.glob(f"{OUT}/*/*.parquet")) meta = {k: pq.ParquetFile(f"{OUT}/{k}") for k in files} print(f"== {len(files)} files in {OUT}: {files}") # 1. schema first = next(iter(meta.values())).schema_arrow check(all(m.schema_arrow.equals(first) for m in meta.values()), "all files share one schema (names and types)") # 2-3. per-row consistency and duplicates S3OF = L.SS8_TO_SS3 for name in files: bad, seqs, ids, n = collections.Counter(), collections.Counter(), collections.Counter(), 0 for r in rows_of(name): n += 1 L_ = len(r["sequence"]) seqs[r["sequence"]] += 1; ids[r["id"]] += 1 bad["length"] += any(r[c] is not None and len(r[c]) != L_ for c in PER_RESIDUE) bad["no_resolved"] += r["resolved"] is None bad["alphabet"] += not (set(r["ss3"]) <= set("HEC") and set(r["ss8"]) <= set("GHIBESTC") and (r["ss8_pp"] is None or set(r["ss8_pp"]) <= set("GHIBESTCP"))) bad["ss3_from_ss8"] += any(S3OF[a] != b for a, b in zip(r["ss8"], r["ss3"]) if a in S3OF) if r["ss8_pp"] is not None: bad["ss8_from_ss8_pp"] += any(p != c and not (p == "P" and c in "CTS") for p, c in zip(r["ss8_pp"], r["ss8"])) if r["resolved"] is not None: bad["unresolved_not_C"] += any(m == 0 and (s != "C" or (r["ss8_pp"] or "C" * L_)[k] != "C") for k, (m, s) in enumerate(zip(r["resolved"], r["ss8"]))) if r["ca_xyz"] is not None: # rcsb / casp: DSSP labels only residues with a complete backbone bad["resolved_without_backbone"] += sum( 1 for k, m in enumerate(r["resolved"]) if m == 1 and any(r[f"{a}_xyz"][k] is None for a in ("n", "ca", "c", "o"))) dup = sum(v - 1 for v in seqs.values()) if name.startswith("tape/"): check(not any(bad.values()), f"{name}: {n} rows, consistent ({dict(+bad) or 'no problems'}); " f"kept as in TAPE: {dup} repeated sequences, {sum(v - 1 for v in ids.values())} repeated ids") else: check(not any(bad.values()) and dup == 0, f"{name}: {n} rows, consistent ({dict(+bad) or 'no problems'}), duplicate sequences: {dup}") # 4. tape == TAPE, field by field, in TAPE's order for split, fn in TAPE_FILES.items(): name = f"tape/{split}.parquet" if name not in meta: continue src = json.load(open(f"{TAPE_DIR}/{fn}")) diff, k = collections.Counter(), -1 for k, r in enumerate(rows_of(name)): s = src[k] diff["id"] += r["id"] != s["id"] diff["sequence"] += r["sequence"] != s["primary"] diff["ss8"] += r["ss8"] != "".join("GHIBESTC"[c] for c in s["ss8"]) diff["ss3"] += r["ss3"] != "".join("HEC"[c] for c in s["ss3"]) diff["resolved=disorder"] += r["resolved"] != s["disorder"] for f in ("valid_mask", "rsa", "asa_max", "phi", "psi", "interface", "evolutionary"): diff[f] += r[f] != s[f] src[k] = None diff["row_count"] += k + 1 != len(src) del src check(not any(diff.values()), f"{name}: identical to TAPE's {fn} ({k + 1} rows; differences: {dict(+diff) or 'none'})") # 5. rcsb CASP12 vs TAPE if "rcsb/casp12.parquet" in meta: tape_src = {r["id"]: r for r in json.load(open(f"{TAPE_DIR}/{TAPE_FILES['casp12']}"))} rr = {r["id"]: r for r in rows_of("rcsb/casp12.parquet")} in_tape = {i for i, r in rr.items() if r["in_tape"]} check(in_tape == set(tape_src), f"rcsb/casp12: TAPE's 21 chains present and flagged in_tape ({len(in_tape)})") from compare_ss_tools_helpers import project n = same = 0 flag = collections.Counter() # TAPE's disorder flag vs whether the residue has structure in today's PDB entry for i in in_tape: s = tape_src[i] lab, _ = project(s["primary"], rr[i]["sequence"], list(zip(rr[i]["ss8"], rr[i]["resolved"]))) for k, d in enumerate(s["disorder"]): flag[f"tape_disorder_{d}__pdb_" + ("not_aligned" if lab[k] is None else f"resolved_{lab[k][1]}")] += 1 if d == 1 and lab[k] is not None and lab[k][1] == 1: n += 1; same += lab[k][0] == "GHIBESTC"[s["ss8"][k]] results["rcsb_casp12_vs_tape"] = {"residues": n, "agree": same, "disorder_flag_vs_pdb": dict(flag)} print(" TAPE disorder flag vs structure in today's PDB entry:", dict(flag)) check(n > 0 and same / n >= 0.999, f"rcsb/casp12: labels agree with TAPE on {100 * same / max(n, 1):.2f}% of {n:,} residues resolved in both") # 6. coverage of CASP-listed targets by rcsb rows for f in sorted(glob.glob(f"{OUT}/logs/rcsb_casp*.json")): log = json.load(open(f)) split = log["split"] if f"rcsb/{split}.parquet" not in meta: continue listed = {t for t, c in L.listed_targets(f"data/original/{split}").items() if c} covered = {t for r in rows_of(f"rcsb/{split}.parquet") for t in r["casp_targets"]} dropped_ids = {d["id"] for d in log["dropped"]} deduped_targets = set() # targets whose whole row was dropped as a duplicate for d in log["dropped"]: if "-" in d["id"]: deduped_targets |= {t for t, v in log["targets"].items() if f"{v['pdb']}-{v['chain']}" == d["id"]} missing = listed - covered - dropped_ids - deduped_targets check(not missing, f"rcsb/{split}: all {len(listed)} CASP-listed targets covered or logged ({len(covered)} in rows)" + (f"; unaccounted: {sorted(missing)}" if missing else "")) # 7. summary print("\n== summary") for f in sorted(glob.glob(f"{OUT}/logs/*_*.json")): log = json.load(open(f)) if "split" not in log: continue key = f"{log['source']}/{log['split']}.parquet" if log.get("source") is None: continue reasons = collections.Counter(d["reason"].split(" as ")[0] if d["reason"].startswith("same sequence") else d["reason"] for d in log["dropped"]) print(f" {key:26s} rows {meta[key].metadata.num_rows if key in meta else '-':>5} | dropped {len(log['dropped'])}: {dict(reasons)} | polyproline {log.get('polyproline') or '-'}") print(f"\n{'ALL CHECKS PASSED' if not fail else f'{len(fail)} CHECK(S) FAILED'}") import datetime results.update(passed=not fail, date=datetime.date.today().isoformat()) json.dump(results, open(f"{OUT}/logs/validation.json", "w"), indent=1) sys.exit(1 if fail else 0)