Keep every substituent on a spiro side ring, and prime them all

`extract_spiro_side_prefixes` matched one leading locant group and
treated everything after it as a single substituent name, so only the
first side-ring prefix was primed.  Worse, its stereo-descriptor strip
recognised R/S but not E/Z, so `(5E)-1-butyl-5-butylidene-1,3-diaza…`
matched nothing at all and the function returned no prefixes: an entire
butyl and butylidene disappeared from the name rather than merely losing
their primes.

Prime every top-level locant instead.  Two things must not be primed.
Locants inside a nested substituent number that substituent's own
skeleton -- `(2,6-difluoro-3-methylphenyl)` -- so priming is tracked by
parenthesis depth.  Digits within a name, as in `but-2-en-1-yl`, are
recognised by the fragment that follows them.

The side ring's stereo descriptor stays dropped.  Re-emitting it inline
put it in the middle of the assembled name, which reads back as a
different molecule; that attempt broke 41 names and is reverted.  It
belongs at the front of the whole name, which this string-level renderer
cannot reach, so a missing descriptor is preferred to a misplaced one --
the one molecule this leaves incomplete is now wrong only in its E/Z,
where before it was missing two whole substituents.

A stereo descriptor opening the right-hand side now takes a hyphen, so
`1-methyl(5'E)-…` no longer runs together.

58 corpus names fixed, 0 broken.  pubchem mismatches 7 -> 5; zinc22
stays at 0.  1301 tests pass.

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

Author: AdrianM0

src/openclatura/assembly_spiro.py

@@ -287,13 +287,52 @@ def extract_spiro_side_prefixes(side_name: str) -> tuple[list[str], str, tuple[t
         prefix_text = normalized[: -len(parent)].rstrip("-")
     elif normalized != parent and normalized.endswith(parent):
         prefix_text = normalized[: -len(parent)].rstrip("-")
-    prefix_text = re.sub(r"^\((?:\d+[A-Za-z']*[RS](?:,\d+[A-Za-z']*[RS])*)\)-?", "", prefix_text)
-    match = re.match(r"^([0-9,]+)-(.+)$", prefix_text)
-    if not match:
+    # A stereo descriptor here can be E/Z as readily as R/S.  Matching only the
+    # latter left `(5E)-` in front of the locants, the locant pattern below then
+    # failed, and every prefix was dropped -- an entire butyl and butylidene
+    # vanished from the name rather than merely losing their primes.
+    # The side ring's stereo descriptor is dropped here rather than carried.
+    # Re-emitting it inline placed it in the middle of the assembled name --
+    # `...-7-(pyrimidin-4-yl)-(3'S)-1'-methylspiro[...` -- which reads back as a
+    # different molecule.  It belongs at the front of the whole name, which this
+    # string-level renderer cannot reach, so a missing descriptor is preferred
+    # to a misplaced one.
+    prefix_text = re.sub(r"^\((?:\d+[A-Za-z']*(?:[RS]|[EZ])(?:,\d+[A-Za-z']*(?:[RS]|[EZ]))*)\)-?", "", prefix_text)
+    if not prefix_text:
         return [], _spiro_side_parent_name(parent), tuple(side_suffixes)
-    locants, substituent = match.groups()
-    primed_locants = ",".join(f"{loc}'" for loc in locants.split(","))
-    return [f"{primed_locants}-{substituent}"], _spiro_side_parent_name(parent), tuple(side_suffixes)
+    return [_prime_side_prefix_locants(prefix_text)], _spiro_side_parent_name(parent), tuple(side_suffixes)
+
+
+# Fragments that follow a digit *inside* a substituent name -- `but-2-en-1-yl`
+# -- rather than after a locant that introduces one.  Everything else beginning
+# a hyphen-separated segment after a number is a fresh prefix at that locant.
+_WITHIN_NAME_AFTER_LOCANT = ("en", "yn", "yl", "ylidene", "ylidyne", "ol", "one", "al", "amine", "oic", "carbo")
+
+
+def _prime_side_prefix_locants(prefix_text: str) -> str:
+    """Prime every locant that introduces a side-ring prefix, and only those.
+
+    The side ring is the primed component, so each of its substituent locants
+    carries a prime.  Priming only the first left the rest reading as the other
+    ring's positions.
+    """
+
+    segments = prefix_text.split("-")
+    depth = 0
+    for index, segment in enumerate(segments):
+        # Only locants at the top level position a prefix on the side ring.
+        # Inside a nested substituent -- `(2,6-difluoro-3-methylphenyl)` -- they
+        # number that substituent's own skeleton and must be left alone.
+        opening, closing = segment.count("("), segment.count(")")
+        was_nested = depth > 0
+        depth += opening - closing
+        if was_nested or depth > 0 or not re.fullmatch(r"[0-9,]+", segment):
+            continue
+        following = segments[index + 1] if index + 1 < len(segments) else ""
+        if following.startswith(_WITHIN_NAME_AFTER_LOCANT):
+            continue
+        segments[index] = ",".join(f"{locant}'" for locant in segment.split(","))
+    return "-".join(segments)
 
 
 def _extract_side_suffixes(side_name: str) -> tuple[str, list[tuple[str, str]]]:

src/openclatura/assembly_utils.py

@@ -14,6 +14,9 @@ def parse_locant(locant):
     return (2, 0.0, text)
 
 
+_STEREO_DESCRIPTOR_START = re.compile(r"\(\d+[A-Za-z']*(?:[RS]|[EZ])(?:,\d+[A-Za-z']*(?:[RS]|[EZ]))*\)")
+
+
 def needs_hyphen(left: str, right: str) -> bool:
     if not left or not right:
         return False
@@ -23,6 +26,9 @@ def needs_hyphen(left: str, right: str) -> bool:
         or right.startswith("N-")
         or right.startswith("N',")
         or right.startswith("N'-")
+        # A stereo descriptor opening the right-hand side is a separate
+        # italicised element and takes a hyphen: `1-methyl-(5'E)-1'-butyl…`.
+        or _STEREO_DESCRIPTOR_START.match(right)
     ):
         return True
     if left[-1].isdigit():

src/openclatura/tests/test_analysis.py

@@ -1908,6 +1908,31 @@ def test_a_named_spiro_component_primes_its_replacement_prefixes():
     )
 
 
+def test_every_side_ring_substituent_survives_and_is_primed():
+    # The locant pattern matched only the first prefix, so the rest were left
+    # unprimed -- and a leading E/Z descriptor made it match nothing at all,
+    # dropping an entire butyl and butylidene from the name.
+    assert name_smiles("CCC/C=C1/N(CCCC)C(=O)NC12C(=O)N(C)c1ccccc12") == (
+        "1-methyl-1'-butyl-5'-butylidene-1',3'-diazaspiro[indoline-3,4'-cyclopentane]-2'-one-2-one"
+    )
+    assert name_smiles("C=C1N(C)C(=O)NC12C(=O)N(C)c1ccccc12") == (
+        "1-methyl-1'-methyl-5'-methylidene-1',3'-diazaspiro[indoline-3,4'-cyclopentane]-2'-one-2-one"
+    )
+
+
+def test_a_nested_substituents_own_locants_are_not_primed():
+    """Only top-level locants position a prefix on the side ring; the ones
+    inside a nested substituent number that substituent's own skeleton."""
+
+    from openclatura.assembly_spiro import extract_spiro_side_prefixes
+
+    prefixes, parent, _suffixes = extract_spiro_side_prefixes(
+        "1-((2,6-difluoro-3-methylphenyl)methyl)piperidine"
+    )
+    assert prefixes == ["1'-((2,6-difluoro-3-methylphenyl)methyl)"]
+    assert parent == "piperidine"
+
+
 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.