"""Build SSP: protein secondary-structure data (training data plus CASP test sets), in three versions with one layout. tape TAPE's files (built by NetSurfP-2.0): train, validation, cb513, ts115, casp12; every field kept, integer labels written as letters, nothing else changed (same rows, order, ids, sequences, values). rcsb CASP12-16 test sets: the PDB entry CASP lists for each target, from RCSB; one row per PDB chain; sequence = the chain's canonical PDB sequence; mkdssp on the whole chain alone. casp CASP12-16 test sets: CASP's own public target files; one row per target; sequence = CASP's target sequence; mkdssp on the target's chain (CASP15: its domain files merged back into one chain; CASP16: first version). Labels, all versions: ss3 = H E C; ss8 = G H I B E S T C (classic DSSP); ss8_pp = ss8 plus P (DSSP 4 polyproline; rcsb and casp only). One letter per residue. As in TAPE, residues without structure are labelled C and have resolved = 0 (TAPE's `disorder`). Columns that don't apply to a version are null (e.g. tape has no coordinates; rcsb/casp have no NetSurfP features). usage: python -I scripts/build_ssp.py [--source tape rcsb casp] [--rounds 12 13 14 15 16] [--tape-splits train validation cb513 ts115 casp12] [--only T0863,...] [--out build/ssp] """ import os, re, sys, glob, json, argparse, collections sys.path.insert(0, "scripts") import pyarrow as pa, pyarrow.parquet as pq import ssp_lib as L TAPE_DIR = "data/original/tape/secondary_structure/secondary_structure" # TAPE's secondary_structure.tar.gz, extracted 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"} ap = argparse.ArgumentParser() ap.add_argument("--source", nargs="+", default=["tape", "rcsb", "casp"], choices=["tape", "rcsb", "casp"]) ap.add_argument("--rounds", nargs="+", default=["12", "13", "14", "15", "16"]) ap.add_argument("--tape-splits", nargs="+", default=list(TAPE_FILES), choices=list(TAPE_FILES)) ap.add_argument("--only", default="", help="comma-separated CASP target ids (testing)") ap.add_argument("--out", default="build/ssp") args = ap.parse_args() ONLY = set(filter(None, args.only.split(","))) RCSB_CACHE = "data/original/rcsb" S8_TAPE, S3_TAPE = "GHIBESTC", "HEC" # TAPE's integer codes; with this decoding mkdssp agrees with TAPE on 99.94% (CASP12) ARCHIVE = { "12": ("casp12.targets_T0.releaseDec022016.tgz", "data/original/casp12/x/**/T*.pdb"), "13": ("casp13.targets.T.4public.tar.gz", "data/original/casp13/x/**/T*.pdb"), "14": ("casp14.targets.T.public_11.29.2020.tar.gz", "data/original/casp14/T/T*.pdb"), "15": ("casp15.targets.TS-domains.public_12.20.2022.tar.gz", "data/original/casp15/x/**/T*.pdb"), "16": ("casp16.targets_monomer.tgz", "data/original/casp16/x/**/T*.pdb"), } xyz = pa.list_(pa.list_(pa.float64())) f32, i8 = pa.list_(pa.float32()), pa.list_(pa.int8()) SCHEMA = pa.schema([ ("id", pa.string()), ("casp_targets", pa.list_(pa.string())), ("target_match", pa.list_(pa.string())), ("target_identity", pa.list_(pa.float64())), ("target_regions", pa.list_(pa.list_(pa.list_(pa.int64())))), ("sequence", pa.string()), ("ss3", pa.string()), ("ss8", pa.string()), ("ss8_pp", pa.string()), ("resolved", i8), ("valid_mask", i8), # NetSurfP-2.0's other per-residue fields, tape only (TAPE's values; all exactly representable in float32) ("rsa", f32), ("asa_max", f32), ("phi", f32), ("psi", f32), ("interface", i8), ("evolutionary", pa.list_(f32)), ("n_xyz", xyz), ("ca_xyz", xyz), ("c_xyz", xyz), ("o_xyz", xyz), ("cb_xyz", xyz), ("pdb_id", pa.string()), ("chain", pa.string()), ("method", pa.string()), ("resolution", pa.float64()), ("release_date", pa.string()), ("pdb_revision_date", pa.string()), ("source_files", pa.list_(pa.string())), ("in_tape", pa.bool_()), ]) def row(**kw): unknown = set(kw) - set(SCHEMA.names) assert not unknown, unknown return {name: kw.get(name) for name in SCHEMA.names} def write(rows, source, split, log, batch=500): """Write rows (any iterable) to {out}/{source}/{split}.parquet in row groups of `batch` rows, and the log.""" os.makedirs(f"{args.out}/{source}", exist_ok=True) os.makedirs(f"{args.out}/logs", exist_ok=True) path = f"{args.out}/{source}/{split}.parquet" n, buf = 0, [] with pq.ParquetWriter(path, SCHEMA, compression="zstd") as w: for r in rows: buf.append(r); n += 1 if len(buf) == batch: w.write_table(pa.Table.from_pylist(buf, schema=SCHEMA)); buf = [] if buf or n == 0: w.write_table(pa.Table.from_pylist(buf, schema=SCHEMA)) log["rows"] = n json.dump(log, open(f"{args.out}/logs/{source}_{split}.json", "w"), indent=1, default=str) print(f" wrote {path}: {n} rows | dropped: {len(log['dropped'])} | polyproline: {dict(log['polyproline'])}", flush=True) def dedupe(rows, log): """One row per identical sequence within a round (first by id); the rest are logged as dropped.""" seen, out = {}, [] for r in sorted(rows, key=lambda r: r["id"]): if r["sequence"] in seen: log["dropped"].append({"id": r["id"], "reason": f"same sequence as {seen[r['sequence']]}"}) continue seen[r["sequence"]] = r["id"] out.append(r) return out def new_log(source, split, **extra): return {"split": split, "source": source, "dssp": L.DSSP_VERSION if source != "tape" else None, "dropped": [], "targets": {}, "polyproline": collections.Counter(), **extra} def map_targets(rnd, log): """CASP-listed PDB code -> the entity/chain matching each target: {target: (code, chain, match, identity, regions)}.""" D = f"data/original/casp{rnd}" listed = {t: c for t, c in L.listed_targets(D).items() if c} seqs = L.target_sequences(rnd, D, sorted(listed)) info = L.entry_info({c for cs in listed.values() for c in cs}, f"{RCSB_CACHE}/entries.json") out = {} for t, codes in sorted(listed.items()): if t not in seqs: log["dropped"].append({"id": t, "reason": "no CASP sequence"}); continue best = None for code in codes: for e in (info.get(code) or {}).get("entities", []): cat, ident, regions = L.match(seqs[t], e["sequence"]) key = (ident, -["byte-identical", "contained", "pieces", "differs"].index(cat)) if best is None or key > best[0]: best = (key, code, sorted(e["chains"])[0], cat, ident, regions) if best is None: log["dropped"].append({"id": t, "reason": f"PDB entry {','.join(codes)} not available from RCSB"}); continue out[t] = best[1:] return out, seqs, info # ---------------------------------------------------------------------------------------------------------- tape def build_tape(split): path = f"{TAPE_DIR}/{TAPE_FILES[split]}" log = new_log("tape", split, source_file=TAPE_FILES[split]) by_chain, seqs = collections.defaultdict(list), {} if split == "casp12": # which CASP12 targets each TAPE chain covers targets, seqs, _ = map_targets("12", new_log("tape", split)) for t, (code, chain, *_rest) in targets.items(): by_chain[f"{code}-{chain}"].append(t) data = json.load(open(path)) def rows(): for k, r in enumerate(data): n = len(r["primary"]) assert r["protein_length"] == n and all(len(r[f]) == n for f in ("ss3", "ss8", "disorder", "valid_mask", "rsa", "asa_max", "phi", "psi", "interface", "evolutionary")), r["id"] assert all(v in (0, 1) for f in ("disorder", "valid_mask", "interface") for v in r[f]), r["id"] # TAPE labels every residue without structure (disorder = 0) as coil assert all(s8 == 7 and s3 == 2 for d, s8, s3 in zip(r["disorder"], r["ss8"], r["ss3"]) if d == 0), r["id"] ts = sorted(by_chain.get(r["id"], [])) matches = [L.match(seqs[t], r["primary"]) for t in ts] pdb, _, chain = r["id"].partition("-") yield row(id=r["id"], casp_targets=ts or None, target_match=[m[0] for m in matches] or None, target_identity=[m[1] for m in matches] or None, target_regions=[m[2] for m in matches] or None, sequence=r["primary"], ss3="".join(S3_TAPE[c] for c in r["ss3"]), ss8="".join(S8_TAPE[c] for c in r["ss8"]), resolved=[int(v) for v in r["disorder"]], valid_mask=[int(v) for v in r["valid_mask"]], rsa=r["rsa"], asa_max=r["asa_max"], phi=r["phi"], psi=r["psi"], interface=[int(v) for v in r["interface"]], evolutionary=r["evolutionary"], pdb_id=pdb or None, chain=chain or None, source_files=[TAPE_FILES[split]], in_tape=True) data[k] = None # free memory as we go (train is 1.4 GB of JSON) write(rows(), "tape", split, log) # ---------------------------------------------------------------------------------------------------------- rcsb def build_rcsb(rnd): log = new_log("rcsb", f"casp{rnd}") targets, seqs, info = map_targets(rnd, log) chains = collections.defaultdict(list) for t, (code, chain, cat, ident, regions) in targets.items(): if ONLY and t not in ONLY: continue chains[(code, chain)].append((t, cat, ident, regions)) log["targets"][t] = {"pdb": code, "chain": chain, "match": cat, "identity": ident} tape_ids = {r["id"] for r in json.load(open(f"{TAPE_DIR}/{TAPE_FILES['casp12']}"))} if rnd == "12" else set() rows = [] for (code, chain), ts in sorted(chains.items()): cif = L.download_cif(code, RCSB_CACHE) st, seq, residues = L.rcsb_chain(cif, chain) labels, pp = L.dssp(residues, st.cell) log["polyproline"].update(pp) ss3, ss8, ss8_pp, resolved = L.label_strings(len(seq), labels) xyz_ = L.coordinates(len(seq), residues) ts.sort() rows.append(row(id=f"{code}-{chain}", casp_targets=[t for t, *_ in ts], target_match=[c for _, c, _, _ in ts], target_identity=[i for _, _, i, _ in ts], target_regions=[g for *_, g in ts], sequence=seq, ss3=ss3, ss8=ss8, ss8_pp=ss8_pp, resolved=resolved, **{f"{a.lower()}_xyz": xyz_[a] for a in L.ATOMS}, pdb_id=code, chain=chain, method=info[code]["method"], resolution=info[code]["resolution"], release_date=info[code]["release_date"], pdb_revision_date=L.latest_revision(cif), source_files=[f"{code}.cif.gz"], in_tape=f"{code}-{chain}" in tape_ids)) write(dedupe(rows, log), "rcsb", f"casp{rnd}", log) # ---------------------------------------------------------------------------------------------------------- casp def base_target(name): """File name -> target id: drop CASP15 domain suffix (-D1) and CASP16 version suffix (v1, _v1).""" return re.sub(r"(_?v\d+)$", "", re.sub(r"-D\d+$", "", name)) def build_casp(rnd): D = f"data/original/casp{rnd}" archive, pattern = ARCHIVE[rnd] files = collections.defaultdict(list) for p in sorted(glob.glob(pattern, recursive=True)): files[base_target(os.path.basename(p)[:-4])].append(p) listed = L.listed_targets(D) log = new_log("casp", f"casp{rnd}", archive=archive) tape_targets = set() if rnd == "12": tape_ids = {r["id"] for r in json.load(open(f"{TAPE_DIR}/{TAPE_FILES['casp12']}"))} tape_targets = {t for t, (code, chain, *_r) in map_targets(rnd, new_log("casp", "casp12"))[0].items() if f"{code}-{chain}" in tape_ids} targets = sorted(t for t in files if not ONLY or t in ONLY) seqs = L.target_sequences(rnd, D, targets) rows = [] for t in targets: paths = files[t] variants = sorted({re.sub(r"-D\d+$", "", os.path.basename(p)[:-4]) for p in paths}) if len(variants) > 1: # several structures (versions) of one target -> the first version paths = [p for p in paths if re.sub(r"-D\d+$", "", os.path.basename(p)[:-4]) == variants[0]] log["targets"].setdefault(t, {})["versions_ignored"] = variants[1:] seq = seqs.get(t) or seqs.get(variants[0]) or seqs.get(t + "v1") if not seq: log["dropped"].append({"id": t, "reason": "no CASP sequence"}); continue st, residues, mism = L.casp_chain(paths, seq) if mism: log["dropped"].append({"id": t, "reason": f"{len(mism)} residues in CASP's file disagree with its sequence"}); continue labels, pp = L.dssp(residues, st.cell) log["polyproline"].update(pp) ss3, ss8, ss8_pp, resolved = L.label_strings(len(seq), labels) xyz_ = L.coordinates(len(seq), residues) rows.append(row(id=t, casp_targets=[t], target_match=["byte-identical"], target_identity=[1.0], target_regions=[[[1, len(seq)]]], sequence=seq, ss3=ss3, ss8=ss8, ss8_pp=ss8_pp, resolved=resolved, **{f"{a.lower()}_xyz": xyz_[a] for a in L.ATOMS}, pdb_id=",".join(listed.get(t, [])) or None, source_files=[f"{archive}:{os.path.basename(p)}" for p in paths], in_tape=t in tape_targets)) log["targets"].setdefault(t, {})["files"] = [os.path.basename(p) for p in paths] write(dedupe(rows, log), "casp", f"casp{rnd}", log) if "tape" in args.source: for split in args.tape_splits: print(f"== tape {split}", flush=True) build_tape(split) for rnd in args.rounds: for source in [s for s in ("rcsb", "casp") if s in args.source]: print(f"== {source} CASP{rnd}", flush=True) {"rcsb": build_rcsb, "casp": build_casp}[source](rnd)