Revert "Fix/issue 52 large backbones"

Author: r-fedorov

README.md

@@ -7,9 +7,6 @@
 Built on top of RDKit, the package walks the molecular graph, detects functional groups and ring systems, selects the principal parent, assigns locants, and constructs the corresponding substitutive IUPAC name. Every step is recorded in an inspectable
 decision trace so the *why* of a name is recoverable, not just the *what*.
 
-Systematic backbone stems are supported for chains and rings containing from 1
-through 1000 skeletal atoms, following IUPAC Blue Book P-14.2.1.
-
 > **Status:** beta. The naming engine handles a broad slice of organic
 > structures (alkanes/alkenes/alkynes, common functional groups, simple
 > heterocycles, fused/spiro/bridged systems, retained names from the Blue
@@ -286,4 +283,4 @@ If you are using OPSIN for verification, please cite the original OPSIN publicat
   doi     = {10.1021/ci100384d},
   url     = {https://doi.org/10.1021/ci100384d}
 }
-```
+```

src/openclatura/chains.py

@@ -462,24 +462,19 @@ def find_all_carbon_paths(mol: Molecule, exclude_atoms: set[int] = None) -> list
 
     all_paths = []
 
-    def collect_paths(start: int) -> None:
-        # Long unbranched backbones can exceed Python's recursion limit. Keep
-        # the existing depth-first order without using the interpreter stack.
-        stack = [(start, [start], {start})]
-        while stack:
-            current, path, visited = stack.pop()
-            neighbors = [n for n in mol.get_neighbors(current) if n in valid_nodes and n not in visited]
-            if not neighbors:
-                all_paths.append(path)
-                continue
-            for neighbor in reversed(neighbors):
-                stack.append((neighbor, path + [neighbor], visited | {neighbor}))
+    def dfs(current: int, path: list[int], visited: set[int]):
+        neighbors = [n for n in mol.get_neighbors(current) if n in valid_nodes and n not in visited]
+        if not neighbors:
+            all_paths.append(path)
+            return
+        for n in neighbors:
+            dfs(n, path + [n], visited | {n})
 
     endpoints = [n for n in valid_nodes if sum(1 for x in mol.get_neighbors(n) if x in valid_nodes) <= 1]
     start_nodes = endpoints if endpoints else valid_nodes
 
     for start in start_nodes:
-        collect_paths(start)
+        dfs(start, [start], {start})
 
     unique_paths = []
     seen = set()

src/openclatura/formatting.py

@@ -98,8 +98,7 @@ def substituted_alkoxy_prefix(branch: str) -> str | None:
 
     if "hydroxy" not in branch:
         return None
-    for length in range(stems.MAX_STEM_LENGTH, stems.MIN_STEM_LENGTH - 1, -1):
-        stem = stems.get(length)
+    for stem in stems.STEMS.values():
         terminal = f"{stem.stem}yl"
         replacement = f"{stem.stem}oxy"
         if branch.endswith(terminal):

src/openclatura/ring_renderer.py

@@ -36,7 +36,7 @@ def von_baeyer_cycle_count(descriptor: str | None) -> int | None:
     for count, multiplier in multipliers.MULTIPLIERS.items():
         if prefix == multiplier.basic:
             return count
-    for count in range(stems.MIN_STEM_LENGTH, stems.MAX_STEM_LENGTH + 1):
+    for count, stem in stems.STEMS.items():
         if prefix == _basic_cycle_prefix(count):
             return count
     return None

src/openclatura/rules/stems.py

@@ -9,7 +9,6 @@
 """
 
 from dataclasses import dataclass
-from functools import lru_cache
 
 
 @dataclass(frozen=True)
@@ -21,8 +20,7 @@ class Stem:
 
 # Stems 1-4 are retained (non-systematic) names.
 # Stems 5+ are derived from Greek/Latin numerical roots.
-# Retained and established spellings through 30. Larger stems are generated
-# from the basic numerical terms in Blue Book P-14.2.1.
+# Coverage up to 30; extend as needed (IUPAC defines stems well beyond this).
 STEMS: dict[int, Stem] = {
     1: Stem(1, "meth", retained=True),
     2: Stem(2, "eth", retained=True),
@@ -56,105 +54,12 @@ class Stem:
     30: Stem(30, "triacont", retained=False),
 }
 
-MIN_STEM_LENGTH = 1
-MAX_STEM_LENGTH = 1000
-
-_UNITS = {
-    1: "hen",
-    2: "do",
-    3: "tri",
-    4: "tetra",
-    5: "penta",
-    6: "hexa",
-    7: "hepta",
-    8: "octa",
-    9: "nona",
-}
-
-_TENS = {
-    1: "deca",
-    2: "icosa",
-    3: "triaconta",
-    4: "tetraconta",
-    5: "pentaconta",
-    6: "hexaconta",
-    7: "heptaconta",
-    8: "octaconta",
-    9: "nonaconta",
-}
-
-_HUNDREDS = {
-    1: "hecta",
-    2: "dicta",
-    3: "tricta",
-    4: "tetracta",
-    5: "pentacta",
-    6: "hexacta",
-    7: "heptacta",
-    8: "octacta",
-    9: "nonacta",
-}
-
-
-def _validate_length(length: int) -> None:
-    if isinstance(length, bool) or not isinstance(length, int):
-        raise ValueError("Stem length must be an integer from 1 through 1000")
-    if not MIN_STEM_LENGTH <= length <= MAX_STEM_LENGTH:
-        raise ValueError("Stem length must be from 1 through 1000")
-
-
-def _under_one_hundred(value: int) -> str:
-    """Return the basic numerical term for a value from 1 through 99."""
-
-    if value == 11:
-        return "undeca"
-
-    units = value % 10
-    tens = value // 10
-    unit_term = _UNITS.get(units, "")
-    tens_term = _TENS.get(tens, "")
-
-    # The initial i of icosa is elided after a vowel (P-14.2.1.2), e.g.
-    # do + icosa -> docosa, but hen + icosa -> henicosa.
-    if unit_term and tens == 2 and unit_term[-1] in "aeiou":
-        tens_term = tens_term[1:]
-    return unit_term + tens_term
-
-
-def _numerical_term(length: int) -> str:
-    """Build the P-14.2.1 basic numerical term for ``length``."""
-
-    _validate_length(length)
-    if length == 1000:
-        return "kilia"
-
-    hundreds, remainder = divmod(length, 100)
-    parts = []
-    if remainder:
-        parts.append(_under_one_hundred(remainder))
-    if hundreds:
-        parts.append(_HUNDREDS[hundreds])
-    return "".join(parts)
-
 
 def get(length: int) -> Stem:
-    """Return the chain stem for a supported skeletal-atom count."""
-
-    _validate_length(length)
-    return _get_cached(length)
-
-
-@lru_cache(maxsize=MAX_STEM_LENGTH)
-def _get_cached(length: int) -> Stem:
-    """Return a validated stem while caching generated values."""
-
-    if length in STEMS:
-        return STEMS[length]
-    numerical_term = _numerical_term(length)
-    return Stem(length, numerical_term.removesuffix("a"), retained=False)
+    """Look up a stem by chain length. Raises KeyError if out of range."""
+    return STEMS[length]
 
 
 def stem_for(length: int) -> str:
-    """Return just the stem string for a supported chain length."""
-
-    return get(length).stem
+    """Return just the stem string for a given chain length."""
+    return STEMS[length].stem