fix: _prefer_spiro_backbone_components() now maps shared counts for every RingSystem.paths entry, not just paths[0].

Removed the redundant ring_system_by_path lookup.
Added _spiro_backbone_rank_key() so the local backbone ranking tuple is defined once.

Author: r-fedorov

src/bluenamer/parent_selection.py

@@ -376,11 +376,11 @@ def _prefer_spiro_backbone_components(
     if len(ring_systems) < 2:
         return candidates
 
-    ring_system_by_path = {tuple(system.paths[0]): system for system in ring_systems}
     shared_counts: dict[tuple[int, ...], int] = {}
     for system in ring_systems:
-        path_key = tuple(system.paths[0])
-        shared_counts[path_key] = sum(1 for other in ring_systems if other is not system and system.atoms & other.atoms)
+        shared_count = sum(1 for other in ring_systems if other is not system and system.atoms & other.atoms)
+        for path in system.paths:
+            shared_counts[tuple(path)] = shared_count
 
     max_shared = max(shared_counts.values(), default=0)
     if max_shared == 0:
@@ -402,39 +402,43 @@ def _prefer_spiro_backbone_components(
         )
         == best_principal_key
     ]
-    eligible_ring_components = [
-        candidate
-        for candidate in eligible
-        if candidate.is_ring
-        and shared_counts.get(tuple(candidate.path), 0) > 0
-        and tuple(candidate.path) in ring_system_by_path
-    ]
+    eligible_ring_components = []
+    for candidate in eligible:
+        if not candidate.is_ring:
+            continue
+        path_key = tuple(candidate.path)
+        if shared_counts.get(path_key, 0) <= 0:
+            continue
+        eligible_ring_components.append(candidate)
     if len(eligible_ring_components) < 2:
         return candidates
 
-    best_backbone_key = min(
-        (
-            -shared_counts[tuple(candidate.path)],
-            -candidate.seniority_profile.ring_count,
-            -candidate.seniority_profile.parent_atom_count,
-            candidate.seniority_profile.path_tiebreak,
-        )
+    backbone_keys = {
+        tuple(candidate.path): _spiro_backbone_rank_key(candidate, shared_counts)
         for candidate in eligible_ring_components
-    )
-    backbone = [
+    }
+    best_backbone_key = min(backbone_keys.values())
+    backbone_paths = {path for path, key in backbone_keys.items() if key == best_backbone_key}
+    if not backbone_paths:
+        return candidates
+    competing_paths = set(backbone_keys)
+    return [
         candidate
-        for candidate in eligible_ring_components
-        if (
-            -shared_counts[tuple(candidate.path)],
-            -candidate.seniority_profile.ring_count,
-            -candidate.seniority_profile.parent_atom_count,
-            candidate.seniority_profile.path_tiebreak,
-        )
-        == best_backbone_key
+        for candidate in candidates
+        if tuple(candidate.path) not in competing_paths or tuple(candidate.path) in backbone_paths
     ]
-    if not backbone:
-        return candidates
-    return backbone
+
+
+def _spiro_backbone_rank_key(candidate: ParentCandidate, shared_counts: dict[tuple[int, ...], int]) -> tuple:
+    """Return the local rank key for competing spiro-connected ring components."""
+
+    path_key = tuple(candidate.path)
+    return (
+        -shared_counts[path_key],
+        -candidate.seniority_profile.ring_count,
+        -candidate.seniority_profile.parent_atom_count,
+        candidate.seniority_profile.path_tiebreak,
+    )
 
 
 def _ring_count_for_system(ring_system: RingSystem) -> int:

src/bluenamer/tests/test_analysis.py

@@ -33,7 +33,7 @@
     format_spiro_core,
     split_spiro_substituents,
 )
-from bluenamer.chains import find_all_carbon_paths, find_ring_systems
+from bluenamer.chains import RingSystem, find_all_carbon_paths, find_ring_systems
 from bluenamer.charge_pair_roles import charge_pair_roles, unsupported_charge_pair_roles
 from bluenamer.formatting import ensure_stereo_descriptor_boundary, format_counted_prefixes
 from bluenamer.functional_groups import (
@@ -112,6 +112,7 @@
     ParentCandidate,
     ParentSelection,
     ParentSeniorityProfile,
+    _prefer_spiro_backbone_components,
     select_principal_parent,
 )
 from bluenamer.perception import PerceivedGroup, perceive_groups
@@ -3276,6 +3277,81 @@ def test_parent_selection_criteria_are_data_ordered():
     assert profile.score_tuple() == (-1, -1, (7,), 0, (), (-2, 0, (0, 0, 0, 0, 0, 0)), 0, 0, (0, 1))
 
 
+def test_senior_element_vector_orders_ring_and_chain_parent_profiles():
+    def profile(*, ring_parent: bool, senior_element_vector: tuple[int, ...]) -> ParentSeniorityProfile:
+        return ParentSeniorityProfile(
+            principal_group_count=0,
+            contains_principal_group=False,
+            senior_element_vector=senior_element_vector,
+            polycycle_parent=False,
+            bicycle_parent=False,
+            spiro_parent=False,
+            ring_parent=ring_parent,
+            ring_count=1 if ring_parent else 0,
+            parent_atom_count=4,
+            heteroatom_count=1,
+            senior_heteroatom_vector=(),
+            senior_heteroatom_count_vector=(0, 0, 0, 0, 0, 0),
+            multiple_bond_count=0,
+            double_bond_count=0,
+            path_tiebreak=(0, 1, 2, 3),
+        )
+
+    n_ring = profile(ring_parent=True, senior_element_vector=(1, 7))
+    o_ring = profile(ring_parent=True, senior_element_vector=(5, 7))
+    n_chain = profile(ring_parent=False, senior_element_vector=(1, 7))
+    o_chain = profile(ring_parent=False, senior_element_vector=(5, 7))
+
+    assert n_ring.score_tuple() < o_ring.score_tuple()
+    assert n_chain.score_tuple() < o_chain.score_tuple()
+
+
+def test_spiro_backbone_filter_keeps_noncompeting_candidates_and_matches_all_ring_paths():
+    backbone = ParentCandidate.build(
+        [3, 2, 1, 0],
+        is_ring=True,
+        is_bicycle=False,
+        is_spiro=True,
+        is_polycycle=False,
+        xyz=(0, 0, 0),
+        principal_groups_count=0,
+        mol=None,
+        ring_count=2,
+    )
+    side_ring = ParentCandidate.build(
+        [3, 4, 5],
+        is_ring=True,
+        is_bicycle=False,
+        is_spiro=False,
+        is_polycycle=False,
+        xyz=(0, 0, 0),
+        principal_groups_count=0,
+        mol=None,
+        ring_count=1,
+    )
+    unrelated_chain = ParentCandidate.build(
+        [10, 11, 12],
+        is_ring=False,
+        is_bicycle=False,
+        is_spiro=False,
+        is_polycycle=False,
+        xyz=(0, 0, 0),
+        principal_groups_count=0,
+        mol=None,
+    )
+    ring_systems = [
+        RingSystem(atoms={0, 1, 2, 3}, is_spiro=True, paths=[[0, 1, 2, 3], [3, 2, 1, 0]]),
+        RingSystem(atoms={3, 4, 5}, paths=[[3, 4, 5]]),
+    ]
+
+    filtered = _prefer_spiro_backbone_components([side_ring, unrelated_chain, backbone], ring_systems)
+
+    assert backbone in filtered
+    assert unrelated_chain in filtered
+    assert side_ring not in filtered
+    assert [candidate.path for candidate in filtered] == [[10, 11, 12], [3, 2, 1, 0]]
+
+
 def test_parent_seniority_profile_exposes_brief_guide_extension_fields():
     mol = read_smiles("NCCO")
     candidate = ParentCandidate.build(

tests/integration/test_corpus_golden.py

@@ -58,6 +58,5 @@ def test_corpus_names_match_golden(goldens, capsys):
                 print(f"    expected: {want}")
                 print(f"    got:      {got}")
         pytest.fail(
-            f"{len(mismatches)} corpus entries name differently on rdkit "
-            f"{rdkit.__version__} than the committed goldens"
+            f"{len(mismatches)} corpus entries name differently on rdkit {rdkit.__version__} than the committed goldens"
         )

tests/integration/test_diverse_corpus.py

@@ -82,7 +82,7 @@ def test_corpus_naming_pass_rate(corpus):
         # Surface the offenders so the failure is actionable.
         sample = "\n".join(f"  - {s} [{c}]" for s, c in unnamed[:10])
         pytest.fail(
-            f"Naming pass rate {rate:.2%} below floor {NAME_PASS_RATE_FLOOR:.2%}.\n" f"First unnamed entries:\n{sample}"
+            f"Naming pass rate {rate:.2%} below floor {NAME_PASS_RATE_FLOOR:.2%}.\nFirst unnamed entries:\n{sample}"
         )