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

package/src_python/run_immunebuilder.py

@@ -1,676 +0,0 @@
-"""ImmuneBuilder batch runner for the Platforma 3D Structure Prediction block.
-
-Reads a batch TSV of clonotypes and predicts structures via ABodyBuilder2 or
-NanoBodyBuilder2 (spec R22). Emits:
-
-- Per-clonotype PDB files named `<sha1(clonotypeKey)>.pdb` (R30).
-- `manifest.tsv`  : (clonotypeKey, pdb_filename) — confident clonotypes only
-                    (success AND selected metric ≤ threshold); drives the
-                    exported/UI PDB ResourceMap.
-- `confidence.tsv`: aggregate + per-residue confidence (Å error, R32-R36)
-                    plus failureReason (R40) and warning columns — every row,
-                    confident or not.
-
-Dependencies (ImmuneBuilder, torch) ride the venv that pl-pkg's install-deps
-creates. ANARCI and pdbfixer are not on PyPI; the atls runenv builds them
-from source and stages them in the runenv's site-packages. The SDK's venv
-is created without --system-site-packages, so we bootstrap the runenv's
-site-packages onto sys.path here before any project-level imports run.
-"""
-
-from __future__ import annotations
-
-import os as _os
-import sys as _sys
-import sysconfig as _sysconfig
-
-_runenv_root = _os.environ.get("PYTHONHOME")
-if _runenv_root:
-    # Pick up packages staged via runenv-python-builder's `copyFiles` directive
-    # (e.g. `{site-packages}/anarci`, `{site-packages}/pdbfixer`).
-    _py_ver_short = f"python{_sys.version_info.major}.{_sys.version_info.minor}"
-    _candidates = [
-        _os.path.join(_runenv_root, "lib", _py_ver_short, "site-packages"),
-        _os.path.join(_runenv_root, "Lib", "site-packages"),  # Windows layout
-    ]
-    _platlib = _sysconfig.get_paths().get("platlib")
-    if _platlib:
-        _candidates.append(_platlib)
-    for _candidate in _candidates:
-        if _os.path.isdir(_candidate) and _candidate not in _sys.path:
-            _sys.path.append(_candidate)
-
-    # ANARCI shells out to `hmmscan` (HMMER); the binary ships in the runenv's
-    # bin/ via copyFiles, but only the venv's bin is on PATH by default.
-    _runenv_bin = _os.path.join(_runenv_root, "bin")
-    if _os.path.isdir(_runenv_bin):
-        _path_env = _os.environ.get("PATH", "")
-        if _runenv_bin not in _path_env.split(_os.pathsep):
-            _os.environ["PATH"] = _runenv_bin + _os.pathsep + _path_env
-
-import argparse
-import csv
-import hashlib
-import json
-import os
-import sys
-import traceback
-from dataclasses import asdict, dataclass, field
-from pathlib import Path
-
-
-def _log(message: str) -> None:
-    """Line-buffered log entry to stderr.
-
-    The exec template saves the stdout stream as a regular file output, so
-    the saved-file blob's content hash flows into the resource CID. Wall
-    clock timestamps and elapsed-time durations would make the saved log
-    byte-different on every run and break the platforma backend's
-    content-addressed caching. Keep log lines fully determined by inputs.
-    """
-    print(message, file=sys.stderr, flush=True)
-
-from numbering import cdrh3_length as imgt_cdrh3_length
-from numbering import extract_numbered_residues, vhh_hallmarks_present
-from pdb_writer import augment_pdb
-from sanitize import sanitize_pair
-
-# `clonotypeKey` is a placeholder — the actual column name we write back is
-# the same name we read from the input TSV (the orchestrator uses the axis
-# spec name, e.g. `pl7.app/vdj/clonotypeKey`, as the column header). See
-# build_confidence_fields().
-KEY_COLUMN_PLACEHOLDER = "clonotypeKey"
-
-CONFIDENCE_FIELDS = [
-    KEY_COLUMN_PLACEHOLDER,
-    "clonotypeLabel",
-    "meanError",
-    "cdrh1Error",
-    "cdrh2Error",
-    "cdrh3Error",
-    "cdrl1Error",
-    "cdrl2Error",
-    "cdrl3Error",
-    "perResidueError",
-    "cdrh3Length",
-    "failureReason",
-    "failureReasonText",
-    "warning",
-    "warningText",
-]
-
-
-def build_confidence_fields(key_col: str) -> list[str]:
-    return [key_col if f == KEY_COLUMN_PLACEHOLDER else f for f in CONFIDENCE_FIELDS]
-
-
-# Code → human-readable label maps. The code columns stay (hidden by default)
-# so downstream blocks / future failure-stats logic can group by enum value;
-# the *Text columns are what the user actually sees in the table.
-FAILURE_REASON_LABELS: dict[str, str] = {
-    "empty_sequence": "Empty sequence",
-    "stop_codon_mid_sequence": "Stop codon in sequence",
-    "non_standard_aa_only_after_strip": "No standard amino acids after cleanup",
-    "non_standard_aa_residue": "Non-standard amino acid residue",
-    "length_out_of_range": "Length outside expected VH/VL range",
-    "light_chain_missing_in_paired_mode":
-        "Light chain missing — switch to NanoBodyBuilder2 or pick a light chain",
-}
-
-WARNING_LABELS: dict[str, str] = {
-    "probable_signal_peptide": "Possible N-terminal signal peptide",
-    "long_cdrh3": "Long CDR-H3 (≥20 aa) — confidence may be reduced",
-    "vhh_hallmarks_missing": "VHH hallmark residues not detected",
-}
-
-
-def _failure_reason_label(code: str) -> str:
-    if not code:
-        return ""
-    if code in FAILURE_REASON_LABELS:
-        return FAILURE_REASON_LABELS[code]
-    # Structured prefixes — preserve the suffix for triage rather than
-    # collapsing to a generic message.
-    if code.startswith("immunebuilder_exception:"):
-        return f"ImmuneBuilder error: {code.split(':', 1)[1]}"
-    if code.startswith("unknown_mode:"):
-        return f"Unknown prediction mode: {code.split(':', 1)[1]}"
-    return code
-
-
-def _warning_label(code: str) -> str:
-    return WARNING_LABELS.get(code, code)
-
-# Failure-reason code for a successful prediction whose selected error metric
-# is above the confidence threshold (so it's excluded from the PDB map). The
-# code is stable for grouping; the human text (with the threshold value) is set
-# per-run via RowResult.failure_reason_text.
-CONFIDENCE_ABOVE_THRESHOLD_REASON = "confidence_above_threshold"
-
-# Failure-reason code for a successful prediction whose selected confidence
-# metric could not be computed (so no threshold comparison was possible). Kept
-# distinct from CONFIDENCE_ABOVE_THRESHOLD_REASON so the table doesn't imply a
-# numeric comparison that never happened.
-CONFIDENCE_METRIC_UNAVAILABLE_REASON = "confidence_metric_unavailable"
-
-MANIFEST_FIELDS = [KEY_COLUMN_PLACEHOLDER, "pdb_filename"]
-
-
-def indexed_filename(row_idx: int) -> str:
-    return f"pdb_{row_idx:05d}.pdb"
-
-
-def sha1_filename(key: str) -> str:
-    """Retained for manifest metadata — downstream blocks can SHA-1 keys to cross-reference."""
-    return hashlib.sha1(key.encode("utf-8")).hexdigest() + ".pdb"
-
-
-def get_immunebuilder_version() -> str:
-    try:
-        from importlib.metadata import version as _version
-        return _version("ImmuneBuilder")
-    except Exception:
-        return "unknown"
-
-
-def get_block_version() -> str:
-    return os.environ.get("BLOCK_VERSION", "unknown")
-
-
-def pick_key_column(fieldnames: list[str]) -> str:
-    for name in fieldnames:
-        if name.lower() == "clonotypekey" or name.lower().endswith("clonotypekey"):
-            return name
-    return fieldnames[0]
-
-
-@dataclass
-class RowResult:
-    clonotype_key: str
-    clonotype_label: str = ""
-    mean_error: str = ""
-    cdrh1: str = ""
-    cdrh2: str = ""
-    cdrh3: str = ""
-    cdrl1: str = ""
-    cdrl2: str = ""
-    cdrl3: str = ""
-    per_residue_json: str = ""
-    cdrh3_len: str = ""
-    failure_reason: str = ""
-    # Optional human text override; when set, used verbatim instead of the
-    # static FAILURE_REASON_LABELS lookup (lets us embed runtime values such as
-    # the confidence threshold).
-    failure_reason_text: str = ""
-    warnings: list[str] = field(default_factory=list)
-    pdb_filename: str = ""
-
-    @property
-    def warning_str(self) -> str:
-        return ";".join(self.warnings)
-
-    @property
-    def warning_text(self) -> str:
-        return "; ".join(_warning_label(w) for w in self.warnings)
-
-    def to_tsv_row(self, key_col: str) -> dict[str, str]:
-        return {
-            key_col: self.clonotype_key,
-            "clonotypeLabel": self.clonotype_label,
-            "meanError": self.mean_error,
-            "cdrh1Error": self.cdrh1,
-            "cdrh2Error": self.cdrh2,
-            "cdrh3Error": self.cdrh3,
-            "cdrl1Error": self.cdrl1,
-            "cdrl2Error": self.cdrl2,
-            "cdrl3Error": self.cdrl3,
-            "perResidueError": self.per_residue_json,
-            "cdrh3Length": self.cdrh3_len,
-            "failureReason": self.failure_reason,
-            "failureReasonText": self.failure_reason_text or _failure_reason_label(self.failure_reason),
-            "warning": self.warning_str,
-            "warningText": self.warning_text,
-        }
-
-
-def _mean(values: list[float]) -> float | None:
-    valid = [v for v in values if v is not None]
-    return sum(valid) / len(valid) if valid else None
-
-
-def _region_errors(per_residue, chain: str, cdr_name: str) -> list[float]:
-    target = f"CDR{cdr_name[-1]}"  # "CDR1" or similar
-    return [
-        r["errorAngstroms"]
-        for r in per_residue
-        if r["chain"] == chain and r.get("_region") == target
-    ]
-
-
-def _load_predictor(mode: str, weights_dir: str | None = None):
-    # weights_dir points at the asset mounted into the workdir (see
-    # predict-batch.tpl.tengo). ImmuneBuilder loads `<weights_dir>/<model_file>`
-    # and only downloads from Zenodo when the file is missing — which, with the
-    # asset present, never happens. weights_dir=None preserves upstream
-    # download-to-site-packages behaviour for local/manual runs.
-    if mode == "ABodyBuilder2":
-        from ImmuneBuilder import ABodyBuilder2
-        return ABodyBuilder2(weights_dir=weights_dir)
-    if mode == "NanoBodyBuilder2":
-        from ImmuneBuilder import NanoBodyBuilder2
-        return NanoBodyBuilder2(weights_dir=weights_dir)
-    raise ValueError(f"unknown mode: {mode}")
-
-
-def _set_seed(seed: int) -> None:
-    import random
-    import numpy as np
-    random.seed(seed)
-    np.random.seed(seed)
-    try:
-        import torch
-        torch.manual_seed(seed)
-        if torch.cuda.is_available():
-            torch.cuda.manual_seed_all(seed)
-    except Exception:
-        pass
-
-
-def _predict_one(predictor, mode: str, vh: str, vl: str | None):
-    sequences = {"H": vh}
-    if mode == "ABodyBuilder2" and vl:
-        sequences["L"] = vl
-    return predictor.predict(sequences)
-
-
-def _per_residue_records(antibody) -> list[dict]:
-    """Extract per-residue error records.
-
-    ImmuneBuilder stores ensemble disagreement on `antibody.error_estimates`;
-    `error_estimates.mean(0).sqrt().cpu().numpy()` produces a 1D array of
-    per-residue RMSD in Å indexed in the order of `numbered_sequences` flattened
-    (heavy chain then light). This is the same array that gets written to the
-    B-factor column of the saved PDB (see `ImmuneBuilder.util.add_errors_as_bfactors`).
-
-    Returns a list of dicts shaped per spec R34:
-        {"pos": "<string>", "chain": "H"|"L", "errorAngstroms": <float>}
-    Stores an additional `_region` marker (stripped before JSON emission) so
-    we can aggregate per-CDR quickly in `_region_errors`.
-    """
-    records: list[dict] = []
-    residues = extract_numbered_residues(antibody)
-
-    err_array = None
-    if hasattr(antibody, "error_estimates"):
-        try:
-            err_array = antibody.error_estimates.mean(0).sqrt().cpu().numpy()
-        except Exception:
-            err_array = None
-
-    for idx, r in enumerate(residues):
-        if err_array is not None and idx < len(err_array):
-            err_val = float(err_array[idx])
-        else:
-            err_val = 0.0
-        records.append({
-            "pos": r.pos,
-            "chain": r.chain,
-            "errorAngstroms": err_val,
-            "_region": r.region,
-        })
-    return records
-
-
-def _json_safe_per_residue(records: list[dict]) -> str:
-    cleaned = [
-        {"pos": r["pos"], "chain": r["chain"], "errorAngstroms": r["errorAngstroms"]}
-        for r in records
-    ]
-    return json.dumps(cleaned, separators=(",", ":"))
-
-
-def _format_number(value: float | None, digits: int = 3) -> str:
-    if value is None:
-        return ""
-    return f"{value:.{digits}f}"
-
-
-def _format_int(value: int | None) -> str:
-    return "" if value is None else str(value)
-
-
-def _metric_value(result: RowResult, metric: str) -> float | None:
-    src = result.cdrh3 if metric == "cdrh3Mean" else result.mean_error
-    if not src:
-        return None
-    try:
-        return float(src)
-    except ValueError:
-        return None
-
-
-def _build_summary(
-    results: list[RowResult],
-    metric: str,
-    threshold: float,
-) -> dict:
-    """Aggregate per-row stats into the schema the model + UI consume.
-
-    Schema is part of the contract between this script and the block model
-    (model.failureStats); keep the field names stable.
-    """
-    by_failure: dict[str, int] = {}
-    by_warning: dict[str, int] = {}
-    metric_values: list[float] = []
-    confident = 0
-    succeeded = 0
-
-    for r in results:
-        if r.failure_reason:
-            by_failure[r.failure_reason] = by_failure.get(r.failure_reason, 0) + 1
-        else:
-            succeeded += 1
-            v = _metric_value(r, metric)
-            if v is not None:
-                metric_values.append(v)
-                if v <= threshold:
-                    confident += 1
-        for w in r.warnings:
-            by_warning[w] = by_warning.get(w, 0) + 1
-
-    summary: dict = {
-        "totalRows": len(results),
-        "succeeded": succeeded,
-        "failed": len(results) - succeeded,
-        "byFailureReason": by_failure,
-        "byWarning": by_warning,
-        "metric": metric,
-        "thresholdAngstroms": threshold,
-        "confidentCount": confident,
-    }
-    if metric_values:
-        summary["metricMean"] = sum(metric_values) / len(metric_values)
-        summary["metricMin"] = min(metric_values)
-        summary["metricMax"] = max(metric_values)
-    return summary
-
-
-def process_batch(
-    input_tsv: Path,
-    pdb_dir: Path,
-    manifest_tsv: Path,
-    confidence_tsv: Path,
-    summary_json: Path | None,
-    mode: str,
-    seed: int,
-    metric: str,
-    threshold: float,
-    weights_dir: str | None = None,
-) -> None:
-    pdb_dir.mkdir(parents=True, exist_ok=True)
-    manifest_tsv.parent.mkdir(parents=True, exist_ok=True)
-    confidence_tsv.parent.mkdir(parents=True, exist_ok=True)
-
-    with open(input_tsv, newline="") as f:
-        reader = csv.DictReader(f, delimiter="\t")
-        fieldnames = reader.fieldnames or []
-        key_col = pick_key_column(fieldnames)
-        rows = list(reader)
-
-    ib_version = get_immunebuilder_version()
-    block_version = get_block_version()
-
-    _log(
-        f"start mode={mode} rows={len(rows)} seed={seed} metric={metric} "
-        f"threshold={threshold} immunebuilder={ib_version} block={block_version}"
-    )
-
-    if not rows:
-        _log("no input rows; skipping ImmuneBuilder load and emitting empty outputs")
-
-    _set_seed(seed)
-    if rows:
-        _log(f"loading {mode} ensemble (4 models)")
-        predictor = _load_predictor(mode, weights_dir)
-        _log("predictor ready")
-    else:
-        predictor = None
-
-    # Intra-batch dedup cache (R16). Key: (clean_vh, clean_vl).
-    prediction_cache: dict[tuple[str, str], object] = {}
-    results: list[RowResult] = []
-
-    n = len(rows)
-    log_every = max(1, n // 20) if n > 20 else 1
-    fail_count = 0
-    success_count = 0
-    cache_hits = 0
-
-    for row_idx, row in enumerate(rows):
-        key = row.get(key_col, "")
-        # Use the human-readable label (e.g. CDR3 sequence) for log lines
-        # AND echo it into confidence.tsv as the `clonotypeLabel` column —
-        # the workflow's xsv import surfaces that column as `pl7.app/label`
-        # so the V3 structures table substitutes it into the row-axis cells.
-        label_from_row = row.get("clonotypeLabel") or ""
-        result = RowResult(clonotype_key=key, clonotype_label=label_from_row)
-        prefix = f"[{row_idx + 1}/{n}] {label_from_row or key}"
-
-        sanitized = sanitize_pair(
-            row.get("heavyChain", ""),
-            row.get("lightChain", "") if mode == "ABodyBuilder2" else None,
-            mode,
-        )
-        result.warnings.extend(sanitized.warnings)
-
-        if not sanitized.success:
-            result.failure_reason = sanitized.failure_reason
-            fail_count += 1
-            _log(f"{prefix} FAIL sanitize reason={sanitized.failure_reason}")
-            results.append(result)
-            continue
-
-        if sanitized.warnings:
-            _log(f"{prefix} warning {','.join(sanitized.warnings)}")
-
-        cache_key = (sanitized.vh, sanitized.vl)
-        antibody = prediction_cache.get(cache_key)
-        if antibody is None:
-            try:
-                antibody = _predict_one(predictor, mode, sanitized.vh, sanitized.vl)
-                prediction_cache[cache_key] = antibody
-                if (row_idx + 1) % log_every == 0 or row_idx == 0:
-                    _log(f"{prefix} predicted")
-            except Exception as exc:  # noqa: BLE001
-                fail_count += 1
-                _log(f"{prefix} FAIL ImmuneBuilder {type(exc).__name__}: {exc}")
-                traceback.print_exc(file=sys.stderr)
-                result.failure_reason = f"immunebuilder_exception:{type(exc).__name__}"
-                results.append(result)
-                continue
-        else:
-            cache_hits += 1
-            _log(f"{prefix} dedup-cache hit (skipping ImmuneBuilder call)")
-
-        pdb_filename = indexed_filename(row_idx)
-        raw_pdb_path = pdb_dir / ("_raw_" + pdb_filename)
-        final_pdb_path = pdb_dir / pdb_filename
-        try:
-            antibody.save(str(raw_pdb_path))
-            augment_pdb(
-                raw_pdb_path,
-                final_pdb_path,
-                mode=mode,
-                immunebuilder_version=ib_version,
-                torch_seed=seed,
-                block_version=block_version,
-                numbering_scheme="imgt",
-            )
-            try:
-                raw_pdb_path.unlink()
-            except FileNotFoundError:
-                pass
-        except Exception as exc:  # noqa: BLE001
-            fail_count += 1
-            _log(f"{prefix} FAIL save/augment {type(exc).__name__}: {exc}")
-            traceback.print_exc(file=sys.stderr)
-            result.failure_reason = f"immunebuilder_exception:{type(exc).__name__}"
-            results.append(result)
-            continue
-
-        residues = _per_residue_records(antibody)
-        per_res_json = _json_safe_per_residue(residues)
-        all_err = [r["errorAngstroms"] for r in residues]
-        mean_err = _mean(all_err)
-        cdrh1 = _mean(_region_errors(residues, "H", "CDR1"))
-        cdrh2 = _mean(_region_errors(residues, "H", "CDR2"))
-        cdrh3 = _mean(_region_errors(residues, "H", "CDR3"))
-
-        result.per_residue_json = per_res_json
-        result.mean_error = _format_number(mean_err)
-        result.cdrh1 = _format_number(cdrh1)
-        result.cdrh2 = _format_number(cdrh2)
-        result.cdrh3 = _format_number(cdrh3)
-
-        if mode == "ABodyBuilder2":
-            result.cdrl1 = _format_number(_mean(_region_errors(residues, "L", "CDR1")))
-            result.cdrl2 = _format_number(_mean(_region_errors(residues, "L", "CDR2")))
-            result.cdrl3 = _format_number(_mean(_region_errors(residues, "L", "CDR3")))
-
-        numbered = extract_numbered_residues(antibody)
-        nb = imgt_cdrh3_length(numbered)
-        result.cdrh3_len = _format_int(nb)
-        if nb >= 20:
-            result.warnings.append("long_cdrh3")
-        if mode == "NanoBodyBuilder2" and not vhh_hallmarks_present(numbered):
-            result.warnings.append("vhh_hallmarks_missing")
-        result.pdb_filename = pdb_filename
-
-        success_count += 1
-        if (row_idx + 1) % log_every == 0 or row_idx == 0 or row_idx == n - 1:
-            _log(
-                f"{prefix} OK mean={result.mean_error}Å cdrh3={result.cdrh3}Å "
-                f"cdrh3Length={result.cdrh3_len}"
-            )
-
-        results.append(result)
-
-    # Preserve the input key-column header in our outputs. The batch
-    # orchestrator hands us TSVs whose key column is named after the axis spec
-    # (e.g. `pl7.app/vdj/clonotypeKey`); when batches are concatenated, the
-    # downstream xsv import expects that same header back.
-    manifest_fields = [key_col if f == KEY_COLUMN_PLACEHOLDER else f for f in MANIFEST_FIELDS]
-    confidence_fields = build_confidence_fields(key_col)
-
-    # Build the summary BEFORE the confident-marking loop below, so its
-    # semantics stay stable: `succeeded` = a structure was produced (regardless
-    # of confidence) and `confidentCount` = the within-threshold subset. The
-    # loop then tags above-threshold / metric-unavailable rows with a failure
-    # reason for the per-row table; that must not retroactively inflate the
-    # summary's failure count or collapse `succeeded` onto `confidentCount`.
-    summary = _build_summary(results, metric, threshold)
-
-    # A structure was produced, but it isn't confident enough to export. Two
-    # distinct cases, surfaced as distinct failure reasons so the user (and any
-    # downstream tooling) can tell them apart — the confidence values still
-    # appear in the table either way. This is the single confident filter for
-    # the block.
-    for r in results:
-        if r.failure_reason or not r.pdb_filename:
-            continue
-        v = _metric_value(r, metric)
-        if v is None:
-            # The selected metric couldn't be computed (e.g. the CDR-H3 region
-            # produced no numbered residues) — no comparison was made.
-            r.failure_reason = CONFIDENCE_METRIC_UNAVAILABLE_REASON
-            r.failure_reason_text = "Confidence metric unavailable"
-        elif v > threshold:
-            r.failure_reason = CONFIDENCE_ABOVE_THRESHOLD_REASON
-            r.failure_reason_text = f"Prediction confidence above threshold ({threshold} Å)"
-
-    # The manifest selects which PDBs become the exported/UI ResourceMap: only
-    # clonotypes that have a structure and no failure reason. Failed and the
-    # low-confidence rows just marked are excluded, so the map is confident-only
-    # by construction.
-    with open(manifest_tsv, "w", newline="") as f:
-        writer = csv.DictWriter(
-            f, fieldnames=manifest_fields, delimiter="\t", lineterminator="\n"
-        )
-        writer.writeheader()
-        for r in results:
-            if r.pdb_filename and not r.failure_reason:
-                writer.writerow({key_col: r.clonotype_key, "pdb_filename": r.pdb_filename})
-
-    with open(confidence_tsv, "w", newline="") as f:
-        writer = csv.DictWriter(f, fieldnames=confidence_fields, delimiter="\t")
-        writer.writeheader()
-        for r in results:
-            writer.writerow(r.to_tsv_row(key_col))
-
-    if summary_json is not None:
-        summary_json.parent.mkdir(parents=True, exist_ok=True)
-        with open(summary_json, "w") as f:
-            json.dump(summary, f)
-
-    _log(
-        f"done total={summary['totalRows']} succeeded={summary['succeeded']} "
-        f"failed={summary['failed']} confident={summary['confidentCount']} "
-        f"cache_hits={cache_hits}"
-    )
-    if summary["byFailureReason"]:
-        for reason, n_fail in sorted(
-            summary["byFailureReason"].items(), key=lambda kv: -kv[1]
-        ):
-            _log(f"  failure: {n_fail} × {reason}")
-    if summary["byWarning"]:
-        for warning, n_warn in sorted(
-            summary["byWarning"].items(), key=lambda kv: -kv[1]
-        ):
-            _log(f"  warning: {n_warn} × {warning}")
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--mode", choices=["ABodyBuilder2", "NanoBodyBuilder2"], required=True)
-    parser.add_argument("--weights-dir", default=None,
-                        help="Directory holding the ImmuneBuilder model weights "
-                             "(mounted from the weights asset). When omitted, "
-                             "ImmuneBuilder downloads them on first use.")
-    parser.add_argument("--input", help="Batch TSV with clonotypeKey, heavyChain[, lightChain]")
-    parser.add_argument("--output-dir", help="Directory for per-clonotype PDB files")
-    parser.add_argument("--manifest", help="Path to manifest.tsv")
-    parser.add_argument("--confidence", help="Path to confidence.tsv")
-    parser.add_argument("--summary", default=None, help="Path to summary.json (aggregate stats for the model)")
-    parser.add_argument("--seed", type=int, default=42)
-    parser.add_argument("--metric", choices=["cdrh3Mean", "overallMean"], default="cdrh3Mean")
-    parser.add_argument("--threshold", type=float, default=2.5,
-                        help="Confidence threshold (Å) used to derive confidentCount in summary.json")
-    args = parser.parse_args()
-
-    missing = [
-        name for name, value in [
-            ("--input", args.input),
-            ("--output-dir", args.output_dir),
-            ("--manifest", args.manifest),
-            ("--confidence", args.confidence),
-        ] if not value
-    ]
-    if missing:
-        parser.error(f"the following arguments are required: {', '.join(missing)}")
-
-    process_batch(
-        input_tsv=Path(args.input),
-        pdb_dir=Path(args.output_dir),
-        manifest_tsv=Path(args.manifest),
-        confidence_tsv=Path(args.confidence),
-        summary_json=Path(args.summary) if args.summary else None,
-        mode=args.mode,
-        seed=args.seed,
-        metric=args.metric,
-        threshold=args.threshold,
-        weights_dir=args.weights_dir,
-    )
-
-
-if __name__ == "__main__":
-    main()