"""A SMILES parser that never calls rdkit. The second opinion, kept genuinely second. WHAT THIS IS FOR. Gate 3 re-derives element_counts, formula, heavy_atom_count and bond_count from the row's own SMILES with code that shares no line, no table and no author's assumption with rdkit, and drops any row where the two disagree. That is only worth anything if this file was written without looking at rdkit's answers, so it was: its entire acceptance test is data/seed/molperceive/hand_formulas.json, thirty structures walked atom by atom on paper and frozen with a sha256 before this module existed. WHAT IT IS NOT FOR. It is not a chemistry toolkit. It handles the SMILES subset this corpus generates and REFUSES on anything else rather than guessing, because a parser that quietly guesses is a parser whose agreement rate means nothing. Isotopes, wildcards, unusual valences and elements outside the supported set raise ParseRefused, the row is dropped, and the drop is counted and published. That narrows the distribution slightly and the card says so. THE VALENCE MODEL, stated so a reviewer can disagree with it specifically: 1. Bracket atoms take exactly the hydrogen written inside the bracket. [nH] is one, [N+] is zero even with four bonds, [Si] is zero. This is the SMILES rule and it is why bracket atoms need no valence table at all. 2. Organic-subset atoms (B C N O P S F Cl Br I) get implicit hydrogen filling the LOWEST normal valence that is at least the sum of their bond orders. 3. A lowercase aromatic atom gets one extra unit of bond order, representing the single formal double bond it carries in any Kekule structure. So aromatic c with two ring neighbours is 2+1=3 against valence 4 and takes 1 H; with three neighbours it is 3+1=4 and takes 0. Bare aromatic n with two neighbours is 2+1=3, which fills nitrogen exactly, so 0 H: that is the pyridine nitrogen, and the pyrrole nitrogen must be written [nH]. 4. Aromatic o and s contribute a lone pair rather than a formal double bond, so rule 3 does not apply to them and they take 0 implicit hydrogen. Run it: python indep_parser.py --selftest # the 30 hand-computed structures only python indep_parser.py --vs-rdkit # the measurement, run once, published """ from __future__ import annotations import argparse import hashlib import json import re from collections import Counter from pathlib import Path try: # importable both as a package and as a script from .fields import formula_with_charge except ImportError: # pragma: no cover import sys sys.path.insert(0, str(Path(__file__).resolve().parent.parent)) from molperceive.fields import formula_with_charge ROOT = Path(__file__).resolve().parents[2] HAND_PATH = ROOT / "data" / "seed" / "molperceive" / "hand_formulas.json" HAND_SHA_PATH = ROOT / "data" / "seed" / "molperceive" / "hand_formulas.sha256" # The aromatic appendix, frozen separately and later. The original 30 are never edited. APPENDIX_PATH = ROOT / "data" / "seed" / "molperceive" / "hand_formulas_appendix_aromatic.json" APPENDIX_SHA_PATH = ROOT / "data" / "seed" / "molperceive" / "hand_formulas_appendix_aromatic.sha256" ORGANIC_SUBSET = ("Br", "Cl", "B", "C", "N", "O", "P", "S", "F", "I") # longest first AROMATIC_LOWER = ("b", "c", "n", "o", "p", "s") # Lowest-first normal valences. Multi-valued entries are tried in order. VALENCES: dict[str, tuple[int, ...]] = { "B": (3,), "C": (4,), "N": (3,), "O": (2,), "P": (3, 5), "S": (2, 4, 6), "F": (1,), "Cl": (1,), "Br": (1,), "I": (1,), "Si": (4,), } BOND_ORDER = {"-": 1, "=": 2, "#": 3, "$": 4, ":": 1, "/": 1, "\\": 1} _BRACKET = re.compile( r"\[(?P\d+)?" r"(?P[A-Z][a-z]?|se|as|[bcnops]|\*)" r"(?P@{1,2}(?:TH|AL|SP|TB|OH)?\d*)?" r"(?PH\d*)?" r"(?P(?:\+{1,3}|-{1,3}|\+\d+|-\d+))?" r"(?::(?P\d+))?" r"\]") class ParseRefused(Exception): """The parser will not answer. Not the same as: the structure is invalid. Kept as a distinct exception so a refusal can never be silently recorded as a disagreement with rdkit, which would understate the agreement rate, nor as an agreement, which would overstate it. Refusals are counted on their own line. """ class SyntaxInvalid(Exception): """The string is not well-formed SMILES. Carries one of fields.SYNTAX_REASONS.""" def __init__(self, code: str, detail: str = "") -> None: super().__init__(f"{code}: {detail}" if detail else code) self.code = code self.detail = detail class Atom: __slots__ = ("idx", "symbol", "aromatic", "bracket", "h_explicit", "charge", "order_sum", "degree") def __init__(self, idx: int, symbol: str, aromatic: bool, bracket: bool, h_explicit: int, charge: int) -> None: self.idx = idx self.symbol = symbol self.aromatic = aromatic self.bracket = bracket self.h_explicit = h_explicit self.charge = charge self.order_sum = 0.0 # sum of bond orders to heavy neighbours self.degree = 0 # number of heavy neighbours def __repr__(self) -> str: # pragma: no cover return f"Atom({self.idx},{self.symbol},arom={self.aromatic},deg={self.degree})" class Molecule: def __init__(self) -> None: self.atoms: list[Atom] = [] self.bonds: list[tuple[int, int, float]] = [] self.adj: dict[int, list[int]] = {} # Bonds created by a ring-closure DIGIT rather than by adjacency in the string. # Recorded because the derivation is required to show ring closure pairing, and # only the parser knows which pair a digit joined: rdkit's RingInfo gives ring # membership, from which the closure pair cannot be recovered. self.ring_closures: list[tuple[int, int]] = [] def add_bond(self, a: int, b: int, order: float) -> None: if a == b: raise SyntaxInvalid("unclosed_ring_bond", f"atom {a} bonded to itself") for x, y, _ in self.bonds: if {x, y} == {a, b}: raise SyntaxInvalid("unclosed_ring_bond", f"duplicate bond {a}-{b}") self.bonds.append((a, b, order)) self.adj.setdefault(a, []).append(b) self.adj.setdefault(b, []).append(a) for i in (a, b): self.atoms[i].degree += 1 self.atoms[i].order_sum += order def _split_charge(tok: str | None) -> int: if not tok: return 0 sign = 1 if tok[0] == "+" else -1 rest = tok[1:] if rest.isdigit(): return sign * int(rest) return sign * (1 + len(rest)) # "++" is +2, "---" is -3 def parse(smiles: str) -> Molecule: """Build the heavy-atom graph. Raises SyntaxInvalid or ParseRefused.""" if not smiles or not smiles.strip(): raise SyntaxInvalid("unknown_element", "empty string") s = smiles.strip() mol = Molecule() branch: list[int] = [] ring: dict[int, tuple[int, float | None]] = {} prev: int | None = None pending: float | None = None # bond symbol seen but not yet consumed depth = 0 i = 0 n = len(s) while i < n: ch = s[i] if ch == "(": if prev is None: raise SyntaxInvalid("unbalanced_parenthesis", "branch opens before any atom") branch.append(prev) depth += 1 i += 1 continue if ch == ")": depth -= 1 if depth < 0 or not branch: raise SyntaxInvalid("unbalanced_parenthesis", f"extra ) at char {i}") prev = branch.pop() i += 1 continue if ch == ".": prev = None pending = None i += 1 continue if s.startswith("->", i) or s.startswith("<-", i): # rdkit's dative bond extension. Well-formed input that this parser will not # assign a hydrogen count for, so it REFUSES. Letting it fall through to the # bond table would file a valid string as unknown_element and put it into the # invalid corpus carrying a fabricated reason code, which is the same bug the # bare wildcard case fixes. Every structure that uses it in the measurement # set is a metal complex and therefore out of scope by element anyway. raise ParseRefused("dative bond notation") if ch in BOND_ORDER: pending = BOND_ORDER[ch] i += 1 continue if ch == "%": j = i + 1 if j + 1 >= n or not s[j:j + 2].isdigit(): raise SyntaxInvalid("unclosed_ring_bond", f"malformed %nn at char {i}") rnum = int(s[j:j + 2]) prev = _ring_bond(mol, ring, rnum, prev, pending, i) pending = None i = j + 2 continue if ch.isdigit(): rnum = int(ch) prev = _ring_bond(mol, ring, rnum, prev, pending, i) pending = None i += 1 continue # An atom. if ch == "[": m = _BRACKET.match(s, i) if not m: close = s.find("]", i) raise SyntaxInvalid("unknown_element", f"unparseable bracket atom {s[i:close + 1] if close > 0 else s[i:]!r}") sym = m.group("sym") if sym == "*": raise ParseRefused("wildcard atom") if m.group("iso"): raise ParseRefused(f"isotope {m.group(0)}") hgrp = m.group("h") h = 0 if not hgrp else (1 if hgrp == "H" else int(hgrp[1:])) aromatic = sym[0].islower() canon = sym.capitalize() if aromatic else sym if canon not in VALENCES and canon not in ("Se", "As"): raise ParseRefused(f"element {canon} outside the supported set") if canon in ("Se", "As"): raise ParseRefused(f"element {canon} outside the supported set") atom = Atom(len(mol.atoms), canon, aromatic, True, h, _split_charge(m.group("chg"))) mol.atoms.append(atom) i = m.end() else: if ch == "*": # A wildcard is well-formed SMILES for an unspecified atom. It is not a # syntax error and it is not something this parser will guess a formula # for, so it refuses. Filing it as unknown_element would put a valid # string into the invalid corpus with a fabricated reason code. raise ParseRefused("bare wildcard atom") sym = None for cand in ORGANIC_SUBSET: if s.startswith(cand, i): sym = cand break if sym is None: for cand in AROMATIC_LOWER: if s.startswith(cand, i): sym = cand break if sym is None: raise SyntaxInvalid("unknown_element", f"char {s[i]!r} at position {i} starts no known element") aromatic = sym.islower() canon = sym.upper() if aromatic else sym if canon == "B" and aromatic: raise ParseRefused("aromatic boron") atom = Atom(len(mol.atoms), canon, aromatic, False, 0, 0) mol.atoms.append(atom) i += len(sym) idx = atom.idx if prev is not None: order = pending if pending is not None else ( 1.5 if (mol.atoms[prev].aromatic and atom.aromatic) else 1.0) mol.add_bond(prev, idx, order) pending = None prev = idx if depth != 0 or branch: raise SyntaxInvalid("unbalanced_parenthesis", f"{abs(depth)} unclosed ( at end of string") if ring: raise SyntaxInvalid("unclosed_ring_bond", f"ring bond number(s) {sorted(ring)} never closed") if not mol.atoms: raise SyntaxInvalid("unknown_element", "no atoms") return mol def _ring_bond(mol: Molecule, ring: dict, rnum: int, prev: int | None, pending: float | None, pos: int) -> int: if prev is None: raise SyntaxInvalid("unclosed_ring_bond", f"ring bond digit {rnum} at char {pos} with no preceding atom") if rnum in ring: other, other_pending = ring.pop(rnum) order = pending if pending is not None else ( other_pending if other_pending is not None else (1.5 if (mol.atoms[other].aromatic and mol.atoms[prev].aromatic) else 1.0)) mol.add_bond(other, prev, order) mol.ring_closures.append((other, prev)) else: ring[rnum] = (prev, pending) return prev def implicit_h(atom: Atom) -> int: """Hydrogen rdkit would add. Bracket atoms get none: the bracket already said.""" if atom.bracket: return 0 # Aromatic bonds are carried as 1.5 in the graph so a Kekule-free walk still knows # they are not plain single bonds. For the valence sum, count each aromatic bond as # one and add a single unit back for the one formal double bond the atom carries. if atom.aromatic: # An aromatic ring needs six pi electrons and each atom supplies them EITHER by # contributing one electron through a formal double bond OR by donating a lone # pair. It cannot do both, and which one it does follows from how many sigma # bonds it has already spent. if atom.symbol in ("O", "S"): return 0 # furan / thiophene heteroatom, lone pair donor if atom.symbol in ("N", "P"): # Two connections is pyridine-type and carries the formal double bond: # 2 + 1 = 3. Three connections has spent every sigma bond and must donate # the lone pair instead, so no double bond: 3 + 0 = 3. Both land exactly on # nitrogen's valence of 3 with nothing left over, so a BARE lowercase # aromatic nitrogen never takes an implicit hydrogen either way. The # pyrrole NH is written [nH] and takes its hydrogen from the bracket. # # Added 2026-07-28 after the scorer selftest showed the parser refusing # caffeine. Derived from the rule above, which rule 4 already applied to # aromatic o and s; the omission was never extending it to nitrogen. Frozen # against ten NEWLY hand-computed structures in # hand_formulas_appendix_aromatic.json BEFORE this line was written, and # the resulting change in the rdkit agreement rate is published as a # separate later measurement rather than folded into the first-run number. return 0 order = float(atom.degree) + 1.0 else: order = atom.order_sum need = int(order + 0.5) if abs(order - round(order)) > 1e-9 else int(round(order)) vals = VALENCES.get(atom.symbol) if vals is None: raise ParseRefused(f"no valence model for {atom.symbol}") for v in vals: if need <= v: return v - need # More bonds than any normal valence allows. That is a valence error, not a hydrogen # count, and the caller must not be handed a number that looks like an answer. raise ParseRefused( f"{atom.symbol} at index {atom.idx} has bond order {need}, " f"above every normal valence {vals}") def counts(smiles: str) -> dict: """element_counts, formula, heavy_atom_count and bond_count. No rdkit anywhere.""" mol = parse(smiles) c: Counter[str] = Counter() h = 0 for a in mol.atoms: c[a.symbol] += 1 h += a.h_explicit + implicit_h(a) ec = dict(c) if h: ec["H"] = h charge = sum(a.charge for a in mol.atoms) return { "element_counts": dict(sorted(ec.items())), "formula": formula_with_charge(ec, charge), "heavy_atom_count": len(mol.atoms), "bond_count": len(mol.bonds), "charge": charge, "n_rings": len(mol.bonds) - len(mol.atoms) + _n_components(mol), } def _n_components(mol: Molecule) -> int: seen: set[int] = set() comps = 0 for a in mol.atoms: if a.idx in seen: continue comps += 1 stack = [a.idx] while stack: x = stack.pop() if x in seen: continue seen.add(x) stack.extend(mol.adj.get(x, [])) return comps def ring_closure_pairs(smiles: str) -> list[tuple[int, int]]: """The atom pairs joined by ring-closure digits, in the order the digits appear.""" return parse(smiles).ring_closures def classify_syntax(smiles: str) -> str | None: """The syntax reason code for a string rdkit's sanitize-off parse rejected. Returns None when the string is syntactically well-formed, which means any failure rdkit reported was chemical rather than textual and belongs to DetectChemistryProblems. """ try: parse(smiles) except SyntaxInvalid as e: return e.code except ParseRefused: return None return None def shortest_path_len(smiles: str, i: int, j: int) -> int | None: """Bond-count distance, breadth first. Used only as a cross check on rdkit.""" mol = parse(smiles) if not (0 <= i < len(mol.atoms) and 0 <= j < len(mol.atoms)): return None if i == j: return 0 dist = {i: 0} frontier = [i] while frontier: nxt = [] for x in frontier: for y in mol.adj.get(x, []): if y not in dist: dist[y] = dist[x] + 1 if y == j: return dist[y] nxt.append(y) frontier = nxt return None # --------------------------------------------------------------------------- # Acceptance test: the frozen hand set, and nothing else. # --------------------------------------------------------------------------- def hand_set(path: Path = HAND_PATH) -> list[dict]: return json.loads(path.read_text())["set"] def hand_sha_ok(path: Path = HAND_PATH, sha_path: Path = HAND_SHA_PATH) -> tuple[bool, str, str]: got = hashlib.sha256(path.read_bytes()).hexdigest() want = sha_path.read_text().split()[0] return got == want, got, want def check_against_hand(verbose: bool = True, path: Path = HAND_PATH) -> tuple[int, int, list[str]]: """Compare the parser to the hand computations. Never to rdkit.""" rows = hand_set(path) fails: list[str] = [] for m in rows: try: got = counts(m["smiles"]) except (SyntaxInvalid, ParseRefused) as e: fails.append(f"{m['id']} {m['name']}: parser refused or rejected: {e}") continue for field in ("formula", "heavy_atom_count", "bond_count"): if got[field] != m[field]: fails.append(f"{m['id']} {m['name']}: {field} " f"parser={got[field]!r} hand={m[field]!r}") if got["element_counts"] != dict(sorted(m["element_counts"].items())): fails.append(f"{m['id']} {m['name']}: element_counts " f"parser={got['element_counts']} hand={m['element_counts']}") if verbose: for f in fails: print(" FAIL " + f) return len(rows) - len({f.split(":")[0].split()[0] for f in fails}), len(rows), fails def _selftest() -> None: all_fails: list[str] = [] for label, hp, sp in (("hand_formulas.json (the original 30)", HAND_PATH, HAND_SHA_PATH), ("hand_formulas_appendix_aromatic.json (10 more)", APPENDIX_PATH, APPENDIX_SHA_PATH)): ok_sha, got, want = hand_sha_ok(hp, sp) print(f"{label}\n sha256 {got[:16]}... " f"{'matches the frozen record' if ok_sha else 'DOES NOT MATCH ' + want[:16]}") if not ok_sha: raise SystemExit( "REFUSING to report a parser pass: a frozen hand-computed file has been " "edited since it was sealed. Its whole value is that it predates the " "parser code it tests.") passed, total, fails = check_against_hand(path=hp) all_fails += fails print(f" parser agrees with {passed}/{total} hand-computed structures") fails = all_fails # Syntax classification must fire, one case per code, and must NOT fire on a valid # string. A classifier that never returns None would mark every row a syntax error. cases = [ ("c1ccccc1O", None), ("CC(C", "unbalanced_parenthesis"), ("CCC)C", "unbalanced_parenthesis"), ("c1ccccc", "unclosed_ring_bond"), ("CCXCC", "unknown_element"), ("C1CCCCC1", None), ] syn_ok = 0 for s, want_code in cases: got_code = classify_syntax(s) assert got_code == want_code, (s, got_code, want_code) syn_ok += 1 print(f"syntax classification: {syn_ok}/{len(cases)} cases correct " f"({len({c for _, c in cases if c})} distinct codes exercised, " f"2 valid strings correctly returned None)") # Refusal must stay distinct from disagreement. for bad in ("[13C]CO", "[Se]c1ccccc1", "*CC"): try: counts(bad) raise AssertionError(f"expected ParseRefused for {bad}") except ParseRefused: pass except SyntaxInvalid: raise AssertionError(f"{bad} was misfiled as a syntax error") print("refusal path: 3/3 unsupported inputs refused rather than guessed") # The path helper, on a structure whose distances are obvious by inspection. assert shortest_path_len("CCCCC", 0, 4) == 4 assert shortest_path_len("c1ccccc1", 0, 3) == 3 assert shortest_path_len("CCO.CCO", 0, 4) is None print("shortest_path_len: 3/3 OK") if fails: raise SystemExit(f"{len(fails)} hand-set disagreement(s); see above") print("indep_parser selftest: OK") def _vs_rdkit(path: Path, limit: int, emit: Path | None) -> None: """THE MEASUREMENT. Run once. The number it prints is the number we publish.""" from rdkit import Chem, RDLogger from rdkit.Chem import rdMolDescriptors RDLogger.DisableLog("rdApp.*") smis: list[str] = [] for line in path.read_text().splitlines(): line = line.strip() if not line: continue if line.startswith("{"): r = json.loads(line) s = r.get("smiles") or r.get("SMILES") or "" else: s = line.split()[0] if s: smis.append(s) if limit: smis = smis[:limit] agree = 0 refused = 0 rdkit_rejected = 0 disagreements: list[dict] = [] for s in smis: mol = Chem.MolFromSmiles(s) if mol is None: rdkit_rejected += 1 continue try: got = counts(s) except ParseRefused as e: refused += 1 continue except SyntaxInvalid as e: disagreements.append({"smiles": s, "field": "parse", "parser": f"SyntaxInvalid {e.code}", "rdkit": "parsed"}) continue ref = { "formula": rdMolDescriptors.CalcMolFormula(mol), "heavy_atom_count": mol.GetNumHeavyAtoms(), "bond_count": mol.GetNumBonds(), "element_counts": dict(sorted( Counter(a.GetSymbol() for a in Chem.AddHs(mol).GetAtoms()).items())), } diffs = [f for f in ref if got[f] != ref[f]] if diffs: for f in diffs: disagreements.append({"smiles": s, "field": f, "parser": got[f], "rdkit": ref[f]}) else: agree += 1 compared = agree + len({d["smiles"] for d in disagreements}) rate = 100.0 * len({d["smiles"] for d in disagreements}) / max(1, compared) print("=" * 72) print("INDEPENDENT PARSER versus RDKIT, FIRST RUN. This number is published as measured.") print("=" * 72) print(f" structures read {len(smis)}") print(f" rdkit itself rejected {rdkit_rejected} (not comparable, excluded)") print(f" parser REFUSED to answer {refused} (isotope, unsupported element, " f"valence above every normal value; counted, never scored as agreement)") print(f" compared {compared}") print(f" molecules agreeing on all 4 {agree}") print(f" molecules disagreeing {compared - agree}") print(f" FIRST RUN DISAGREEMENT RATE {rate:.2f}%") if disagreements: print("\n every disagreement, for classification as parser bug or rdkit convention:") for d in disagreements[:60]: print(f" {d['smiles']}\n {d['field']}: parser={d['parser']!r} " f"rdkit={d['rdkit']!r}") if len(disagreements) > 60: print(f" ... and {len(disagreements) - 60} more (see the emitted file)") if emit: emit.write_text(json.dumps({ "compared": compared, "agree": agree, "refused": refused, "rdkit_rejected": rdkit_rejected, "first_run_disagreement_pct": round(rate, 2), "disagreements": disagreements}, indent=2)) print(f"\n wrote {emit}") def main() -> None: ap = argparse.ArgumentParser() ap.add_argument("--selftest", action="store_true") ap.add_argument("--vs-rdkit", default="", help="file of SMILES or jsonl with a smiles key") ap.add_argument("--limit", type=int, default=0) ap.add_argument("--emit", default="") a = ap.parse_args() if a.vs_rdkit: _vs_rdkit(Path(a.vs_rdkit), a.limit, Path(a.emit) if a.emit else None) else: _selftest() if __name__ == "__main__": main()