@platforma-open/milaboratories.3d-structure-prediction.software 1.1.0 → 1.1.1

package/src_python/numbering.py

@@ -1,103 +0,0 @@
-"""IMGT numbering helpers.
-
-ImmuneBuilder runs ANARCI internally and exposes numbered residues on the
-Antibody object. Default scheme is typically Chothia unless configured. Until
-runtime testing confirms the scheme emitted by `antibody.numbered_sequences`,
-we trust what comes out and record the scheme in provenance; if a Chothia
-fallback is needed, switch to post-hoc renumbering via the `anarci` CLI here.
-
-IMGT CDR ranges (per spec R27):
-  CDRH1: 27-38   CDRH2: 56-65   CDRH3: 105-117
-  CDRL1: 27-38   CDRL2: 56-65   CDRL3: 105-117
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-IMGT_CDR_RANGES: dict[str, dict[str, tuple[int, int]]] = {
-    "H": {"CDR1": (27, 38), "CDR2": (56, 65), "CDR3": (105, 117)},
-    "L": {"CDR1": (27, 38), "CDR2": (56, 65), "CDR3": (105, 117)},
-}
-
-
-@dataclass
-class NumberedResidue:
-    chain: str  # "H" or "L"
-    pos: str  # IMGT position as string; may include insertion code (e.g. "111A").
-    aa: str
-
-    @property
-    def imgt_int(self) -> int:
-        digits = "".join(c for c in self.pos if c.isdigit())
-        return int(digits) if digits else 0
-
-    @property
-    def region(self) -> str:
-        ranges = IMGT_CDR_RANGES.get(self.chain, {})
-        n = self.imgt_int
-        for name, (lo, hi) in ranges.items():
-            if lo <= n <= hi:
-                return name
-        return "FR"
-
-
-def extract_numbered_residues(antibody) -> list[NumberedResidue]:
-    """Pull residue numbering out of an ImmuneBuilder Antibody.
-
-    `antibody.numbered_sequences` is {'H': [((pos, ins), aa), ...], 'L': ...}.
-    For VHH only 'H' is present. Residues are returned in N-to-C order per
-    chain, heavy first then light.
-    """
-    out: list[NumberedResidue] = []
-    numbered = getattr(antibody, "numbered_sequences", {}) or {}
-    for chain in ("H", "L"):
-        chain_data = numbered.get(chain, [])
-        for entry in chain_data:
-            (pos, ins), aa = entry
-            pos_str = f"{pos}{ins.strip()}" if ins and ins.strip() else str(pos)
-            out.append(NumberedResidue(chain=chain, pos=pos_str, aa=aa))
-    return out
-
-
-def cdr_ranges_in_pdb_notation(chain: str) -> dict[str, tuple[str, str]]:
-    """Return CDR ranges formatted for REMARK 99 CDR* records.
-
-    Example: {"CDR1": ("H27", "H38"), ...} for chain H.
-    """
-    ranges = IMGT_CDR_RANGES.get(chain, {})
-    return {
-        name: (f"{chain}{lo}", f"{chain}{hi}")
-        for name, (lo, hi) in ranges.items()
-    }
-
-
-def cdrh3_length(residues: list[NumberedResidue]) -> int:
-    """Count residues in CDRH3."""
-    return sum(1 for r in residues if r.chain == "H" and r.region == "CDR3")
-
-
-# IMGT 42/49/50/52 are the same four physical FR2 residues historically
-# described as Kabat 37/44/45/47. FR2 has no insertion-prone loops, so the
-# correspondence is canonical (Vincke et al. 2009; Mitchell & Colwell 2018).
-VHH_HALLMARKS_IMGT: dict[int, tuple[str, ...]] = {
-    42: ("F", "Y"),  # canonical VHH; conventional VH carries V
-    49: ("E",),      # canonical VHH; conventional VH carries G
-    50: ("R",),      # canonical VHH; conventional VH carries L
-    52: ("G",),      # canonical VHH; conventional VH carries W
-}
-
-
-def vhh_hallmarks_present(residues: list[NumberedResidue]) -> bool:
-    """R15 — return True when the heavy chain looks like a canonical VHH.
-
-    Reads IMGT-numbered residues already extracted from the predicted Antibody
-    (no second ANARCI call). Tolerates one humanized position: True iff at
-    least 2 of the 4 hallmark positions carry a canonical VHH residue.
-    """
-    by_pos = {r.imgt_int: r.aa for r in residues if r.chain == "H"}
-    matches = sum(
-        1 for pos, expected in VHH_HALLMARKS_IMGT.items()
-        if by_pos.get(pos) in expected
-    )
-    return matches >= 2

package/src_python/pdb_writer.py

@@ -1,136 +0,0 @@
-"""PDB writer that augments ImmuneBuilder output with REMARKs.
-
-ImmuneBuilder writes a standard PDB. Per spec R26/R28/R29 we need to:
- - Clamp per-atom B-factor to [0.00, 99.99] to fit PDB `%6.2f` precision.
- - Inject a TITLE line identifying the predictor.
- - Inject REMARK 99 PROVENANCE block (version, seed, block version).
- - Inject REMARK 99 CDR* records with IMGT CDR ranges.
-
-PDB content must be byte-stable for identical inputs so the platforma
-backend can cache and reuse downstream results — a wall-clock prediction
-timestamp would break every run's CID, so we omit it. The seed + version
-fields plus the input sequences are sufficient to reproduce the prediction.
-
-The cleanest approach is: let ImmuneBuilder write a temp PDB, then post-
-process the lines — injecting REMARKs after TITLE and clamping B-factors on
-ATOM/HETATM lines in one pass.
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-from numbering import IMGT_CDR_RANGES, cdr_ranges_in_pdb_notation
-
-B_FACTOR_MIN = 0.00
-B_FACTOR_MAX = 99.99
-
-
-def _clamp_b_factor(line: str) -> tuple[str, bool]:
-    """Clamp B-factor column on ATOM/HETATM lines. Returns (new_line, clamped)."""
-    if not (line.startswith("ATOM") or line.startswith("HETATM")):
-        return line, False
-    if len(line) < 66:
-        return line, False
-    raw = line[60:66]
-    try:
-        value = float(raw)
-    except ValueError:
-        return line, False
-    clamped = max(B_FACTOR_MIN, min(B_FACTOR_MAX, value))
-    if clamped == value:
-        return line, False
-    return f"{line[:60]}{clamped:6.2f}{line[66:]}", True
-
-
-def _cdr_remark_lines(mode: str) -> list[str]:
-    """Emit REMARK 99 CDR* lines (IMGT ranges)."""
-    lines: list[str] = []
-    chains = ["H"] if mode == "NanoBodyBuilder2" else ["H", "L"]
-    for chain in chains:
-        for cdr_name, (lo, hi) in cdr_ranges_in_pdb_notation(chain).items():
-            # e.g. "REMARK 99 PLATFORMA CDRH1 H27-H38"
-            label = f"CDR{chain}{cdr_name[-1]}"  # CDR1 → CDRH1 / CDRL1
-            lines.append(f"REMARK  99 PLATFORMA {label} {lo}-{hi}")
-    return lines
-
-
-def _provenance_remark_lines(
-    *,
-    immunebuilder_version: str,
-    torch_seed: int,
-    block_version: str,
-    numbering_scheme: str,
-) -> list[str]:
-    return [
-        "REMARK  99 PROVENANCE",
-        f"REMARK  99 PROVENANCE immunebuilder-version={immunebuilder_version}",
-        f"REMARK  99 PROVENANCE torch-seed={torch_seed}",
-        f"REMARK  99 PROVENANCE block-version={block_version}",
-        f"REMARK  99 PROVENANCE numbering-scheme={numbering_scheme}",
-    ]
-
-
-def _title_line(mode: str) -> str:
-    builder = "ABodyBuilder2" if mode == "ABodyBuilder2" else "NanoBodyBuilder2"
-    return f"TITLE     {builder} prediction (Platforma Structure Prediction block)"
-
-
-def augment_pdb(
-    source_path: Path,
-    dest_path: Path,
-    *,
-    mode: str,
-    immunebuilder_version: str,
-    torch_seed: int,
-    block_version: str,
-    numbering_scheme: str,
-) -> dict:
-    """Rewrite source_path → dest_path with TITLE + REMARK injections + B clamping.
-
-    Returns stats dict: {clamped_count: int, injected_remarks: int}.
-    """
-    with open(source_path, "r") as f:
-        src_lines = [line.rstrip("\n") for line in f]
-
-    title = _title_line(mode)
-    provenance = _provenance_remark_lines(
-        immunebuilder_version=immunebuilder_version,
-        torch_seed=torch_seed,
-        block_version=block_version,
-        numbering_scheme=numbering_scheme,
-    )
-    cdr = _cdr_remark_lines(mode)
-    injected = [title, *provenance, *cdr]
-
-    out_lines: list[str] = []
-    clamped = 0
-    header_done = False
-
-    for line in src_lines:
-        # Skip any existing TITLE that ImmuneBuilder might have put down.
-        if not header_done and line.startswith("TITLE"):
-            continue
-        if not header_done and line.startswith(("ATOM", "HETATM", "MODEL")):
-            # Inject our block before the coordinate section starts.
-            out_lines.extend(injected)
-            header_done = True
-
-        new_line, was_clamped = _clamp_b_factor(line)
-        out_lines.append(new_line)
-        if was_clamped:
-            clamped += 1
-
-    # If the PDB had no ATOM/HETATM/MODEL lines at all (shouldn't happen),
-    # still emit the REMARKs so downstream parsers don't break.
-    if not header_done:
-        out_lines = injected + out_lines
-
-    with open(dest_path, "w") as f:
-        f.write("\n".join(out_lines))
-        f.write("\n")
-
-    return {
-        "clamped_count": clamped,
-        "injected_remarks": len(injected),
-    }

package/src_python/requirements.txt

@@ -1,5 +0,0 @@
-ImmuneBuilder==1.2
-torch==2.7.0
-biopython==1.85
-openmm==8.3.1
-pdbfixer==1.12.0