Upload src/02_build_curated_master_csv.py with huggingface_hub

src/02_build_curated_master_csv.py

@@ -0,0 +1,243 @@
+#!/usr/bin/env python3
+"""
+Build chain CSVs from index. Curated by subset: only list/FASTA pairs in
+curated_csv/cullpdb_list_fasta_index.csv are processed.
+
+Outputs:
+  - curated_csv/cullpdb_combined_chains.csv  — single master CSV for all analysis
+  - curated_csv/subset_chains/<list_basename>.csv  — one CSV per subset
+"""
+import csv
+import re
+import sys
+from pathlib import Path
+from typing import List, Optional, Tuple
+
+SCRIPT_DIR = Path(__file__).resolve().parent
+BASE = SCRIPT_DIR.parent
+CULLPDB_DIR = BASE / "pieces" / "2026_01_26"
+CURATED_DIR = BASE / "curated_csv"
+SUBSET_CSV_DIR = CURATED_DIR / "subset_chains"  # one CSV per subset, named by list_basename
+COMBINED_CSV = CURATED_DIR / "cullpdb_combined_chains.csv"  # single CSV for all analysis
+
+PAT = re.compile(
+    r"^cullpdb_pc([\d.]+)_res([\d.]+)-([\d.]+)_"
+    r"(?:(noBrks)_)?"
+    r"len40-10000_R([\d.]+)_"
+    r"(.+?)_d\d{4}_\d{2}_\d{2}_chains(\d+)$"
+)
+
+
+def split_pdb_chain(pdb_chain: str) -> tuple:
+    """Split PDB chain ID into (pdb_id, chain_id). PDB ID is first 4 chars, rest is chain."""
+    if len(pdb_chain) <= 4:
+        return (pdb_chain, "")
+    return (pdb_chain[:4], pdb_chain[4:])
+
+
+def parse_params_from_basename(base: str) -> Optional[dict]:
+    m = PAT.match(base)
+    if not m:
+        return None
+    pc, res_min, res_max, no_brks, r_cutoff, methods, n_chains = m.groups()
+    n = int(n_chains)
+    no_brk = no_brks is not None
+    return {
+        "pc": float(pc),
+        "resolution_range": f"{res_min}-{res_max}",
+        "no_breaks": "yes" if no_brk else "no",
+        "R": float(r_cutoff),
+        "source_list": base,
+    }
+
+
+def read_list_file(path: Path) -> List[dict]:
+    """Return list of dicts: PDBchain, len, method, resol, rfac, freerfac."""
+    rows = []
+    with open(path) as f:
+        lines = f.readlines()
+    if not lines:
+        return rows
+    # header: PDBchain   len  method   resol   rfac  freerfac
+    for line in lines[1:]:
+        line = line.strip()
+        if not line:
+            continue
+        parts = line.split()
+        if len(parts) < 5:
+            continue
+        pdb_chain = parts[0]
+        try:
+            length = int(parts[1])
+        except ValueError:
+            continue
+        method = parts[2]
+        resol = parts[3]
+        rfac = parts[4]
+        freerfac = parts[5] if len(parts) > 5 else ""
+        rows.append({
+            "pdb_chain": pdb_chain,
+            "len": length,
+            "method": method,
+            "resol": resol,
+            "rfac": rfac,
+            "freerfac": freerfac,
+        })
+    return rows
+
+
+def read_fasta_entries(path: Path) -> List[Tuple[str, str]]:
+    """Return list of (pdb_chain_from_header, sequence) in order (one per FASTA entry)."""
+    entries = []
+    current_seq = []
+    current_id = None
+    with open(path) as f:
+        for line in f:
+            line = line.rstrip("\n")
+            if line.startswith(">"):
+                if current_seq is not None:
+                    if current_id is not None:
+                        entries.append((current_id, "".join(current_seq)))
+                    # New entry: first token after ">" is PDBchain
+                    rest = line[1:].strip()
+                    current_id = rest.split(None, 1)[0] if rest else ""
+                    current_seq = []
+            else:
+                current_seq.append(line)
+        if current_id is not None:
+            entries.append((current_id, "".join(current_seq)))
+    return entries
+
+
+def load_pairs_from_index(index_csv: Path) -> List[tuple]:
+    """Load (base, list_path, fasta_path, params) from curated index CSV. Only these subsets are used."""
+    pairs = []
+    with open(index_csv, newline="") as f:
+        r = csv.DictReader(f)
+        for row in r:
+            base = row.get("list_basename", "").strip()
+            list_path_s = row.get("list_path", "").strip()
+            fasta_path_s = row.get("fasta_path", "").strip()
+            if not base or not list_path_s or not fasta_path_s:
+                continue
+            list_path = Path(list_path_s)
+            fasta_path = Path(fasta_path_s)
+            if not list_path.exists() or not fasta_path.exists():
+                print(f"Skip (missing): {base}", file=sys.stderr)
+                continue
+            params = parse_params_from_basename(base)
+            if not params:
+                print(f"Skip (parse): {base}", file=sys.stderr)
+                continue
+            pairs.append((base, list_path, fasta_path, params))
+    return pairs
+
+
+def main():
+    index_csv = CURATED_DIR / "cullpdb_list_fasta_index.csv"
+    if not index_csv.exists():
+        print(f"Index not found: {index_csv}. Run build_list_fasta_index.py first.", file=sys.stderr)
+        sys.exit(1)
+
+    pairs = load_pairs_from_index(index_csv)
+    if not pairs:
+        print("No subsets in index (or paths missing). Nothing to do.", file=sys.stderr)
+        sys.exit(1)
+    print(f"Curating from index: {len(pairs)} subsets.")
+    fieldnames = [
+        "pdb_chain", "pdb", "chain", "sequence", "len", "method", "resolution", "rfac", "freerfac",
+        "pc", "no_breaks", "R", "source_list",
+    ]
+    SUBSET_CSV_DIR.mkdir(parents=True, exist_ok=True)
+
+    # Sanity-check counters
+    id_mismatches = 0
+    len_mismatches = 0
+    count_mismatches = 0
+    files_skipped = 0
+    rows_written_total = 0
+    files_written = 0
+    all_rows = []  # for combined CSV (all analysis uses this file)
+
+    for base, list_path, fasta_path, params in pairs:
+        list_rows = read_list_file(list_path)
+        fasta_entries = read_fasta_entries(fasta_path)
+        n_list, n_fasta = len(list_rows), len(fasta_entries)
+        if n_list != n_fasta:
+            print(f"SKIP {base}: list has {n_list} rows, fasta has {n_fasta} entries", file=sys.stderr)
+            files_skipped += 1
+            continue
+
+        subset_rows = []
+        file_id_mismatches = 0
+        file_len_mismatches = 0
+        for i, (row, (fasta_id, seq)) in enumerate(zip(list_rows, fasta_entries)):
+            list_id = row["pdb_chain"]
+            list_len = row["len"]
+            seq_len = len(seq)
+
+            # Sanity 1: PDBchain in list must match first token in FASTA header
+            if list_id != fasta_id:
+                id_mismatches += 1
+                file_id_mismatches += 1
+                if file_id_mismatches <= 3:
+                    print(f"ID mismatch in {base} row {i+2}: list={list_id!r} fasta_header={fasta_id!r}", file=sys.stderr)
+                continue
+
+            # Sanity 2: list length must match actual sequence length
+            if list_len != seq_len:
+                len_mismatches += 1
+                file_len_mismatches += 1
+                if file_len_mismatches <= 3:
+                    print(f"LEN mismatch in {base} {list_id}: list len={list_len} seq len={seq_len}", file=sys.stderr)
+                continue
+
+            pdb_id, chain_id = split_pdb_chain(list_id)
+            out_row = {
+                "pdb_chain": list_id,
+                "pdb": pdb_id,
+                "chain": chain_id,
+                "sequence": seq,
+                "len": list_len,
+                "method": row["method"],
+                "resolution": row["resol"],
+                "rfac": row["rfac"],
+                "freerfac": row["freerfac"],
+                "pc": params["pc"],
+                "no_breaks": params["no_breaks"],
+                "R": params["R"],
+                "source_list": params["source_list"],
+            }
+            subset_rows.append(out_row)
+
+        if file_id_mismatches > 0 or file_len_mismatches > 0:
+            count_mismatches += 1
+
+        # Write one CSV per subset
+        out_path = SUBSET_CSV_DIR / f"{base}.csv"
+        with open(out_path, "w", newline="") as f:
+            w = csv.DictWriter(f, fieldnames=fieldnames)
+            w.writeheader()
+            w.writerows(subset_rows)
+        all_rows.extend(subset_rows)
+        rows_written_total += len(subset_rows)
+        files_written += 1
+
+    # Write single combined CSV for all downstream analysis
+    with open(COMBINED_CSV, "w", newline="") as f:
+        w = csv.DictWriter(f, fieldnames=fieldnames)
+        w.writeheader()
+        w.writerows(all_rows)
+    print(f"Wrote {COMBINED_CSV} with {len(all_rows)} chain rows (master for analysis).")
+
+    # Summary
+    print(f"Wrote {files_written} subset CSVs to {SUBSET_CSV_DIR} ({rows_written_total} chain rows total).")
+    print(f"Sanity check: ID mismatches (list PDBchain vs FASTA header) = {id_mismatches}")
+    print(f"Sanity check: length mismatches (list len vs len(sequence)) = {len_mismatches}")
+    print(f"Files with ID or len mismatch = {count_mismatches}; files skipped (list vs FASTA count) = {files_skipped}")
+    if id_mismatches > 0 or len_mismatches > 0 or files_skipped > 0:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()