vimol 0.1.4__tar.gz → 0.1.6__tar.gz

{vimol-0.1.4/src/vimol.egg-info → vimol-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vimol
-Version: 0.1.4
+Version: 0.1.6
 Summary: A terminal molecular viewer and editor using the Kitty graphics protocol
 Author: vimol contributors
 License-Expression: MIT

{vimol-0.1.4 → vimol-0.1.6}/src/vimol/__init__.py

@@ -36,7 +36,7 @@ from . import select
 from .structures import StructureSet, Structure, Transform, AlignmentResult
 from .align import kabsch, superpose, permutation_search, subset_search
 
-__version__ = "0.1.4"
+__version__ = "0.1.6"
 
 __all__ = [
     "Molecule", "VectorField", "Camera", "Renderer", "Style", "Scene", "MoleculeWidget",

vimol-0.1.6/src/vimol/cistrans.py

@@ -0,0 +1,266 @@
+"""Cis/trans classification of peptide and peptoid backbone bonds.
+
+A peptide bond's rotation is described by the omega dihedral,
+``Cα(i)-C(i)-N(i+1)-Cα(i+1)``: near 0° it is cis, near 180° trans. This is
+the same walk :func:`vimol.select.peptide_motifs` already builds for the
+ribbon/RMSD backbone presets, and it does not depend on where a residue's
+side chain attaches -- a peptoid's N-substituted backbone (no amide H) is
+the same N-Cα-C path a peptide's is, so no separate peptoid handling is
+needed here.
+"""
+from __future__ import annotations
+
+import math
+import re
+from typing import List, Optional, Sequence, Tuple
+
+from .editor import measure_value
+from .molecule import Molecule
+# The private variant: classification needs the bond graph alongside the
+# runs to notice a cyclic backbone's ring-closing peptide bond, which the
+# public runs-only view cannot express.
+from .select import _peptide_motifs, ring_systems
+
+# |omega| below this is cis, at or above it is trans -- the standard
+# literature convention, and a strict binary split with no third bucket.
+_CIS_MAX_ABS_OMEGA = 90.0
+
+# A ring system at least this big, carrying amides, makes the molecule a
+# macrocycle: a cyclic peptide/peptoid, where the ring's own amides are the
+# conformational question and the exocyclic tail is noise. Twelve is the
+# usual line between an ordinary ring and a macrocycle, and it sits well
+# clear of proline's pyrrolidine (5) and of the 6-membered diketopiperazine
+# that a cyclic dipeptide forms -- both of which stay on the linear path,
+# where the head-to-tail closure already handles them.
+_MACROCYCLE_MIN_ATOMS = 12
+
+# Boltzmann population of each classification across a multi-frame file,
+# weighted by the energy in each frame's XYZ comment line. Energies are
+# always read as Hartree (the convention CREST/xtb/ORCA write when the
+# comment is a bare or labeled electronic energy) -- there is deliberately
+# no unit auto-detection: a silently wrong unit produces a distribution that
+# still looks plausible (collapsed onto one conformer, or smeared flat),
+# so getting it wrong is worse than not offering the feature at all.
+TEMPERATURE_K = 298.15
+_KB_HARTREE_PER_K = 3.166811563e-6
+_KT_HARTREE = _KB_HARTREE_PER_K * TEMPERATURE_K
+
+# A bare float is CREST's own convention (the whole comment IS the energy).
+_BARE_FLOAT_RE = re.compile(r"^[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$")
+# "energy", "energy:", "energy=", "E", "E=" ... followed by the number --
+# the xtb/ORCA-style labeled convention.
+_LABELED_ENERGY_RE = re.compile(
+    r"(?:^|\s)(?:energy|e)\s*[:=]?\s*([+-]?\d+\.\d+(?:[eE][+-]?\d+)?)",
+    re.IGNORECASE)
+# Fallback: a decimal-point number anywhere in the comment (excludes bare
+# integers like a model/frame index, which a comment often also carries).
+_DECIMAL_RE = re.compile(r"[+-]?\d+\.\d+(?:[eE][+-]?\d+)?")
+
+
+def parse_energy(comment: str) -> Optional[float]:
+    """Pull one energy value out of an XYZ comment line, or ``None``.
+
+    Three conventions, tried in order of confidence: the whole comment is
+    the number (CREST); a label ("energy"/"E", "=" or ":" optional)
+    precedes it (xtb, ORCA); or exactly one decimal number appears
+    anywhere in the comment. Two or more equally plausible numbers with no
+    label to disambiguate them is not a confident read -- ``None``, same
+    as a comment with no number at all.
+    """
+    text = comment.strip()
+    if not text:
+        return None
+    if _BARE_FLOAT_RE.match(text):
+        return float(text)
+    labeled = _LABELED_ENERGY_RE.search(text)
+    if labeled:
+        return float(labeled.group(1))
+    decimals = _DECIMAL_RE.findall(text)
+    if len(decimals) == 1:
+        return float(decimals[0])
+    return None
+
+
+def boltzmann_breakdown(classifications: Sequence[str],
+                        energies_hartree: Sequence[float],
+                        min_pct: float = 1.0) -> List[Tuple[str, float]]:
+    """Boltzmann-weighted population of each distinct classification string.
+
+    ``classifications`` and ``energies_hartree`` are parallel, one pair per
+    frame -- every frame must already have a real (non-``None``)
+    classification and energy; filtering that is the caller's job, not
+    this function's. Weights are relative to the group's own minimum
+    energy (numerically stable, and the group's reference point is the
+    only one that matters for population *within* the group). Returns
+    ``(classification, percentage)`` pairs, rounded to nothing here (the
+    caller rounds for display), sorted by descending population, with
+    anything under ``min_pct`` dropped -- population that round to 100%
+    across the survivors is not guaranteed, by design.
+    """
+    if not classifications or len(classifications) != len(energies_hartree):
+        return []
+    e_min = min(energies_hartree)
+    weights = [math.exp(-(e - e_min) / _KT_HARTREE) for e in energies_hartree]
+    total = sum(weights)
+    populations: dict = {}
+    for cls, w in zip(classifications, weights):
+        populations[cls] = populations.get(cls, 0.0) + w
+    breakdown = [(cls, 100.0 * w / total) for cls, w in populations.items()]
+    breakdown = [item for item in breakdown if item[1] >= min_pct]
+    breakdown.sort(key=lambda item: item[1], reverse=True)
+    return breakdown
+
+
+def _amide_ring_systems(molecule: Molecule, neighbors, symbols, carbonyls):
+    """Macrocyclic ring systems, each with the amide C-N bonds inside it.
+
+    Returns ``[(ring_atoms, [(carbonyl_C, amide_N), ...]), ...]``, only for
+    systems of at least :data:`_MACROCYCLE_MIN_ATOMS` atoms that actually
+    carry an amide. The size test alone is not enough: a steroid or a
+    porphyrin is a big ring system with no amide in it, and restricting a
+    peptide's classification to one of those would report nothing at all.
+
+    Built from the ``neighbors`` the motif walk already returned, so a
+    frame is never bond-perceived twice -- this runs over every frame of a
+    multi-thousand-frame ensemble on one keypress.
+    """
+    systems = []
+    for ring in ring_systems(neighbors):
+        if len(ring) < _MACROCYCLE_MIN_ATOMS:
+            continue
+        inside = set(ring)
+        amides = []
+        for carbon in ring:
+            # The motif walk's own carbonyl verdict, not a second opinion:
+            # a rule of "terminal oxygen" would also accept a hydroxyl and
+            # read hydrogen-free threonine's C-OH as an amide.
+            if carbon not in carbonyls:
+                continue
+            amides.extend((carbon, n) for n in neighbors[carbon]
+                          if symbols[n] == "N" and n in inside)
+        if amides:
+            systems.append((inside, amides))
+    return systems
+
+
+def _ring_omega_atoms(carbon: int, nitrogen: int, ring, neighbors):
+    """The two Cα-side atoms of a ring amide no motif pair describes.
+
+    Each is the bond partner's *other* neighbour inside the ring. Ambiguity
+    is refused rather than guessed: in a proline fused into a macrocycle the
+    nitrogen has two ring neighbours (Cα and Cδ), and picking Cδ would flip
+    c and t on exactly the residue whose cis state people care about. Those
+    bonds are motif pairs anyway, and are classified as such before this is
+    ever reached.
+
+    KNOWN GAP: refusing drops that amide from the string entirely, which is
+    the same silent class-merge that including the lactam exists to
+    prevent. Reaching it needs a non-motif amide sitting at a ring fusion
+    point, which nothing seen so far does -- but a third state would be
+    honester than omission if something ever gets there.
+    """
+    carbon_side = [x for x in neighbors[carbon] if x in ring and x != nitrogen]
+    nitrogen_side = [x for x in neighbors[nitrogen] if x in ring and x != carbon]
+    if len(carbon_side) != 1 or len(nitrogen_side) != 1:
+        return None
+    return carbon_side[0], nitrogen_side[0]
+
+
+def classify_cis_trans(molecule: Molecule) -> Optional[str]:
+    """One ``c``/``t`` character per peptide bond, chain by chain.
+
+    A linear chain of N residues yields N-1 characters, one per
+    Cα(i)-C(i)-N(i+1) junction; a *cyclic* chain yields N, the extra one
+    for the ring-closing bond back from the last residue's carbonyl to the
+    first residue's nitrogen -- omitting it would silently merge cyclic
+    conformers that differ only in that omega. Multiple chains (a real
+    chain break, not just a gap in the file) join with ``/``, in the order
+    the motif walk returns them. A chain of a single residue has no
+    peptide bond to classify and is dropped; ``None`` means nothing in the
+    molecule survived that filter.
+
+    A MACROCYCLE is classified on its ring alone (see
+    :data:`_MACROCYCLE_MIN_ATOMS`). In a cyclic peptide it is the ring's
+    amides that are the conformational question; a pendant tail's omegas
+    are a separate, largely independent story, and letting them into the
+    same string makes every Boltzmann class a product of the two. The ring
+    string covers every amide in the ring, including a side-chain lactam
+    that no backbone walk passes through -- that bond closes the ring, and
+    dropping it would merge conformers differing only there.
+    """
+    runs, neighbors, symbols, carbonyls = _peptide_motifs(molecule)
+
+    def omega_char(ca_i: int, c_i: int, n_j: int, ca_j: int) -> str:
+        omega = measure_value(molecule, (ca_i, c_i, n_j, ca_j))
+        return ("c" if omega is not None and abs(omega) < _CIS_MAX_ABS_OMEGA
+                else "t")
+
+    macrocycles = _amide_ring_systems(molecule, neighbors, symbols, carbonyls)
+    if macrocycles:
+        chains = []
+        for ring, amides in macrocycles:
+            # Motif pairs first, in backbone order -- they carry real Cα
+            # atoms, and their order is the one a chemist reads the ring
+            # in. Whatever is left (a lactam) follows by atom index. The
+            # order must come from topology alone: rotating the string to
+            # some "canonical" start chosen by its own c/t values would
+            # collapse cttt and tctt into one Boltzmann class.
+            chars, done = [], set()
+            for run in runs:
+                for (_n_i, ca_i, c_i, _o_i), (n_j, ca_j, _c_j, _o_j) in zip(run, run[1:]):
+                    if (c_i, n_j) in amides and (c_i, n_j) not in done:
+                        done.add((c_i, n_j))
+                        chars.append(omega_char(ca_i, c_i, n_j, ca_j))
+                if len(run) < 2:
+                    continue
+                first_n, first_ca = run[0][0], run[0][1]
+                last_ca, last_c = run[-1][1], run[-1][2]
+                if (last_c, first_n) in amides and (last_c, first_n) not in done:
+                    done.add((last_c, first_n))
+                    chars.append(omega_char(last_ca, last_c, first_n, first_ca))
+            for carbon, nitrogen in sorted(set(amides) - done):
+                ends = _ring_omega_atoms(carbon, nitrogen, ring, neighbors)
+                if ends is not None:
+                    chars.append(omega_char(ends[0], carbon, nitrogen, ends[1]))
+            if chars:
+                chains.append("".join(chars))
+        if chains:
+            return "/".join(chains)
+
+    chains = []
+    for run in runs:
+        if len(run) < 2:
+            continue
+        chars = [omega_char(ca_i, c_i, n_j, ca_j)
+                 for (_n_i, ca_i, c_i, _o_i), (n_j, ca_j, _c_j, _o_j)
+                 in zip(run, run[1:])]
+        first_n, first_ca = run[0][0], run[0][1]
+        last_ca, last_c = run[-1][1], run[-1][2]
+        if first_n in neighbors[last_c]:
+            chars.append(omega_char(last_ca, last_c, first_n, first_ca))
+        chains.append("".join(chars))
+    if not chains:
+        return None
+    return "/".join(chains)
+
+
+def macrocycle_size(molecule: Molecule) -> Optional[int]:
+    """Atom count of the macrocycle a classification is restricted to, if
+    any -- what the viewer tells the user so a string that got shorter does
+    not read as a regression.
+
+    This counts the fused ring SYSTEM, not a single cycle: a proline in the
+    ring shares its N-Cα bond with the pyrrolidine, so the two fuse and the
+    count runs three past the macrocycle's own size. Hence the viewer says
+    "N ring atoms" and not "N-membered", which would be a claim about a
+    cycle and would be wrong exactly there.
+    """
+    runs, neighbors, symbols, carbonyls = _peptide_motifs(molecule)
+    if not runs:
+        return None
+    systems = _amide_ring_systems(molecule, neighbors, symbols, carbonyls)
+    return max((len(ring) for ring, _amides in systems), default=None)
+
+
+__all__ = ["classify_cis_trans", "macrocycle_size", "parse_energy",
+           "boltzmann_breakdown", "TEMPERATURE_K"]

{vimol-0.1.4 → vimol-0.1.6}/src/vimol/select.py

@@ -25,27 +25,98 @@ def heavy_atoms(molecule: Molecule) -> np.ndarray:
     )
 
 
-def largest_ring_system(molecule: Molecule) -> np.ndarray:
-    """Return the largest fused ring system in the heavy-atom bond graph.
+def bridge_edges(adjacency) -> set:
+    """Every edge whose removal would disconnect the graph (Tarjan lowlink).
+
+    ``adjacency[i]`` is any iterable of *i*'s neighbours. Edges come back
+    normalized to ``(low, high)``. The bridge set is a property of the graph
+    alone, so it does not depend on the file's atom order -- which is what
+    makes the ring systems built from it well-defined.
+
+    Iterative on purpose: the recursive form is shorter but blows the
+    interpreter's stack on a few-thousand-atom protein, and the selection
+    presets run on proteins.
+    """
+    n = len(adjacency)
+    discovered = [-1] * n
+    low = [0] * n
+    bridges = set()
+    clock = 0
+    for root in range(n):
+        if discovered[root] != -1:
+            continue
+        discovered[root] = low[root] = clock
+        clock += 1
+        stack = [(root, -1, iter(adjacency[root]))]
+        while stack:
+            atom, parent, pending = stack[-1]
+            for other in pending:
+                if other == parent:
+                    continue        # the edge we arrived by, not a back edge
+                if discovered[other] == -1:
+                    discovered[other] = low[other] = clock
+                    clock += 1
+                    stack.append((other, atom, iter(adjacency[other])))
+                    break           # descend; this iterator resumes later
+                low[atom] = min(low[atom], discovered[other])
+            else:
+                stack.pop()
+                if stack:
+                    up = stack[-1][0]
+                    low[up] = min(low[up], low[atom])
+                    # Nothing under `atom` reaches `up` or higher, so the
+                    # only way back out is the edge itself.
+                    if low[atom] > discovered[up]:
+                        bridges.add((min(up, atom), max(up, atom)))
+    return bridges
+
+
+def ring_systems(adjacency) -> List[Tuple[int, ...]]:
+    """Fused ring systems in ``adjacency``, each a sorted tuple of atoms.
+
+    An edge lies on a cycle exactly when it is NOT a bridge, so deleting
+    the bridges leaves the cyclic part and nothing else; each surviving
+    connected component is one fused ring system. Anything smaller than a
+    three-membered cycle is dropped, which also discards the isolated atoms
+    that bridge deletion leaves behind (every hydrogen among them).
+
+    This replaced a 2-core peel, which was wrong for a reason worth
+    recording: an atom survives the 2-core when it merely has two
+    neighbours, not when it lies on a cycle. A plain chain joining two
+    rings is degree-2 all the way along, so peeling kept it, and the
+    "largest ring system" of a macrocycle with a pendant phenyl came back
+    as both rings PLUS the chain between them.
+    """
+    bridges = bridge_edges(adjacency)
+    n = len(adjacency)
+    seen = [False] * n
+    systems = []
+    for root in range(n):
+        if seen[root]:
+            continue
+        seen[root] = True
+        component = [root]
+        stack = [root]
+        while stack:
+            atom = stack.pop()
+            for other in adjacency[atom]:
+                if seen[other] or (min(atom, other), max(atom, other)) in bridges:
+                    continue
+                seen[other] = True
+                component.append(other)
+                stack.append(other)
+        if len(component) >= 3:
+            systems.append(tuple(sorted(component)))
+    return systems
 
-    An atom lies on at least one cycle exactly when it survives the graph's
-    2-core, so repeatedly stripping terminal atoms leaves the cyclic part and
-    nothing else; the largest connected component of that core is the answer.
-    Both passes are O(N+E).
 
-    A depth-first cycle basis would be just as cheap but is not a well-defined
-    answer: which fundamental cycles it finds depends on the file's atom
-    order, so the same molecule written twice can yield different subsets.
-    The 2-core does not, and it keeps fused systems (naphthalene, steroids,
-    porphyrins) whole -- which is what a rigid-core RMSD subset wants anyway.
+def heavy_adjacency(molecule: Molecule) -> List[set]:
+    """Neighbour sets over heavy atoms only, hydrogens dropped.
 
     Explicit bonds are preferred; unnamed formats fall back to the same
     spatially hashed bond perception used by the viewer.
     """
     n = molecule.n_atoms
-    if n < 3:
-        return np.empty(0, dtype=np.int64)
-
     bonds = molecule.bonds or perceive_bonds(molecule)
     adjacency = [set() for _ in range(n)]
     symbols = molecule.symbols
@@ -57,46 +128,25 @@ def largest_ring_system(molecule: Molecule) -> np.ndarray:
             continue
         adjacency[i].add(j)
         adjacency[j].add(i)
+    return adjacency
 
-    # Peel to the 2-core. Dropping a terminal atom can strand its neighbor,
-    # so the walk continues until nothing is left below degree two.
-    degree = np.fromiter((len(row) for row in adjacency), dtype=np.int64, count=n)
-    alive = degree > 0
-    pending = [i for i in range(n) if alive[i] and degree[i] < 2]
-    while pending:
-        atom = pending.pop()
-        if not alive[atom]:
-            continue
-        alive[atom] = False
-        for other in adjacency[atom]:
-            if alive[other]:
-                degree[other] -= 1
-                if degree[other] < 2:
-                    pending.append(other)
-
-    # Every remaining component is a ring or a fused ring system; the smallest
-    # possible one is a three-membered cycle.
-    components = []
-    seen = np.zeros(n, dtype=np.bool_)
-    for root in range(n):
-        if not alive[root] or seen[root]:
-            continue
-        seen[root] = True
-        component = [root]
-        stack = [root]
-        while stack:
-            atom = stack.pop()
-            for other in adjacency[atom]:
-                if alive[other] and not seen[other]:
-                    seen[other] = True
-                    component.append(other)
-                    stack.append(other)
-        components.append(tuple(sorted(component)))
 
-    if not components:
+def largest_ring_system(molecule: Molecule) -> np.ndarray:
+    """Return the largest fused ring system in the heavy-atom bond graph.
+
+    Fused systems (naphthalene, steroids, porphyrins) stay whole, because
+    the bonds they share are on cycles and so are never bridges -- which is
+    what a rigid-core RMSD subset wants. Systems merely joined by a chain
+    or a single bond (biphenyl, a macrocycle with a pendant aryl) are
+    separate, and only the larger one comes back. See :func:`ring_systems`.
+    """
+    if molecule.n_atoms < 3:
+        return np.empty(0, dtype=np.int64)
+    systems = ring_systems(heavy_adjacency(molecule))
+    if not systems:
         return np.empty(0, dtype=np.int64)
     # Stable tie-break: the earliest system in atom/file order wins.
-    chosen = min(components, key=lambda system: (-len(system), system))
+    chosen = min(systems, key=lambda system: (-len(system), system))
     return np.asarray(chosen, dtype=np.int64)
 
 
@@ -119,7 +169,7 @@ def peptide_motifs(molecule: Molecule) -> List[List[Tuple[int, int, int, Optiona
 
 def _topology_backbone(molecule: Molecule, include_beta_carbon: bool) -> np.ndarray:
     """Infer N-Cα-C(-O) motifs from elements and connectivity in O(N+E)."""
-    runs, neighbors, symbols = _peptide_motifs(molecule)
+    runs, neighbors, symbols, _carbonyls = _peptide_motifs(molecule)
     selected = set()
     for run in runs:
         for nitrogen, alpha, carbonyl, _oxygen in run:
@@ -144,7 +194,7 @@ def _peptide_motifs(molecule: Molecule):
     """(runs, neighbors, symbols) -- the shared half of both callers' work."""
     n = molecule.n_atoms
     if n < 4:
-        return [], [], molecule.symbols
+        return [], [], molecule.symbols, {}
     bonds = molecule.bonds or perceive_bonds(molecule)
     neighbors = [[] for _ in range(n)]
     bond_orders = {}
@@ -169,12 +219,19 @@ def _peptide_motifs(molecule: Molecule):
         return out
 
     motifs = []
+    # Every carbonyl carbon in the molecule, collected on the way past at no
+    # extra cost. Callers that need to recognize an amide (cistrans, for a
+    # ring's side-chain lactam) must use THIS rule rather than rolling their
+    # own: "terminal oxygen" alone also matches a hydroxyl, which is the
+    # hydrogen-free threonine trap carbonyl_oxygens exists to avoid.
+    carbonyls = {}
     for carbonyl, symbol in enumerate(symbols):
         if symbol != "C":
             continue
         oxygens = carbonyl_oxygens(carbonyl)
         if not oxygens:
             continue
+        carbonyls[carbonyl] = oxygens
         # The Cα is the carbonyl carbon's carbon neighbor that itself touches
         # nitrogen. This tiny condition rejects common side-chain amides:
         # their adjacent CB/CD carbon is not N-bound.
@@ -237,7 +294,7 @@ def _peptide_motifs(molecule: Molecule):
             at = successor.get(at)
         if run:
             runs.append(run)
-    return runs, neighbors, symbols
+    return runs, neighbors, symbols, carbonyls
 
 
 def peptide_backbone(molecule: Molecule, include_beta_carbon: bool = False) -> np.ndarray:
@@ -264,4 +321,5 @@ def peptide_backbone(molecule: Molecule, include_beta_carbon: bool = False) -> n
 
 
 __all__ = ["heavy_atoms", "largest_ring_system", "peptide_backbone",
+           "ring_systems", "bridge_edges", "heavy_adjacency",
            "peptide_motifs"]

{vimol-0.1.4 → vimol-0.1.6}/src/vimol/viewer.py

@@ -4005,6 +4005,9 @@ class Viewer:
         change as files are added or removed."""
         base = ("cis/trans per peptide bond · ω=Cα-C-N-Cα, "
                 "|ω|<90° = cis · chains joined with /")
+        ring = cistrans.macrocycle_size(self.structures.active.molecule)
+        if ring:
+            base += f" · ring only (macrocycle, {ring} ring atoms)"
         energies = [cistrans.parse_energy(e.molecule.name)
                    for e in self.structures.entries]
         missing = sum(1 for e in energies if e is None)
@@ -4041,6 +4044,11 @@ class Viewer:
                          for entry in sset.entries]
         column.revisions = [entry.revision for entry in sset.entries]
         classified = sum(1 for value in column.values if value is not None)
+        # A macrocycle is classified on its ring alone, so its string is
+        # SHORTER than the residue count would suggest. Say so, or the
+        # missing characters read as a bug rather than as the point.
+        ring = cistrans.macrocycle_size(sset.active.molecule)
+        ring_note = f" · ring only (macrocycle, {ring} ring atoms)" if ring else ""
         if classified == 0:
             # "classified 0 frames" would be technically true and completely
             # misleading -- nothing was found, say that.
@@ -4049,10 +4057,10 @@ class Viewer:
             # A lone structure never gets a measurement table at all
             # (_measure_layout returns [] below two entries), so the message
             # is the only place its classification can appear.
-            self._msg = f"{column.header}: {column.values[0]}"
+            self._msg = f"{column.header}: {column.values[0]}{ring_note}"
         else:
             self._msg = (f"{column.header} classified {classified} of "
-                         f"{len(column.values)} frames")
+                         f"{len(column.values)} frames{ring_note}")
         self._measure_layout_cache = None
         self._refresh_measure_w()
         return True

{vimol-0.1.4 → vimol-0.1.6/src/vimol.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vimol
-Version: 0.1.4
+Version: 0.1.6
 Summary: A terminal molecular viewer and editor using the Kitty graphics protocol
 Author: vimol contributors
 License-Expression: MIT

{vimol-0.1.4 → vimol-0.1.6}/tests/test_align.py

@@ -1092,6 +1092,49 @@ def test_largest_ring_system_strips_substituents_down_to_the_cycle():
                           [0, 1, 2, 3, 4, 5])
 
 
+def test_rings_joined_by_a_chain_are_separate_systems():
+    """The bug a 2-core peel could not see: an atom survives the 2-core when
+    it merely has two neighbours, not when it lies on a cycle, so a plain
+    chain BETWEEN two rings was kept and the "ring system" came back as both
+    rings plus the linker. Here that answered all 15 atoms; only the larger
+    ring is one."""
+    molecule = _mol(["C"] * 15, np.zeros((15, 3)))
+    molecule.bonds = [
+        # six-ring 0-5, chain 5-6-7-8, five-ring 8-12, plus a tail
+        (0, 1, 1), (1, 2, 1), (2, 3, 1), (3, 4, 1), (4, 5, 1), (5, 0, 1),
+        (5, 6, 1), (6, 7, 1), (7, 8, 1),
+        (8, 9, 1), (9, 10, 1), (10, 11, 1), (11, 12, 1), (12, 8, 1),
+        (12, 13, 1), (13, 14, 1),
+    ]
+    systems = vimol.select.ring_systems(vimol.select.heavy_adjacency(molecule))
+    assert sorted(len(s) for s in systems) == [5, 6]
+    assert np.array_equal(vimol.select.largest_ring_system(molecule),
+                          [0, 1, 2, 3, 4, 5])
+
+
+def test_biphenyl_rings_do_not_fuse_across_their_single_bond():
+    """A bond between two rings is a bridge, so the rings stay separate --
+    unlike naphthalene's shared edge, which lies on a cycle."""
+    molecule = _mol(["C"] * 12, np.zeros((12, 3)))
+    molecule.bonds = [(i, (i + 1) % 6, 1) for i in range(6)]
+    molecule.bonds += [(6 + i, 6 + (i + 1) % 6, 1) for i in range(6)]
+    molecule.bonds.append((0, 6, 1))
+    systems = vimol.select.ring_systems(vimol.select.heavy_adjacency(molecule))
+    assert sorted(len(s) for s in systems) == [6, 6]
+    assert np.array_equal(vimol.select.largest_ring_system(molecule),
+                          [0, 1, 2, 3, 4, 5])
+
+
+def test_bridge_detection_survives_a_deep_chain():
+    """Iterative on purpose: a recursive lowlink walk blows the interpreter
+    stack here, and the selection presets run on whole proteins."""
+    n = 5000
+    molecule = _mol(["C"] * n, np.zeros((n, 3)))
+    molecule.bonds = [(i, i + 1, 1) for i in range(n - 1)]
+    molecule.bonds.append((n - 1, 0, 1))      # one huge cycle
+    assert len(vimol.select.largest_ring_system(molecule)) == n
+
+
 def test_largest_ring_system_perceives_bonds_for_unnamed_xyz():
     angles = np.arange(6) * (np.pi / 3.0)
     positions = np.column_stack((1.4 * np.cos(angles),