Prime a named spiro component's replacement prefixes

In spiro[indoline-3,4'-cyclopentane] the side ring is the primed
component, so its skeletal-replacement locants are primed with it.  Both
priming helpers were guarded on the literal `spiro[cyclopropane-`, so
every other side ring kept unprimed locants and the heteroatoms read
back on the wrong ring: a spiro indoline carrying two ring nitrogens
came out as `1,3-diaza` rather than `1',3'-diaza`.  The regex also only
matched a bare `oxa`/`aza`/`thia`, so multiplied forms were missed
entirely.

The guard cannot simply be dropped.  `6,8-diazaspiro[4.4]nonane` numbers
the whole spiro system once and its prefixes must stay unprimed; only a
descriptor that names its components primes the second one, and the
prime inside the bracket tells the two apart.

Nor can that test be made against the whole name.  A name can hold both
forms at once, and checking globally primed the `6-aza` of an
`azaspiro[3.3]heptane` sitting beside a `spiro[indoline-3,1'-
cyclohexane]` -- caught as the one regression in the first measurement.
The inline test is now made against the bracket each prefix actually
precedes.

30 corpus names fixed, 0 broken.  Mismatch counts are unchanged at 7 and
0, because every one of these was already abstaining rather than being
refuted -- the audit could not model the spiro side ring to begin with.
1299 tests pass.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: AdrianM0

src/openclatura/assembly_spiro.py

@@ -155,18 +155,59 @@ def _reprime_side_prefixes(prefixes: tuple[str, ...], prime: str) -> list[str]:
 
 
 def _prime_replacement_prefixes_for_primed_component(core_name: str, prefixes: list[str]) -> list[str]:
-    if "spiro[cyclopropane-" not in core_name:
+    """Prime replacement prefixes that describe the side ring.
+
+    The side component is always the primed one, and these prefixes are always
+    the side ring's, so the priming does not depend on which ring it happens to
+    be.  Guarding on ``spiro[cyclopropane-`` meant every other side ring kept
+    unprimed locants: spiro[indoline-3,4'-cyclopentane] carrying two ring
+    nitrogens came out as ``1,3-diaza`` and read back with the nitrogens on the
+    indoline instead.
+    """
+
+    if not _spiro_names_its_components(core_name):
         return prefixes
     return [
-        re.sub(r"^([0-9,]+)-(oxa|aza|thia)$", lambda match: f"{match.group(1)}'-{match.group(2)}", prefix)
+        re.sub(
+            r"^([0-9,]+)-((?:di|tri|tetra|penta)?(?:oxa|aza|thia|selena|tellura|phospha|sila|bora|germa|stanna))$",
+            lambda match: f"{','.join(f'{locant}' + chr(39) for locant in match.group(1).split(','))}-{match.group(2)}",
+            prefix,
+        )
         for prefix in prefixes
     ]
 
 
 def _prime_inline_replacement_prefixes_for_primed_component(core_name: str) -> str:
-    if "spiro[cyclopropane-" not in core_name:
-        return core_name
-    return re.sub(r"(^|-)([0-9,]+)-(oxa|aza|thia)spiro\[", r"\1\2'-\3spiro[", core_name)
+    """Prime a replacement prefix that ended up in front of the spiro core."""
+
+    # A name can hold both spiro forms at once, so the test has to be made
+    # against the bracket this prefix actually sits in front of rather than
+    # against the whole name: 6-azaspiro[3.3]heptane keeps unprimed locants
+    # even when a spiro[indoline-3,1'-cyclohexane] appears elsewhere in it.
+    def prime(match: re.Match) -> str:
+        if "'" not in match.group(4):
+            return match.group(0)
+        locants = ",".join(f"{locant}'" for locant in match.group(2).split(","))
+        return f"{match.group(1)}{locants}-{match.group(3)}spiro[{match.group(4)}"
+
+    return re.sub(
+        r"(^|-)([0-9,]+)-((?:di|tri|tetra|penta)?(?:oxa|aza|thia|selena|tellura|phospha|sila|bora|germa|stanna))"
+        r"spiro\[([^\]]*)",
+        prime,
+        core_name,
+    )
+
+
+def _spiro_names_its_components(core_name: str) -> bool:
+    """Whether the spiro descriptor names its rings rather than counting them.
+
+    ``spiro[indoline-3,4'-cyclopentane]`` numbers each component separately and
+    primes the second, so a side-ring replacement prefix is primed with it.
+    ``6,8-diazaspiro[4.4]nonane`` numbers the whole system once and its
+    prefixes must stay unprimed.  The prime inside the bracket tells them
+    apart."""
+
+    return bool(re.search(r"spiro\[[^\]]*'", core_name))
 
 
 def _prime_side_suffixes(suffixes: tuple[tuple[str, str], ...], prime: str) -> list[tuple[str, str]]:

src/openclatura/tests/test_analysis.py

@@ -1899,6 +1899,25 @@ def test_two_nitrogen_chain_uses_its_retained_name():
     assert name_smiles("CN=NC") == "1,2-dimethyldiazene"
 
 
+def test_a_named_spiro_component_primes_its_replacement_prefixes():
+    # The side ring is the primed component, so its heteroatom locants are
+    # primed too.  Unprimed, they read back on the other ring entirely.
+    assert name_smiles("N1CC2(C3=CC=CC=C13)NCNC2") == "1',3'-diazaspiro[indoline-3,4'-cyclopentane]"
+    assert name_smiles("O=C1NC2(CN1)c1ccccc1NC2=O") == (
+        "1',3'-diazaspiro[indoline-3,4'-cyclopentane]-2'-one-2-one"
+    )
+
+
+def test_a_counted_spiro_keeps_its_replacement_prefixes_unprimed():
+    # spiro[4.4] numbers the whole system once, so nothing is primed -- and a
+    # name holding both spiro forms must prime only the component-named one.
+    assert name_smiles("C1CC2(CC1)NCNC2") == "6,8-diazaspiro[4.4]nonane"
+    assert name_smiles("C1CC2(CC1)OCCO2") == "6,9-dioxaspiro[4.4]nonane"
+    both = name_smiles("Cc1noc(C2CC3(C2)CN(C2CCC4(CC2)C(=O)Nc2ccccc24)C3)n1")
+    assert "6-azaspiro[3.3]heptan" in both
+    assert "spiro[indoline-3,1'-cyclohexane]" in both
+
+
 def test_homonuclear_chain_names_are_reconstructed_by_the_audit():
     """A shortcut returns before the usual audit point, so it must hand over a
     plan or its name can never be checked.  Corrupting the plan must refute."""