Round-2 viewer fixes: raw formatters, selectedAA, Scatter3D guard, Precursor

Re-audit follow-ups:
- Tables: drop precision from the dashNegativeOne columns (ProteoformMass,
  ProteoformLevelQvalue, Nmass, Cmass) so they show the RAW value like legacy
  (precision-4 was destroying tiny Q-values); keep the -1 -> "-" sentinel.
- TnT tag walk: publish selectedAA (= selectedAApos - StartPos when the
  selected residue is within the tag) so the selected-residue gold highlight
  renders; drop zero-valued tag masses (legacy filters != 0); silently skip
  absent components instead of st.warning (match Deconv).
- Deconv Scatter3D: pass the precursor-lookup columns only when all four are
  present in the frame, so stale 4-column threedim_SN_plot caches no longer
  crash the panel (ValueError) and degrade to the legacy per-scan view.
- Deconv SequenceView: stop emitting computed_mass (it forced the TnT branch,
  mislabeled the header "Proteoform", and disabled the variable-mod menu);
  emit the observed precursor_mass from the selected scan so the "Precursor"
  header renders and variable mods stay enabled.
- Remove dead code (_data_path, unused imports) and drop the inert
  internal_fragment_map from the Deconv selectable layout (parity with TnT).

Author: claude

content/FLASHDeconv/FLASHDeconvLayoutManager.py

@@ -219,11 +219,13 @@ def handleSettingButtons():
 
 def setSequenceView():
     if get_sequence() is not None:
+        # Parity with the TnT layout: `internal_fragment_map` was dropped because
+        # neither the legacy grid nor the OI viewer renders it (it produces
+        # nothing). Only the sequence view is added on sequence submission.
         global COMPONENT_OPTIONS
-        COMPONENT_OPTIONS = COMPONENT_OPTIONS + ['Sequence view (Mass table needed)',
-                                                 'Internal fragment map (Mass table needed)']
+        COMPONENT_OPTIONS = COMPONENT_OPTIONS + ['Sequence view (Mass table needed)']
         global COMPONENT_NAMES
-        COMPONENT_NAMES = COMPONENT_NAMES + ['sequence_view', 'internal_fragment_map']
+        COMPONENT_NAMES = COMPONENT_NAMES + ['sequence_view']
 
 
 # page initialization

content/FLASHDeconv/FLASHDeconvViewerOI.py

@@ -30,7 +30,7 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import List, Optional
 
 import polars as pl
 import streamlit as st
@@ -45,10 +45,7 @@
     Table,
 )
 
-from content.FLASHDeconv.deconv_sequence import (
-    bake_fixed_modifications,
-    theoretical_mass,
-)
+from content.FLASHDeconv.deconv_sequence import bake_fixed_modifications
 
 # Map the layout COMPONENT_NAMES (FLASHDeconvLayoutManager) to a builder. Every
 # builder returns a *callable* OpenMS-Insight component already wired with the
@@ -109,15 +106,6 @@ def _component_cache_dir(file_manager, experiment_id: str) -> str:
     return str(cache_root)
 
 
-def _data_path(file_manager, experiment_id: str, name_tag: str) -> Optional[str]:
-    """Resolve the on-disk parquet path for a stored frame, or None if absent."""
-    if not file_manager.result_exists(experiment_id, name_tag):
-        return None
-    res = file_manager.get_results(experiment_id, [name_tag], partial=True)
-    path = res.get(name_tag)
-    return str(path) if path is not None else None
-
-
 def _lazy(file_manager, experiment_id: str, name_tag: str) -> Optional[pl.LazyFrame]:
     """Load a stored frame as a polars LazyFrame, or None if absent."""
     if not file_manager.result_exists(experiment_id, name_tag):
@@ -281,6 +269,25 @@ def _build_scatter3d(file_manager, experiment_id: str, cache_dir: str):
     data = _lazy(file_manager, experiment_id, "threedim_SN_plot")
     if data is None:
         return None
+    # MS2 precursor-signal lookup: locate the precursor scan's row
+    # (Scan == PrecursorScan) and the index into its MonoMass array whose value
+    # matches PrecursorMass. Fresh parses (src/parse/deconv.py) emit all four
+    # columns (7-col frame), but STALE/OLD ``threedim_SN_plot.pq`` caches only
+    # carry the 4 legacy columns (index, PrecursorScan, SignalPeaks, NoisyPeaks).
+    # Scatter3D._validate_mappings raises ValueError if any precursor column is
+    # configured-but-missing, and this builder runs OUTSIDE the page try/except,
+    # so we MUST schema-gate: pass the precursor params ONLY when ALL FOUR
+    # columns are present; otherwise fall back to the legacy per-scan behavior.
+    schema_names = data.collect_schema().names()
+    precursor_cols = ("Scan", "PrecursorScan", "PrecursorMass", "MonoMass")
+    precursor_kwargs = {}
+    if all(col in schema_names for col in precursor_cols):
+        precursor_kwargs = {
+            "scan_column": "Scan",
+            "precursor_scan_column": "PrecursorScan",
+            "precursor_mass_column": "PrecursorMass",
+            "mono_mass_column": "MonoMass",
+        }
     # 3D S/N plot: scanIndex value-filters on `index`; massIndex handled internally
     # as an array subscript (NOT a value filter).
     return Scatter3D(
@@ -289,16 +296,9 @@ def _build_scatter3d(file_manager, experiment_id: str, cache_dir: str):
         scan_filter="index",
         signal_column="SignalPeaks",
         noisy_column="NoisyPeaks",
-        # MS2 precursor-signal lookup: locate the precursor scan's row
-        # (Scan == PrecursorScan) and the index into its MonoMass array whose
-        # value matches PrecursorMass. All four columns are emitted on
-        # threedim_SN_plot by src/parse/deconv.py.
-        scan_column="Scan",
-        precursor_scan_column="PrecursorScan",
-        precursor_mass_column="PrecursorMass",
-        mono_mass_column="MonoMass",
         title="Precursor Signals",
         cache_path=cache_dir,
+        **precursor_kwargs,
     )
 
 
@@ -318,6 +318,49 @@ def _build_fdr_plot(file_manager, experiment_id: str, cache_dir: str):
     )
 
 
+def _selected_precursor_mass(file_manager, experiment_id: str, state_manager):
+    """Observed PrecursorMass of the currently-selected scan, or None.
+
+    Mirrors the legacy "Precursor" mass header (src/render/update.py get_sequence
+    / per-scan data), which reads ``PrecursorMass`` from the selected scan. The
+    selected scan is the ``scanIndex`` selection (== the scan_table ``index``);
+    we look its ``PrecursorMass`` up in the scan_table frame. Returns None when no
+    scan is selected, the table/column is absent, or the value is 0.0 (the legacy
+    sentinel for "scan not eligible for this view", which renders an empty header).
+    """
+    if state_manager is None:
+        return None
+    selected_index = state_manager.get_selection(SCAN_KEY)
+    if selected_index is None:
+        return None
+    scan_table = _lazy(file_manager, experiment_id, "scan_table")
+    if scan_table is None:
+        return None
+    names = scan_table.collect_schema().names()
+    if "index" not in names or "PrecursorMass" not in names:
+        return None
+    try:
+        row = (
+            scan_table.filter(pl.col("index") == selected_index)
+            .select("PrecursorMass")
+            .collect()
+        )
+    except Exception:
+        return None
+    if row.height == 0:
+        return None
+    value = row["PrecursorMass"][0]
+    if value is None:
+        return None
+    try:
+        value = float(value)
+    except (TypeError, ValueError):
+        return None
+    if value == 0.0:
+        return None
+    return value
+
+
 def _get_sequence(file_manager):
     """Return the submitted (sequence, fix_C, fix_M) tuple, or None."""
     if not file_manager.result_exists("sequence", "sequence"):
@@ -374,17 +417,29 @@ def _build_sequence_view(
         pl.col("SumIntensity").alias("intensity"),
     )
 
-    # Pass the sequence as a single-row frame so we can attach the optional
-    # `computed_mass` column (the baked sequence's monoisotopic mass) for the
-    # SequenceView mass header. Falls back to a plain string when pyOpenMS is
-    # unavailable (theoretical_mass returns None) so the column is simply omitted.
-    seq_mass = theoretical_mass(sequence_string)
-    if seq_mass is not None:
+    # Mass header parity (legacy Deconv shows the "Precursor" header:
+    # Theoretical / Observed / Δ). We MUST NOT emit `computed_mass` here: in the
+    # OI SequenceView Vue, `displayTnT = (computedMass !== undefined)`, which would
+    # (a) mislabel the header "Proteoform" instead of "Precursor", and (b) force
+    # `disableVariableModifications = true`, silently disabling the variable/custom
+    # modification context menu that this path explicitly enables via
+    # `disable_variable_modifications=False`. So `computed_mass` stays dropped.
+    #
+    # Instead emit `precursor_mass` = the OBSERVED precursor mass of the selected
+    # scan (legacy reads `PrecursorMass` from the selected scan; see
+    # src/render/update.py get_sequence). When a scan is selected and its
+    # PrecursorMass is reachable in the scan_table, wire it so the "Precursor"
+    # header renders; otherwise omit it (header observed/Δ rows render empty) --
+    # either way the variable-mod menu stays enabled.
+    precursor_mass = _selected_precursor_mass(
+        file_manager, experiment_id, state_manager
+    )
+    if precursor_mass is not None:
         sequence_data = pl.LazyFrame(
             {
                 "sequence": [sequence_string],
                 "precursor_charge": [1],
-                "computed_mass": [seq_mass],
+                "precursor_mass": [precursor_mass],
             }
         )
     else:

content/FLASHTnT/FLASHTnTViewerOI.py

@@ -170,20 +170,22 @@ def _stamp_proteoform_index(
     {"title": "Accession", "field": "accession", "sorter": "string"},
     {"title": "Description", "field": "description", "sorter": "string"},
     {"title": "Length", "field": "length", "sorter": "number"},
-    # Legacy TabulatorProteinTable.vue renders the `-1` sentinel as "-" (the raw
-    # value otherwise). The OI `dashNegativeOne` formatter reproduces the sentinel
-    # rule; precision 4 matches the app-wide `toFixedFormatter()` default (4 dp,
-    # used for every other numeric mass column, e.g. MonoMass in the mass table).
+    # Legacy TabulatorProteinTable.vue renders the `-1` sentinel as "-" and the
+    # RAW unrounded value otherwise (TabulatorProteinTable.vue:78-81). The OI
+    # `dashNegativeOne` formatter reproduces the sentinel rule and renders the raw
+    # value when `precision` is omitted -- so we drop `formatterParams` to avoid
+    # rounding (critical for tiny Q-values: 0.00012 must NOT become 0.0001).
     {"title": "Mass", "field": "ProteoformMass", "sorter": "number",
-     "formatter": "dashNegativeOne", "formatterParams": {"precision": 4}},
+     "formatter": "dashNegativeOne"},
     {"title": "No. of Matched Fragments", "field": "MatchingFragments", "sorter": "number"},
     {"title": "No. of Modifications", "field": "ModCount", "sorter": "number"},
     {"title": "No. of Tags", "field": "TagCount", "sorter": "number"},
     {"title": "Score", "field": "Score", "sorter": "number"},
-    # Q-Value also uses the `-1 -> "-"` sentinel rule (legacy formatter); 4 dp
-    # matches the app-wide default decimal precision.
+    # Q-Value also uses the `-1 -> "-"` sentinel rule with the RAW unrounded value
+    # otherwise (TabulatorProteinTable.vue:105-108). No `formatterParams` so the
+    # raw value is shown -- rounding would corrupt tiny Q-values (e.g. 0.00012).
     {"title": "Q-Value (Proteoform Level)", "field": "ProteoformLevelQvalue", "sorter": "number",
-     "formatter": "dashNegativeOne", "formatterParams": {"precision": 4}},
+     "formatter": "dashNegativeOne"},
 ]
 
 # TabulatorTagTable.vue columns -> tag_dfs fields.
@@ -194,12 +196,13 @@ def _stamp_proteoform_index(
     {"title": "Sequence", "field": "TagSequence", "sorter": "string"},
     {"title": "Length", "field": "Length", "sorter": "number"},
     {"title": "Tag Score", "field": "Score", "sorter": "number"},
-    # N/C mass use the legacy `-1 -> "-"` sentinel rule (TabulatorTagTable.vue
-    # ~72-83); precision 4 matches the app-wide mass decimal default.
+    # N/C mass use the legacy `-1 -> "-"` sentinel rule and render the RAW
+    # unrounded value otherwise (TabulatorTagTable.vue:72-83). No `formatterParams`
+    # so the raw value is shown (rounding would lose precision on the mass offset).
     {"title": "N mass", "field": "Nmass", "sorter": "number",
-     "formatter": "dashNegativeOne", "formatterParams": {"precision": 4}},
+     "formatter": "dashNegativeOne"},
     {"title": "C mass", "field": "Cmass", "sorter": "number",
-     "formatter": "dashNegativeOne", "formatterParams": {"precision": 4}},
+     "formatter": "dashNegativeOne"},
     {"title": "Δ mass", "field": "DeltaMass", "sorter": "number"},
 ]
 
@@ -310,15 +313,18 @@ def _resolve_tag_masses(file_manager, experiment_id: str, state_manager) -> None
 
     Only the selected tag's row is collected (filtered by ``TagIndex``). The tag
     ``mzs`` are a comma-joined string (trailing comma); parse and drop non-numeric
-    entries, keeping the STORED order (ascending for C-term tags, descending for
-    N-term tags). ``TagSequence`` gives the residue letters; the legacy walks
-    consecutive stored masses labelling gap ``i`` with ``sequence[len-1-i]`` —
-    i.e. the REVERSED sequence aligns to the stored-order gaps regardless of
-    anchoring (verified against both an ascending C-term and a descending N-term
-    tag). Do NOT sort the masses: sorting breaks the alignment for descending
-    (N-term) tags. The published value is a dict
-    ``{"masses": [...], "residues": [...]}`` consumed by the OI LinePlot tag walk;
-    when no residues are available it carries only masses (highlight-only)."""
+    AND zero entries (legacy ``number !== 0``), keeping the STORED order (ascending
+    for C-term tags, descending for N-term tags). ``TagSequence`` gives the residue
+    letters; the legacy walks consecutive stored masses labelling gap ``i`` with
+    ``sequence[len-1-i]`` — i.e. the REVERSED sequence aligns to the stored-order
+    gaps regardless of anchoring (verified against both an ascending C-term and a
+    descending N-term tag). Do NOT sort the masses: sorting breaks the alignment
+    for descending (N-term) tags. The published value is a dict
+    ``{"masses": [...], "residues": [...], "nTerminal": bool}`` consumed by the OI
+    LinePlot tag walk; when no residues are available it carries only masses
+    (highlight-only). When a residue within the selected tag's span is also
+    selected (``selectedAApos``), a tag-relative ``selectedAA`` index is added so
+    the walk gold-highlights that residue (legacy ``selectedAApos - StartPos``)."""
     def _clear_all() -> None:
         state_manager.clear_selection(TAG_MASSES_KEY)
         state_manager.clear_selection(TAG_SPAN_KEY)
@@ -355,8 +361,12 @@ def _clear_all() -> None:
 
     raw = selected["tag_masses"][0]
     # Keep STORED order (do not sort) so the reversed-sequence walk aligns for
-    # both ascending (C-term) and descending (N-term) tags.
-    masses = [m for m in raw if m is not None] if raw is not None else []
+    # both ascending (C-term) and descending (N-term) tags. Drop null AND zero
+    # masses (legacy `number !== 0`, TabulatorTagTable.vue:140): a literal 0 mass
+    # would misalign the reversed-residue walk.
+    masses = (
+        [m for m in raw if m is not None and m != 0] if raw is not None else []
+    )
     if not masses:
         _clear_all()
         return
@@ -373,15 +383,33 @@ def _clear_all() -> None:
     n_mass = selected["n_mass"][0]
     n_terminal = (n_mass is not None) and (float(n_mass) == -1.0)
 
-    state_manager.set_selection(
-        TAG_MASSES_KEY,
-        {"masses": list(masses), "residues": residues, "nTerminal": n_terminal},
-    )
+    tag_masses = {
+        "masses": list(masses),
+        "residues": residues,
+        "nTerminal": n_terminal,
+    }
 
-    # Tag-span highlight on the SequenceView. StartPos/EndPos are protein-absolute
-    # (matching the full-protein residue grid), so they bracket the tag directly.
+    # Selected-residue gold (#F3A712) highlight (legacy
+    # `selectedTag.selectedAA = selectedAApos - StartPos`, TabulatorTagTable.vue:
+    # 151,169). When a residue is selected (AA_KEY holds its protein-absolute
+    # position) AND it falls within the selected tag's [StartPos, EndPos] span,
+    # publish the tag-relative residue index so the LinePlot tag walk highlights
+    # that residue; omit otherwise (no highlight).
     start_pos = selected["start_pos"][0]
     end_pos = selected["end_pos"][0]
+    selected_aa_pos = state_manager.get_selection(AA_KEY)
+    if (
+        selected_aa_pos is not None
+        and start_pos is not None
+        and end_pos is not None
+        and int(start_pos) <= int(selected_aa_pos) <= int(end_pos)
+    ):
+        tag_masses["selectedAA"] = int(int(selected_aa_pos) - int(start_pos))
+
+    state_manager.set_selection(TAG_MASSES_KEY, tag_masses)
+
+    # Tag-span highlight on the SequenceView. StartPos/EndPos are protein-absolute
+    # (matching the full-protein residue grid), so they bracket the tag directly.
     if start_pos is not None and end_pos is not None:
         state_manager.set_selection(
             TAG_SPAN_KEY,
@@ -799,7 +827,9 @@ def render_experiment_panel(
                     best_per_spectrum=best_per_spectrum,
                 )
                 if component is None:
-                    st.warning(f"No data for '{comp_name}'.")
+                    # Silently skip an absent component (data frame missing),
+                    # matching the Deconv viewer's documented intent and avoiding
+                    # noisy warnings on stale / partial caches.
                     continue
                 key = f"tnt_oi_{panel_index}_{row_index}_{col_index}_{comp_name}"
                 component(key=key, state_manager=state_manager)