cleanup: workflow + Python pass

Pure refactor; zero behavior change. 65 pytest cases still pass; full
block build green (7/7).

Workflow (main.tpl.tengo):
- Extract `withSidecar(cmd, bundleKey, filename, cliFlag)` helper for
  the optional enrichment sidecars. Two near-identical 7-line blocks
  (cdrh3 lengths, per-residue confidence) collapse to two one-liner
  calls returning the extended `cmd`. Filter stays inline since it
  uses the single-column accessor.
- Extract `withOptArg(cmd, flag, value)` for the three optional CLI
  string knobs (numbering scheme, chain-h, chain-l). Three 3-line
  guarded `cmd.arg(...)` chains collapse to three one-liners.
- Replace the `pdbIndex := ""` accumulator loop with one-shot
  `text.join(indexLines, "\n") + "\n"`.
- Drop dead `rowCount` increment (never read after the loop).
- Hoist `ll` import to module level (was lazy-imported inside
  wf.body's panic branch only).

Python (metrics.py):
- Extract `_weight_fns(in_bridge)` factory. The same three weight
  closures (hydrophobicity / pos_charge_abs / neg_charge_abs) were
  defined inline in `_chain_metrics` (per-chain, VHH branch) AND
  again in the TAP branch over the unified H+L `in_bridge`. Both
  callsites now unpack a single helper call.
- Drop the local `h_scale` / `h_glycine` aliases, the helper reads
  the module constants directly.

Python (main.py):
- Replace `isinstance(surface_metrics, dict)` with the simpler `sm =
  surface_metrics` (compute_metrics always returns a dict; the
  paranoia check is unwarranted).
- `hallmark` can be None (per its signature), so the mismatch check
  is now `if hallmark and hallmark.get("mismatch")`.

Em-dash sweep:
- Drop em-dashes / en-dashes across all Python source
  (cysteines.py, motifs.py, scoring.py, structure.py, metrics.py)
  per the no-em-dashes feedback. ~30 occurrences total.
- `check_hallmark_tetrad` warning message switched the em-dash
  sentinel `'—'` to `'?'` so missing residues show up readably.

Author: xnacly

software/liabilities-script/cysteines.py

@@ -72,7 +72,7 @@ def _collect_cys_records(parsed):
 
 def _scan_disulfides(cys_records) -> dict[int, int]:
     """Pairwise scan over cys_records; returns idx → partner_idx for every
-    Cys engaged in a disulfide. First-match wins on ambiguous geometry —
+    Cys engaged in a disulfide. First-match wins on ambiguous geometry ,
     if one Cys could bond to two partners, we lock the first one we hit
     and treat the other as `unbonded` (consistent with REMARK SSBOND-style
     1:1 bond accounting; ambiguous cases are rare and biologically odd)."""
@@ -152,7 +152,7 @@ def detect_cysteines(
         (role, pos) for role, positions in canonical_positions.items() for pos in positions
     }
     # Used below to skip phantom rows for canonical positions that ARE
-    # filled — keyed by (role, res_seq).
+    # filled , keyed by (role, res_seq).
     cys_by_role_pos: dict[tuple[str, int], int] = {}
     for idx, (chain_id, r, _ca, _sg) in enumerate(cys_records):
         role = role_of_chain(chain_id, heavy_chain_id, light_chain_id)

software/liabilities-script/main.py

@@ -260,13 +260,15 @@ def analyze_pdb(
         parsed, numbering_scheme, heavy_chain_id, chain_count_mode=mode
     )
     hallmark_warning = ""
-    if isinstance(hallmark, dict) and hallmark.get("mismatch"):
+    if hallmark and hallmark.get("mismatch"):
         impl = hallmark.get("impliedMode", "?")
         hallmark_warning = (
             f"hallmark tetrad implies {impl} but chain count says {mode}"
         )
 
-    sm = surface_metrics if isinstance(surface_metrics, dict) and "mode" in surface_metrics else {}
+    # compute_metrics returns {} when neither chain is mapped; .get(...) below
+    # returns None for every metric in that case.
+    sm = surface_metrics
     flags = developability["flags"]
     extra_cys = sum(1 for h in cys_hits if h.cysClass == "cys_extra")
     exposed_extra_cys = sum(

software/liabilities-script/metrics.py

@@ -5,7 +5,7 @@
 charge assignment. Section 2 is the patch detector + per-mode metric
 implementations.
 
-Fv (TAP) — Raybould 2019:
+Fv (TAP) , Raybould 2019:
   R24  totalCdrLength  : sum of CDR loop lengths from numbering
   R25  PSH             : Σ H(R₁)·H(R₂)/r² over surface CDR-vicinity pairs
                          within 7.5 Å heavy-atom distance, no type restriction
@@ -14,7 +14,7 @@
   R28  SFvCSP          : [Σ_RH Q(RH)] × [Σ_RL Q(RL)] over surface-exposed
                          whole-V-domain residues (NOT CDR-restricted)
 
-VHH (TNP) — Gordon 2025:
+VHH (TNP) , Gordon 2025:
   R29  totalCdrLength  : sum of three CDR lengths (single chain)
   R31  PSH/PPC/PNC     : same algorithms applied to one chain, but with
                          same-type-pair restriction (PSH: H-H pairs only;
@@ -25,7 +25,7 @@
 Per R34/R36 the residue's local positional uncertainty is the parser's
 mean heavy-atom B-factor, gated region-aware against `frConfidenceGatingThreshold`
 (framework) or `cdrConfidenceGatingThreshold` (CDR). For each metric we
-emit a parallel `<metric>LowConfidenceResidueFraction` Double — fraction
+emit a parallel `<metric>LowConfidenceResidueFraction` Double , fraction
 of *contributing* residues that exceed their region threshold (R36).
 """
 
@@ -112,6 +112,27 @@ def _centroid(atoms) -> tuple[float, float, float]:
     )
 
 
+def _weight_fns(in_bridge: dict):
+    """Build the three PSH / PPC / PNC weight closures over a shared
+    `in_bridge` map (R15a: salt-bridged residues take the glycine
+    hydrophobicity and zero charge). The same three are needed by both
+    `_chain_metrics` (per-chain, VHH mode) and the TAP-mode Fv pool
+    built from H+L; centralising avoids triple-duplicating them."""
+    def hydrophobicity(i, aa):
+        v = hydrophobicity_of(aa, in_bridge.get(i, False), KD_HYDROPHOBICITY, GLYCINE_HYDROPHOBICITY)
+        return v if v is not None else 0.0
+
+    def pos_charge_abs(i, aa):
+        c = charge_of(aa, in_bridge.get(i, False))
+        return c if c > 0 else 0.0
+
+    def neg_charge_abs(i, aa):
+        c = charge_of(aa, in_bridge.get(i, False))
+        return -c if c < 0 else 0.0
+
+    return hydrophobicity, pos_charge_abs, neg_charge_abs
+
+
 def detect_salt_bridges(parsed) -> set[tuple[str, int, str]]:
     """Walk every K/R + D/E pair, return the set of residue keys that are in
     a salt bridge. R15a uses N+ ↔ O- atom-pair distance ≤ 3.2 Å. Returned
@@ -182,7 +203,7 @@ def charge_of(aa_letter: str, in_salt_bridge: bool) -> float:
 
 @dataclass
 class FvMetrics:
-    """R24-R28 (Fv mode) — emitted only when 2 mapped chains and Fv-shape input."""
+    """R24-R28 (Fv mode) , emitted only when 2 mapped chains and Fv-shape input."""
     totalCdrLength: int
     psh: float
     pshPatchCount: int
@@ -193,7 +214,7 @@ class FvMetrics:
 
 @dataclass
 class VhhMetrics:
-    """R29-R33 (VHH mode) — single chain, type-restricted patches, CDRH3 compactness."""
+    """R29-R33 (VHH mode) , single chain, type-restricted patches, CDRH3 compactness."""
     totalCdrLength: int
     psh: float
     pshPatchCount: int
@@ -452,8 +473,6 @@ def compute_metrics(
 
     salt_bridges = detect_salt_bridges(parsed)
     chain_id_to_residues = dict(parsed.residues_by_chain)
-    h_scale = KD_HYDROPHOBICITY
-    h_glycine = GLYCINE_HYDROPHOBICITY
 
     h_present = heavy_chain_id and heavy_chain_id in chain_id_to_residues
     l_present = light_chain_id and light_chain_id in chain_id_to_residues
@@ -474,17 +493,7 @@ def _chain_metrics(chain_id, role, type_restricted_psh):
         regions = [region_for(role, r.res_seq, numbering_scheme, parsed.platforma_cdrs) for r in residues]
         cdr_vic = _cdr_vicinity_residues(residues, regions, rsasa_lookup, rsasa_buried_cutoff)
 
-        def h_weight(i, aa):
-            v = hydrophobicity_of(aa, in_bridge.get(i, False), h_scale, h_glycine)
-            return v if v is not None else 0.0
-
-        def pos_charge_abs(i, aa):
-            c = charge_of(aa, in_bridge.get(i, False))
-            return c if c > 0 else 0.0
-
-        def neg_charge_abs(i, aa):
-            c = charge_of(aa, in_bridge.get(i, False))
-            return -c if c < 0 else 0.0
+        h_weight, pos_charge_abs, neg_charge_abs = _weight_fns(in_bridge)
 
         psh, psh_patches, psh_contrib = _residue_pair_sum(
             cdr_vic, residues, aa_letters, h_weight,
@@ -506,7 +515,7 @@ def neg_charge_abs(i, aa):
     out: dict = {"mode": mode}
 
     if mode == "TAP":
-        # Combine H and L into a single CDR-vicinity / pair pool — but the
+        # Combine H and L into a single CDR-vicinity / pair pool , but the
         # spec defines PSH/PPC/PNC over the *Fv* (both chains together).
         # We compute per-chain CDR vicinities, then merge for inter-chain
         # pair contributions.
@@ -545,17 +554,7 @@ def neg_charge_abs(i, aa):
 
         cdr_vic = _cdr_vicinity_residues(residues, regions, rsasa_lookup, rsasa_buried_cutoff)
 
-        def h_weight(i, aa):
-            v = hydrophobicity_of(aa, in_bridge.get(i, False), h_scale, h_glycine)
-            return v if v is not None else 0.0
-
-        def pos_charge_abs(i, aa):
-            c = charge_of(aa, in_bridge.get(i, False))
-            return c if c > 0 else 0.0
-
-        def neg_charge_abs(i, aa):
-            c = charge_of(aa, in_bridge.get(i, False))
-            return -c if c < 0 else 0.0
+        h_weight, pos_charge_abs, neg_charge_abs = _weight_fns(in_bridge)
 
         psh, psh_patches, psh_contrib = _residue_pair_sum(cdr_vic, residues, aa_letters, h_weight)
         ppc, _, ppc_contrib = _residue_pair_sum(cdr_vic, residues, aa_letters, pos_charge_abs)

software/liabilities-script/motifs.py

@@ -1,6 +1,6 @@
 # Regex set + weights + risk taxonomy copied VERBATIM from
 # blocks/antibody-sequence-liabilities/liabilities-calc-script/src/definitions.py
-# (R16). Spec requires this block to be standalone — no import — to avoid
+# (R16). Spec requires this block to be standalone , no import , to avoid
 # silent half-coupling. A parity check vs the source is owed at M1.
 
 import math
@@ -84,7 +84,7 @@ class MotifHit:
     region: str | None
     # R18: absolute SASA (Ų) for the chemically-relevant residue, paired
     # with rSASA. Spec mandates both even though rSASA × Ala-X-Ala ref
-    # recovers it — keeping the raw value makes downstream analytics
+    # recovers it , keeping the raw value makes downstream analytics
     # comparable to TAP-style reports without a back-conversion step.
     sasa: float | None
     rsasa: float
@@ -106,7 +106,7 @@ class MotifHit:
 
 
 def _exposure_factor(rsasa: float | None) -> float:
-    # R20: logistic centered at 0.30 — avoids a cliff at the buried/exposed
+    # R20: logistic centered at 0.30 , avoids a cliff at the buried/exposed
     # cutoff so transitional residues taper smoothly into the score.
     if rsasa is None:
         return 0.0
@@ -173,13 +173,13 @@ def _score_motif_hit(
     arithmetic per hit.
 
     Computes:
-      • exposureFactor  — R20 logistic on rSASA (smooths the buried/exposed
+      • exposureFactor  , R20 logistic on rSASA (smooths the buried/exposed
                           cliff at 0.30).
-      • confidence       — residue's mean heavy-atom B-factor (R34).
-      • confidenceGated  — true when B-factor exceeds the region-aware
+      • confidence       , residue's mean heavy-atom B-factor (R34).
+      • confidenceGated  , true when B-factor exceeds the region-aware
                           threshold (R35); gated hits stay in the table
                           for traceability but skip motifStructuralRiskScore.
-      • weightedScore    — fixability_weight × region_weight × exposureFactor.
+      • weightedScore    , fixability_weight × region_weight × exposureFactor.
                           The R19 region weight rewards CDR-localized hits
                           (most therapeutically relevant) over framework.
     """
@@ -220,7 +220,7 @@ def detect_motifs(
 ):
     """Walk each chain, apply the regex set, and emit hits whose
     chemically-relevant residue (R17) has rSASA >= cutoff. Buried matches
-    are suppressed entirely per the spec, not just down-weighted — a buried
+    are suppressed entirely per the spec, not just down-weighted , a buried
     NG can't be deamidated, so flagging it would be a false positive.
 
     When numbering_scheme + heavy/light chain mapping are supplied, hits get
@@ -252,7 +252,7 @@ def detect_motifs(
                     continue
                 residue = residues[pos_in_seq]
                 if AA_THREE_TO_ONE.get(residue.res_name) is None:
-                    # Non-standard residue — skip (we can't trust the
+                    # Non-standard residue , skip (we can't trust the
                     # 1-letter translation that fed the regex match).
                     continue
                 key = (chain_id, f"{residue.res_seq}{residue.i_code}".strip())

software/liabilities-script/scoring.py

@@ -55,7 +55,7 @@ def _coerce_band_tuples(thresholds: dict) -> dict:
 def _flag_one_sided(value: float, spec: dict) -> str:
     """Three-band: amber within (amber_lo, amber_hi); red on the bad side
     of the band, green on the good side. `direction` picks which side is
-    bad — "high_bad" (most metrics) treats values above amber as red,
+    bad , "high_bad" (most metrics) treats values above amber as red,
     "low_bad" (SFvCSP) treats values below amber as red."""
     amber_lo, amber_hi = spec["amber"]
     direction = spec.get("direction", "high_bad")
@@ -141,7 +141,7 @@ def _cys_class_bump(cys_class: str, sidechain_rsasa: Optional[float], buried_cut
     return 0.0
 
 
-# R41a — engineering-grade fixability tiers + the four-step risk ladder.
+# R41a , engineering-grade fixability tiers + the four-step risk ladder.
 # `_ENGINEERING_FIXABILITIES` is the same set the sequence-liabilities
 # block uses for `classify_developability_risk` (motifs we can credibly
 # fix without a sequence redesign).
@@ -151,14 +151,14 @@ def _cys_class_bump(cys_class: str, sidechain_rsasa: Optional[float], buried_cut
 
 
 def _seq_risk_to_level(rc: str) -> str:
-    """R41a — sequence-side risk class → R41a level. Identity-ish mapping
+    """R41a , sequence-side risk class → R41a level. Identity-ish mapping
     that defends against unexpected `sequenceRiskClass` values by falling
     through to "None"."""
     return {"High": "High", "Medium": "Medium", "Low": "Low"}.get(rc, "None")
 
 
 def _developability_risk(motif_hits, flags: dict[str, str]) -> str:
-    """R41a — over engineering-fixable, non-gated motifs only:
+    """R41a , over engineering-fixable, non-gated motifs only:
        1. Take the highest sequenceRiskClass among them as the base level.
        2. Promote to Medium if ANY metric flag is amber.
        3. Promote to High if ANY metric flag is red.
@@ -184,11 +184,11 @@ def _developability_risk(motif_hits, flags: dict[str, str]) -> str:
 
 
 def _has_integrity_issue(motif_hits, cys_hits, rsasa_buried_cutoff: float) -> bool:
-    """R41a structuralIntegrityRisk — Present iff at least one of:
+    """R41a structuralIntegrityRisk , Present iff at least one of:
        • a canonical disulfide is broken or missing entirely (cys side),
        • an extra Cys is surface-exposed (free thiol → covalent aggregation risk),
        • a non-gated motif lives in the {hard_to_fix, structural} tier.
-    Any one is enough — short-circuits as soon as it finds a trigger."""
+    Any one is enough , short-circuits as soon as it finds a trigger."""
     for h in cys_hits:
         if h.cysClass in ("disulfide_broken", "disulfide_missing"):
             return True

software/liabilities-script/structure.py

@@ -61,12 +61,12 @@ class Parsed:
     chain_order: List[str] = field(default_factory=list)
     residues_by_chain: Dict[str, List[Residue]] = field(default_factory=dict)
     ssbonds: List[Ssbond] = field(default_factory=list)
-    # Spec R10 — CDR ranges from `REMARK 99 PLATFORMA CDR*` records emitted
+    # Spec R10 , CDR ranges from `REMARK 99 PLATFORMA CDR*` records emitted
     # by the Structure Prediction block. Shape: {"H": {"CDR1": (start, end),
     # "CDR2": (...), "CDR3": (...)}, "L": {...}}. Empty when not present;
     # downstream code falls back to scheme-aware fixed ranges.
     platforma_cdrs: Dict[str, Dict[str, Tuple[int, int]]] = field(default_factory=dict)
-    # Spec R9 — REMARK 99 chain identity is authoritative. Maps role ("H"/"L")
+    # Spec R9 , REMARK 99 chain identity is authoritative. Maps role ("H"/"L")
     # to the physical PDB chain letter the records reference. e.g. given
     # `REMARK 99 PLATFORMA CDRH1 B27-B38`, this becomes {"H": "B"}. Caller
     # uses this to override the user's heavy/light chain dropdowns when
@@ -117,7 +117,7 @@ def parse_pdb(text: str) -> Parsed:
                 if end < start:
                     continue
                 out.platforma_cdrs.setdefault(role, {})[f"CDR{cdr_idx}"] = (start, end)
-                # Spec R9 — record the physical PDB chain letter for this role.
+                # Spec R9 , record the physical PDB chain letter for this role.
                 # Later records for the same role must agree; conflicts are
                 # silently dropped (downstream falls back to the user's mapping).
                 existing = out.chain_role_to_pdb_chain.get(role)
@@ -158,7 +158,7 @@ def parse_pdb(text: str) -> Parsed:
             #   30-37 x   38-45 y      46-53 z  (Å, free-form floats)
             #   60-65 B-factor (Ų for crystals, Šfor ImmuneBuilder-predicted)
             #
-            # altLoc filter — multi-conformer side chains list each alternate
+            # altLoc filter , multi-conformer side chains list each alternate
             # location with a letter ('A', 'B', ...). Keeping only ' ' and 'A'
             # ensures geometry tests (distance pairs, salt bridges) don't
             # double-count atoms.
@@ -274,7 +274,7 @@ def region_for(
     """Return "FR1" / "CDR1" / "FR2" / "CDR2" / "FR3" / "CDR3" / "FR4" /
     None. Returns None when chain_role is unknown (e.g. antigen chains in a
     complex), scheme is invalid, or residue falls outside the V-domain (e.g.
-    constant region in a Fab — we don't tag CH1/CL).
+    constant region in a Fab , we don't tag CH1/CL).
 
     chain_role: "H" or "L". Pass "H" for VHH (single-chain camelid) too;
     its numbering follows heavy-chain convention.
@@ -305,7 +305,7 @@ def region_for(
     v_end = SCHEME_VDOMAIN_END[s][chain_role]
 
     if res_seq > v_end:
-        return None  # constant region — not tagged
+        return None  # constant region , not tagged
     if res_seq < cdr1_start:
         return "FR1"
     if cdr1_start <= res_seq <= cdr1_end:
@@ -513,7 +513,7 @@ def check_hallmark_tetrad(
     )
     if mismatch:
         observed = ", ".join(
-            f"{p}={o or '—'}" for p, o in zip(positions, one_letters)
+            f"{p}={o or '?'}" for p, o in zip(positions, one_letters)
         )
         print(
             f"WARN (spec R33): hallmark-tetrad residues at {observed} "

ui/src/composables/ptableCell.ts

@@ -56,6 +56,4 @@ export function readString(col: PTableColumn, i: number): string | null {
  *  `outputWithStatus` result whose `value` carries `fullTableHandle` for the
  *  pFrameDriver. Lives here (next to readCell) since both consumers
  *  (useClusterAssignments, useRunSummaryAlerts) operate on the same handle. */
-export type ScoresTableOutput =
-  | { ok?: boolean; value?: { fullTableHandle?: unknown } }
-  | undefined;
+export type ScoresTableOutput = { ok?: boolean; value?: { fullTableHandle?: unknown } } | undefined;