chython 3.3.2__tar.gz → 3.4__tar.gz

{chython-3.3.2/chython.egg-info → chython-3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chython
-Version: 3.3.2
+Version: 3.4
 Summary: Library for processing molecules and reactions in python way
 Author-email: Ramil Nugmanov <nougmanoff@protonmail.com>
 License-Expression: LGPL-3.0-or-later

{chython-3.3.2 → chython-3.4}/chython/chemistry/_canonicalize.py

@@ -48,6 +48,43 @@ _RULE_ROUNDS = 'canonicalize:rounds'
 _ROUNDS_MAX = 5
 
 
+def _pin_lactim(molecule: MoleculeContainer) -> bool:
+    """Kekulise `molecule` with the C=N of one aromatic lactim pinned, when that lets a row repair it.
+
+    A site is `[O,S;D1]-c:n` with a bare two-connected ring nitrogen.  Sites are tried in `atoms_order`,
+    which the placement stage has already made spelling-independent, and a site is taken only when a
+    trial `standardize()` on the pinned form turns its C-OH into C=O -- the rows stay the only authority
+    on which lactims are lactams.  Returns True with the molecule kekulised and the repair still to run.
+    """
+    ranks = molecule.atoms_order
+    sites = []
+    for o in molecule.atom_numbers:
+        if molecule.element_of(o) not in (8, 16) or molecule.charge_of(o) or molecule.implicit_h_of(o) != 1:
+            continue
+        neighbors = tuple(molecule.neighbors_of(o))
+        if len(neighbors) != 1 or molecule.order_of(o, neighbors[0]) != 1:
+            continue
+        c = neighbors[0]
+        for n in molecule.neighbors_of(c):
+            if (molecule.element_of(n) == 7 and molecule.order_of(c, n) == 4 and not molecule.charge_of(n)
+                    and not molecule.implicit_h_of(n) and len(tuple(molecule.neighbors_of(n))) == 2):
+                sites.append((ranks[o], ranks[n], o, c, n))
+    for *_, o, c, n in sorted(sites):
+        trial = molecule.copy()
+        with trial.edit():
+            trial.set_order(c, n, 2)
+        if trial.kekule().unresolved or trial.order_of(c, n) != 2:
+            continue
+        standardize(trial)
+        if trial.order_of(o, c) != 2:
+            continue
+        with molecule.edit():
+            molecule.set_order(c, n, 2)
+        molecule.kekule()
+        return True
+    return False
+
+
 def canonicalize(molecule: MoleculeContainer, *, fix_tautomers: bool = True,
                  keep_kekule: bool = False) -> bool:
     """Bring `molecule` to the representation two drawings of one compound share.  Did it change?
@@ -149,25 +186,32 @@ def canonicalize(molecule: MoleculeContainer, *, fix_tautomers: bool = True,
     #
     #    `kekule()` leads, and not for the reason step 1 does: the `tautomer` rows are written against
     #    definite bond orders, so on the aromatic form step 7 left behind they match nothing at all and
-    #    re-running step 3 would be a guaranteed no-op.  Step 5 is re-entered only behind a repair,
-    #    which is the only thing that can hand it a charged site it has not already seen.  Step 6 rides
+    #    re-running step 3 would be a guaranteed no-op.  Step 5 is re-entered every round: a repair and
+    #    the placement both hand it charged sites it has not seen -- the placement moves an N-oxide's
+    #    charge onto an azole NH, `c1ccc2[nH]cnc2[n+]1[O-]` to `c1ccc2nc[nH+]c2n1[O-]`, a zwitterion
+    #    step 5 pairs off -- and what it pairs off can unblock the placement again.  It cannot cycle:
+    #    step 5 only ever reduces the number of charged atoms and step 8 never adds one.  Step 6 rides
     #    with the aromatisation and not with the repair: the kekulisation above is free to come back with
     #    a different Kekule form than the one it was handed, which is the form step 7 would then read.
     #    Step 2 is not re-entered: the parities it can justify are a property of the constitution, which
     #    no stage from here on changes.
+    #
+    #    A round the placement did not ask for is opened by a lactim `kekule()` left unrepairable: the
+    #    hydroxy-azine rows need the C=N beside the C-OH, and which Kekule form comes back depends on the
+    #    atom order.  `_pin_lactim` pins that C=N and kekulises around it, so 3-hydroxyisoquinoline
+    #    reaches isoquinolin-3(2H)-one from every order.
     for _ in range(_ROUNDS_MAX):
-        if not moved:
+        if moved:
+            molecule.kekule()
+        elif not (fix_tautomers and _pin_lactim(molecule)):
             break
-        molecule.kekule()
         changed = standardize(molecule, fix_tautomers=fix_tautomers)
         if changed:
             implicify_hydrogens(molecule)
-            neutralize(molecule)
+        changed |= neutralize(molecule)
         standardize_kekule(molecule)
         molecule.thiele()               # unconditional: step 6's form is what a caller compares, and
-        if not changed:                 # the kekulisation above has to be undone either way
-            break
-        moved = standardize_isomers(molecule)
+        moved = changed and standardize_isomers(molecule)   # the kekulisation has to be undone either way
     else:
         with recording(molecule, stage='canonicalize') as log:
             log.append(LogRecord(_RULE_ROUNDS, (), f'repair and placement were still changing the '

{chython-3.3.2 → chython-3.4}/chython/chemistry/_isomers.py

@@ -217,8 +217,9 @@ def _deal(sites: tuple[int, ...], states: tuple[tuple, ...]):
 
 
 def _admissible(molecule: MoleculeContainer, group: list[int],
-                placement: dict[int, tuple[int, int]]) -> bool:
-    """Does this placement give a Kekule form for this group?  The kekuliser is the oracle.
+                placement: dict[int, tuple[int, int]]) -> int | None:
+    """How many bonds `thiele()` writes aromatic under this placement, or `None` when it gives no Kekule
+    form for this group.  The kekuliser is the oracle.
 
     This group's systems and not the whole molecule's: one ring nobody can kekulise (`c1cccc1`) would
     otherwise make every placement of every other ring inadmissible.
@@ -238,17 +239,32 @@ def _admissible(molecule: MoleculeContainer, group: list[int],
             work.set_hydrogens(n, hydrogens)
     members = frozenset(group)
     if any(members.intersection(system) for system in work.kekule().unresolved):
-        return False
-    return all((work.implicit_h_of(n), work.charge_of(n)) == state for n, state in placement.items())
+        return None
+    if any((work.implicit_h_of(n), work.charge_of(n)) != state for n, state in placement.items()):
+        return None
+    work.thiele()
+    return work.aromatic_bond_count
 
 
 def _choose(molecule: MoleculeContainer, group: list[int], ranks: dict[int, int]):
     """The canonical placement for one group, `None` when nothing must move, `'budget'` when too big.
 
     The hydrogens and the charges are read off the group rather than assumed, and dealt back over it.  The
-    key is the sorted ranks of the sites holding the hydrogens, then of those holding each charge in turn
-    -- a strict total order, because `atoms_order` is a permutation and those two sets fix the placement,
-    so no two placements share a key and no tie is left for an arbitrary rule to break.
+    key is the aromatic bond count `thiele()` gives the placement, most first, then the hydrogens beside a
+    C=O or C=S carbon, then the hydrogens on five-membered rings, each most first, then the sorted ranks
+    of the sites holding the hydrogens, then of those holding each charge in turn -- a strict total order,
+    because `atoms_order` is a permutation and those two sets fix the placement, so no two placements
+    share a key and no tie is left for an arbitrary rule to break.
+
+    A lactam N-H sits next to its carbonyl: 6-methylpyrimidin-4(3H)-one, not its 1H form.  An azole N-H
+    outranks an azine N-H whenever both forms are equally aromatic, so every 7-azaindole reads 1H
+    (`c1cnc2[nH]ccc2c1`), its carboxylic acid too.  Ring size and bond order are graph facts, so both
+    terms are as spelling-independent as the ranks after them.
+
+    Aromaticity leads because a fused system spelled aromatic joins rings a hydrogen cannot cross for
+    free: pyrido[4,3-d]pyrimidine-2,4-dione `O=C1NC(=O)c2cnccc2N1` with its N1-H moved onto the pyridine
+    N kekulises, as a quinoid imine with no pyridine sextet.  Only nitrogen sites deal here and `thiele()`
+    leaves a lactam non-aromatic, so the term never weighs an enol against its ketone.
 
     A hydrogen deals over the sites with two heavy neighbours and a charge over all of them, which is the
     whole difference a substituted nitrogen makes.  That much is not left to the oracle: `kekule()` decides
@@ -268,16 +284,22 @@ def _choose(molecule: MoleculeContainer, group: list[int], ranks: dict[int, int]
     if trials == 1:
         return None                       # one way to deal them: there is no distribution to choose
     signs = [q for q in sorted(charges) if q]
+    azole = {n for n in carriers if 5 in molecule.ring_sizes_of(n)}
+    lactam = {n for n in carriers
+              if any(any(molecule.order_of(c, x) == 2 and molecule.element_of(x) in _DONOR
+                         for x in molecule.neighbors_of(c)) for c in molecule.neighbors_of(n))}
     current = {n: (molecule.implicit_h_of(n) or 0, molecule.charge_of(n)) for n in group}
     best = None
     for protonated in combinations(carriers, hydrogens):
         for dealt in _deal(tuple(group), order):
             placement = {n: (1 if n in protonated else 0, dealt[n]) for n in group}
-            key = [sorted(ranks[n] for n in protonated)]
+            aromatic = _admissible(molecule, group, placement)
+            if aromatic is None:
+                continue
+            key = [[-aromatic, -sum(n in lactam for n in protonated), -sum(n in azole for n in protonated)],
+                   sorted(ranks[n] for n in protonated)]
             key.extend(sorted(ranks[n] for n in group if dealt[n] == q) for q in signs)
-            if best is not None and key >= best[0]:
-                continue                  # cheaper than the oracle, so it goes first
-            if _admissible(molecule, group, placement):
+            if best is None or key < best[0]:
                 best = (key, placement)
     if best is None or best[1] == current:
         return None

{chython-3.3.2 → chython-3.4}/chython/chemistry/_protomers.py

@@ -66,6 +66,11 @@ def _admitted(molecule: MoleculeContainer, candidates: dict[int, AcidRow], delta
                                    f'atom {n} has no derivable implicit hydrogen count, so a proton '
                                    f'cannot be counted off or onto it', REFUSED))
             continue
+        if hydrogens + delta < 0:
+            lines.append(LogRecord(row.id, (n,),
+                                   f'atom {n} holds its proton as a drawn hydrogen atom, and this pass '
+                                   f'writes implicit counts only', REFUSED))
+            continue
         order_sum, environment, aromatic = environment_of(molecule, n)
         # an aromatic bond has no valence row, so the question cannot be put -- `check_valence` calls
         # that `unknown` rather than a violation, and a pyridinium must stay deprotonatable.
@@ -101,8 +106,9 @@ def neutralize(molecule: MoleculeContainer, *, keep_charge: bool = True) -> bool
     nitrate past zero.  `keep_charge=False` lets a site act alone, as far as its own component's charge
     allows: `C[NH3+]` alone becomes `CN`.
 
-    Sites are found by `tables/acids.tsv`, whose `h` primitive reads IMPLICIT hydrogens, so a molecule
-    carrying explicit hydrogen atoms wants `implicify_hydrogens()` first.  A site whose hydrogen count
+    Sites are found by `tables/acids.tsv`, whose `h` primitive counts drawn hydrogen atoms too, but a
+    proton is moved only off an implicit count, so a molecule carrying explicit hydrogen atoms wants
+    `implicify_hydrogens()` first.  A site whose hydrogen count
     is not derivable, and one whose neutral form no valence row accepts, is refused and logged.
     """
     lines: list[LogRecord] = []

{chython-3.3.2 → chython-3.4}/chython/chemistry/tables/acids.tsv

@@ -14,8 +14,8 @@
 #            pattern matching nothing is invisible: the pass just stops recognizing that site.
 #   comment  what the row claims.  Documentation only.
 #
-# `h` COUNTS IMPLICIT HYDROGENS ONLY, so an `acid` row does not see `[N+]([H])([H])[H]` drawn with three
-# hydrogen ATOMS.  `implicify_hydrogens()` first; the pass says so in its docstring.
+# `h` COUNTS DRAWN HYDROGENS TOO, but a proton moves only off an implicit count, so `[N+]([H])([H])[H]`
+# drawn with three hydrogen ATOMS is refused.  `implicify_hydrogens()` first; the pass says so in its docstring.
 #
 # AN UNSTATED CHARGE IS NEUTRAL, not "any charge", which is why nitrate has a row of its own: the anchor
 # oxygen's neighbour is `[N+]`, and `acids:alkoxide`'s `[C,N]` admits the neutral nitrogen alone.

{chython-3.3.2 → chython-3.4}/chython/chemistry/tables/standardize_groups.tsv

@@ -87,7 +87,7 @@ groups:05	[B;z1]-[O,S;D3;z1]	-	1:2:8	0	-	BS(C)C>>[BH3]~[S](C)C	A three-coordinat
 groups:06	[B;z2;-]=[N;D1,D2,D3;z2;+]	1:1:-;2:-1:-	1:2:1	0	-	[B-]=[N+]>>BN	A borane adduct drawn as the ylide [B-]=[N+]; the two charges cancel and the bond is an ordinary single one
 groups:07	[B;D4;z1;+3]([A;-])([A;-])([A;-])[A;-]	1:-4:-;2:1:-;3:1:-;4:1:-;5:1:-	-	0	-	[O-][B+3]([O-])([O-])[O-]>>[B-](O)(O)(O)O	A borate drawn with the whole count of charges on the boron and an anion on every ligand as well; the boron is [B-] and the four ligands are neutral
 groups:08	[B;D4;z1]-[A;-]	1:-1:-;2:1:-	-	0	-	[O-]B(O)(O)O>>[B-](O)(O)(O)O	A four-coordinate boron carrying an anionic ligand holds the charge itself; the negative charge moves from the ligand to the boron
-groups:09	[B;D4;z1]	1:-1:-	-	0	groups:00;groups:08	OB(O)(O)O>>[B-](O)(O)(O)O	Four single bonds on a boron is a borate; the drawing left it neutral, so the charge is added
+groups:09	[B;D4;z1]	1:-1:-	-	0	groups:08	OB(O)(O)O>>[B-](O)(O)(O)O	Four single bonds on a boron is a borate; the drawing left it neutral, so the charge is added
 groups:10	[P&D4&x0&z1,N&D4&z1]	1:1:-	-	0	-	CP(C)(C)C>>C[P+](C)(C)C;CN(C)(C)C>>C[N+](C)(C)C	Four single bonds on a phosphorus with no heteroatom neighbour, or on a nitrogen, is a phosphonium or a quaternary ammonium; the drawing left it neutral, so the charge is added and the phantom hydrogen goes with it
 groups:11	[N;D3;z5;x2](=[O;D1])([O;D1])=C	1:1:-;3:-1:-	1:4:1	1	-	C=N(=O)O>>C[N+]([O-])=O	A nitro group drawn pentavalent in its aci form, C=N(=O)OH; the nitro becomes charge-separated and the acidic hydrogen moves from oxygen to carbon
 groups:12	[N;D3;z5](=[O;D1])(=[C,N,O])-[A]	1:1:-;2:-1:-	1:2:1	0	groups:11	C=N(C)=O>>C=[N+](C)[O-]	A pentavalent nitrogen carrying an N=O and a second double bond; the N=O is separated into [N+]-[O-] and the other double bond is left as drawn

{chython-3.3.2 → chython-3.4}/chython/chemistry/test/test_canonicalize.py

@@ -228,6 +228,21 @@ def test_the_pipeline_is_a_fixed_point_and_not_merely_ordered():
             assert m.canonical_bytes == first, f'{label}: {string} is not a fixed point'
 
 
+def test_a_placement_that_makes_a_zwitterion_is_neutralized():
+    """Step 8 can hand step 5 a charged site: it moves an N-oxide's charge onto the azole NH.
+
+    Imidazo[4,5-b]pyridine 4-oxide and its N-hydroxy tautomer are one compound, and each drawing is a
+    fixed point -- the zwitterion step 8 leaves behind is not.
+    """
+    for oxide, hydroxy in (('c1ccc2[nH]cnc2[n+]1[O-]', 'c1ccc2ncnc2n1O'),
+                           ('c1[n+]([O-])c2[nH]cnc2c([N+](=O)[O-])c1', 'c1n(O)c2ncnc2c([N+](=O)[O-])c1')):
+        a, b = smiles(oxide), smiles(hydroxy)
+        a.canonicalize()
+        b.canonicalize()
+        assert a == b, f'{oxide} and {hydroxy} keep two keys: {a} vs {b}'
+        assert a.canonicalize() is False, f'{oxide} still moved on a second pass'
+
+
 def test_the_extra_round_costs_no_duplicate_repair_record():
     """A repair is reported once however many rounds saw the molecule.
 
@@ -604,3 +619,27 @@ def test_nothing_to_do_is_zero_and_touches_nothing():
         assert explicify_hydrogens(m) == 0, s
         assert len(m) == n
         assert not [r for r in log if r.rule == 'hydrogens:explicify']
+
+
+LACTIMS = ['Oc1cc2ccccc2cn1',                       # 3-hydroxyisoquinoline
+           'Cc1ncc2cnc(O)c(-c3ccccc3)c2n1',         # a fused hydroxypyridine beside a pyrimidine
+           'Oc1ncnc2ccccc12',                       # quinazolin-4-ol
+           'Cc1cc(O)nc(C)n1']                       # 2,6-dimethylpyrimidin-4-ol
+
+
+def test_a_lactim_reaches_its_lactam_from_every_atom_order():
+    """One key per compound, whichever Kekule form `kekule()` happened to return, with the NH beside
+    the C=O."""
+    import random
+    random.seed(0)
+    for lactim in LACTIMS:
+        keys = set()
+        for _ in range(40):
+            molecule = smiles(format(smiles(lactim), 'r'))
+            molecule.canonicalize()
+            keys.add(molecule.canonical_bytes)
+        assert len(keys) == 1, lactim
+        assert not any(molecule.element_of(n) == 8 and molecule.implicit_h_of(n) for n in molecule.atom_numbers)
+        nh = [n for n in molecule.atom_numbers if molecule.element_of(n) == 7 and molecule.implicit_h_of(n)]
+        assert [any(molecule.element_of(x) == 8 for c in molecule.neighbors_of(n) for x in molecule.neighbors_of(c))
+                for n in nh] == [True], f'{lactim}: {molecule}'

{chython-3.3.2 → chython-3.4}/chython/chemistry/test/test_isomers.py

@@ -192,6 +192,43 @@ def test_two_kekule_tautomers_of_one_lactam_store_the_same_molecule():
             f'{label}: {a} and {b} still differ, {ma} vs {mb}'
 
 
+AROMATIC_PAIRS = [
+    ('O=C1NC(=O)c2cnccc2N1', 'O=C1NC(=O)C2=CNC=CC2=N1', 'pyrido[4,3-d]pyrimidine-2,4-dione'),
+    ('O=C1Nc2cc3ncccc3cc2N1', 'O=C1N=C2C=C3C(=CC=CN3)C=C2N1', 'imidazo[4,5-g]quinolin-2-one'),
+]
+
+
+def test_a_fused_lactam_keeps_its_pyridine_aromatic():
+    """A hydrogen on a lactam nitrogen does not move onto a fused pyridine nitrogen, whichever form arrives.
+
+    Both placements kekulise, so the canonical order alone would take whichever ranks lower; the imine
+    leaves the pyridine without a sextet and is the form that loses.
+    """
+    for aromatic, quinoid, label in AROMATIC_PAIRS:
+        ma, mb = read_smiles(aromatic), read_smiles(quinoid)
+        canonicalize(ma)
+        canonicalize(mb)
+        assert ma.aromatic_rings_count == read_smiles(aromatic).aromatic_rings_count, f'{label}: {ma}'
+        assert ma.canonical_bytes == mb.canonical_bytes, f'{label}: {ma} vs {mb}'
+
+
+AZOLE_FIRST = [('c1cnc2[nH]ccc2c1', 'C1=CNC2=NC=CC2=C1', '7-azaindole'),
+               ('OC(=O)c1ccc2cc[nH]c2n1', 'OC(=O)C1=CC=C2C=CN=C2N1', '7-azaindole-6-carboxylic acid'),
+               ('NC(=O)c1ccc2cc[nH]c2n1', 'NC(=O)C1=CC=C2C=CN=C2N1', '7-azaindole-6-carboxamide')]
+
+
+def test_an_azole_nh_outranks_an_azine_nh():
+    """Both forms are aromatic, so the ring size decides: the hydrogen sits on the five-membered ring."""
+    for azole, azine, label in AZOLE_FIRST:
+        ma, mb = read_smiles(azole), read_smiles(azine)
+        canonicalize(ma)
+        canonicalize(mb)
+        assert ma.canonical_bytes == mb.canonical_bytes, f'{label}: {ma} vs {mb}'
+        nh = [n for n in ma.atom_numbers if ma.element_of(n) == 7 and ma.total_h_of(n)
+              and len(tuple(ma.neighbors_of(n))) == 2]
+        assert [5 in ma.ring_sizes_of(n) for n in nh] == [True], f'{label}: {ma}'
+
+
 def test_a_kekule_placement_never_changes_the_formula():
     """The working copy is spelled aromatic and kekulised back, and `kekule()` repairs when it must.
 

{chython-3.3.2 → chython-3.4}/chython/chemistry/test/test_protomers.py

@@ -175,8 +175,8 @@ def test_a_site_taken_past_zero_alone_is_refused():
 
 
 def test_explicit_hydrogens_hide_the_site():
-    """`acids.tsv` reads IMPLICIT hydrogens, so a cation drawn with hydrogen atoms is invisible until
-    they are folded in.  The docstring says `implicify_hydrogens()` first, and this is why."""
+    """A proton is moved only off an implicit count, so a cation drawn with hydrogen atoms is refused
+    until they are folded in.  The docstring says `implicify_hydrogens()` first, and this is why."""
     m = smiles('[H][N+]([H])([H])C.[Cl-]')
     assert neutralize(m) is False
     implicify_hydrogens(m)

{chython-3.3.2 → chython-3.4}/chython/chemistry/test/test_thiele_is_single_purpose.py

@@ -19,7 +19,7 @@
 """Asking for the aromatic spelling must not silently choose a tautomer.
 
 `kekule()` repairs, because it is the boundary where input arrives; `thiele()` must not, because by
-then the data is the library's own arena.  The hydrogen move chython 2 did inside `thiele` is owed to
+then the data is the library's own arena.  The hydrogen move chython 2 did inside `thiele` belongs to
 `standardize_isomers` instead.  Both halves are pinned here.
 """
 import pytest
@@ -96,16 +96,9 @@ for line in sys.stdin:
     assert on_smiles != off_smiles
 
 
-@pytest.mark.xfail(strict=True, reason='owed: standardize_isomers has not been ported yet, so the '
-                                       'hydrogen move chython 2 performed inside thiele is '
-                                       'currently unavailable anywhere.  Delete this marker when '
-                                       'the isomer pass lands -- a strict xfail is what makes that '
-                                       'a required edit rather than an optional one')
-def test_the_hydrogen_move_is_owed_to_standardize_isomers():
-    """What the split costs until the isomer pass exists, written down as a failing test.
-
-    The end state is the one chython 2 reached by combining the two jobs, and is what the ported rule
-    must reproduce: the hydrogen on atom 5, not atom 1.
+def test_the_hydrogen_move_belongs_to_standardize_isomers():
+    """The hydrogen move chython 2 made inside `thiele` is `standardize_isomers`' own: an azole N-H
+    outranks an azine N-H, so the hydrogen goes to atom 5, not atom 1.
     """
     molecule = read_smiles(SHIFTED)
     molecule.thiele()

{chython-3.3.2 → chython-3.4}/chython/core/_features.pxi

@@ -245,6 +245,9 @@ cdef int fill_features(Structure structure) except -1:
             # `rebuild_derived` derives degree as the CSR row length, `_pach.pxi` writes it as that
             # row length, and `_stereo.pxi` reads it as connectivity.  Two different facts, so two
             # counts -- neither is a stale copy of the other, and each is derived in one place only.
+            #
+            # A hydrogen ATOM of any isotope is not a `D` neighbour: `[2H]C([2H])(C)O` is a primary
+            # alcohol, `[C;D2]`, exactly as `C(C)O` is.  It counts towards `h` below instead.
             w1 = w0_element_bits(element)
             degree = 0
             heteroatoms = 0
@@ -252,8 +255,10 @@ cdef int fill_features(Structure structure) except -1:
                 w1 |= w0_bond_bits(&edges[k])
                 if edges[k].order == 8:
                     continue
-                degree += 1
                 nb_element = atoms[edges[k].to].element
+                if nb_element == 1:
+                    continue
+                degree += 1
                 if element_is_heteroatom(nb_element):
                     heteroatoms += 1
 
@@ -299,8 +304,10 @@ cdef int fill_features(Structure structure) except -1:
                 # the one function-body forward reference in the core.
                 w3 |= SPAN_MASK[SPAN_IMPLICIT_H] | SPAN_MASK[SPAN_TOTAL_H]
             else:
+                # `h` is every attached hydrogen, implicit or drawn, so a deuterium answers `h` as the
+                # protium `canonicalize()` would have folded into the count.  `H` is the same sum.
                 th = ih + eh
-                w3 |= <uint64_t> 1 << (17 + _bit_of(<int32_t> ih, 0, 4))
+                w3 |= <uint64_t> 1 << (17 + _bit_of(<int32_t> th, 0, 4))
                 w3 |= <uint64_t> 1 << (27 + _bit_of(<int32_t> th, 0, 5))
             w3 |= <uint64_t> 1 << (33 + _bit_of(a.charge, -4, 8))
             if a.isotope:

{chython-3.3.2 → chython-3.4}/chython/core/_reaction_passes.py

@@ -354,10 +354,12 @@ def reaction_reset_mapping(rxn) -> bool:
 def _side_states(molecules):
     """`({map number: state}, {colliding map numbers})` for one side.
 
-    A state is `(element, charge, radical, implicit h, {neighbour map number: order})` -- everything a
-    CGR's dynamic atom and dynamic bond carried between them, which is what the reaction centre is
-    defined against.  Bonds to an unmapped atom are left out: they cannot be compared across the arrow
-    because there is nothing to compare them to.
+    A state is `(element, charge, radical, implicit h, {neighbour map number: order}, unmapped branches)`
+    -- everything a CGR's dynamic atom and dynamic bond carried between them, which is what the reaction
+    centre is defined against.  An unmapped neighbour has no identity across the arrow, so it enters as a
+    description: the canonical SMILES of the unmapped region it belongs to, rooted at the mapped atom by
+    its map number.  `[C:1](=[O:2])OC >> [C:1](=[O:2])O` changes atom 1's branch from `[C:1]OC` to
+    `[C:1]O`; an unmapped `OH` drawn on both sides is the same branch twice and changes nothing.
     """
     states = {}
     collisions = set()
@@ -371,23 +373,42 @@ def _side_states(molecules):
             if mn in states:
                 collisions.add(mn)
             local[atom.n] = mn
-            states[mn] = (atom.element, atom.charge, atom.is_radical, atom.implicit_h, {})
+            states[mn] = (atom.element, atom.charge, atom.is_radical, atom.implicit_h, {}, [])
         for bond in molecule.bonds():
             mn, mm = local.get(bond.n), local.get(bond.m)
-            if mn is None or mm is None:
-                continue
-            states[mn][4][mm] = bond.order
-            states[mm][4][mn] = bond.order
-    return states, collisions
+            if mn is not None and mm is not None:
+                states[mn][4][mm] = bond.order
+                states[mm][4][mn] = bond.order
+        for n, mn in local.items():
+            states[mn][5].extend(_unmapped_branches(molecule, n, local))
+    return {mn: (*state[:5], tuple(sorted(state[5]))) for mn, state in states.items()}, collisions
+
+
+def _unmapped_branches(molecule, n, mapped):
+    """The canonical SMILES of each unmapped region bonded to atom `n`, with `n` itself as the root."""
+    seen = set()
+    for start in molecule.neighbors_of(n):
+        if start in mapped or start in seen:
+            continue
+        region = {start}
+        stack = [start]
+        while stack:
+            for m in molecule.neighbors_of(stack.pop()):
+                if m not in mapped and m not in region:
+                    region.add(m)
+                    stack.append(m)
+        seen |= region
+        region.add(n)
+        yield format(molecule.substructure(region), 'm')
 
 
 def reaction_center(rxn) -> set[int]:
     """The map numbers of the atoms this reaction changes.  Empty for a reaction with no mapping.
 
     An atom is in the centre when it appears on BOTH sides and something about it differs: its element,
-    charge, radical state, implicit hydrogen count, or the map numbers and orders of its bonds.  It is
-    computed without building a CGR: there is no CGR container on this release, and the question does
-    not need one.
+    charge, radical state, implicit hydrogen count, the map numbers and orders of its bonds, or the
+    unmapped branches bonded to it (`_side_states`).  It is computed without building a CGR: there is
+    no CGR container on this release, and the question does not need one.
 
     AN ATOM PRESENT ON ONLY ONE SIDE IS NOT IN THE CENTRE, and that is a decision.  Calling it dynamic
     instead -- a bond that exists on one side and not the other -- keeps sodium hydroxide a REACTANT in

{chython-3.3.2 → chython-3.4}/chython/core/_smirks_patch.pxi

@@ -53,7 +53,9 @@
 #
 #   * an atom the patch WROTE (its element, charge, radical, or one of its bonds) and every surviving
 #     neighbour of a deleted atom gets its count recomputed from the valence collection;
-#   * an atom that merely sat inside the match keeps the count its input stated, exactly;
+#   * a pnictogen sharing an aromatic ring with a pnictogen the patch bonded is recomputed -- the
+#     azole NH of the tautomer the patch replaced;
+#   * any other atom that merely sat inside the match keeps the count its input stated, exactly;
 #   * where the collection has no answer -- no row for the element in that charge and radical state,
 #     or an aromatic bond reaching the atom -- the count is stored as `H_UNKNOWN`.
 #
@@ -189,6 +191,39 @@ cdef int smk_hydrogens(MoleculeContainer m, uint32_t n) except -2:
     return H_UNKNOWN
 
 
+cdef bint smk_aromatic_pnictogen(MoleculeContainer m, object n) except -1:
+    cdef object other
+    if m.element_of(<uint32_t> n) not in (7, 15, 33):
+        return False
+    for other in m.neighbors_of(<uint32_t> n):
+        if m.order_of(<uint32_t> n, <uint32_t> other) == 4:
+            return True
+    return False
+
+
+cdef int smk_ring_pnictogens(MoleculeContainer new, set gained, set alive, set changed) except -1:
+    """Add to `changed` every pnictogen with hydrogens sharing a ring with a bonded aromatic pnictogen.
+
+    The pyrrole-type hydrogen of an azole belongs to one tautomer.  N-substituting any other ring
+    nitrogen makes it the other tautomer's, so the NH is recomputed although the patch never wrote
+    it, and comes back `H_UNKNOWN` for `kekule()`.  Example: 5-methyltetrazole arylated at N2.
+    """
+    cdef set sites = set()
+    cdef object ring, n
+    for n in gained:
+        if n in alive and smk_aromatic_pnictogen(new, n):
+            sites.add(n)
+    if not sites:
+        return 0
+    for ring in new.rings:
+        if sites.isdisjoint(ring):
+            continue
+        for n in ring:
+            if n not in changed and new.implicit_h_of(<uint32_t> n) and smk_aromatic_pnictogen(new, n):
+                changed.add(n)
+    return 0
+
+
 # "the element is the R marker", in `smk_atom_fields`'s element slot, where 0 already means INHERIT.
 # A distinct value because those two are distinct claims, and 118 elements sit between them.
 DEF SMK_ELEMENT_R = -1
@@ -928,6 +963,8 @@ cdef tuple smk_one(ReactionTemplate t, MoleculeContainer work, set work_bonds, d
             if key not in doomed:
                 changed.add(key)
 
+    # atoms given a NEW bond: the ring-pnictogen rule below starts from them
+    cdef set gained = set()
     cdef set prod_bond_set = set(t.product_bonds)
     cdef tuple fields
     cdef uint32_t nid
@@ -957,7 +994,8 @@ cdef tuple smk_one(ReactionTemplate t, MoleculeContainer work, set work_bonds, d
             if <int> fields[1] != work.charge_of(nid):
                 new.set_charge(nid, <int> fields[1])
                 changed.add(<object> nid)
-            if <int> fields[2] != work.isotope_of(nid):
+            # an unstated product isotope (0) keeps the reactant's: `[C:1]` does not strip a 14C label
+            if <int> fields[2] and <int> fields[2] != work.isotope_of(nid):
                 new.set_isotope(nid, <int> fields[2])
             if <bint> fields[3] != work.radical_of(nid):
                 new.set_radical(nid, <bint> fields[3])
@@ -997,8 +1035,11 @@ cdef tuple smk_one(ReactionTemplate t, MoleculeContainer work, set work_bonds, d
                 new.add_bond(<uint32_t> u, <uint32_t> v, order)
                 changed.add(u)
                 changed.add(v)
+                gained.add(u)
+                gained.add(v)
 
     cdef set alive = set(new.atom_numbers)
+    smk_ring_pnictogens(new, gained, alive, changed)
 
     # Hydrogens BEFORE the stereo directives, and the order is load-bearing: whether an anchor's
     # fourth direction is an atom or its implicit hydrogen is a fact about the count, so a directive
@@ -1173,7 +1214,8 @@ cdef tuple smk_one(ReactionTemplate t, MoleculeContainer work, set work_bonds, d
             (tuple(sorted(touched)), tuple(identities)), where)
 
 
-def smk_apply(ReactionTemplate t, tuple molecules, bint automorphism_filter, object log, bint report):
+def smk_apply(ReactionTemplate t, tuple molecules, bint automorphism_filter, object log, bint report,
+              bint dedupe):
     """Validate eagerly, then hand back the generator.
 
     The split is the point: a bad argument raises from the CALL, not from the first `next()`, so a
@@ -1189,10 +1231,11 @@ def smk_apply(ReactionTemplate t, tuple molecules, bint automorphism_filter, obj
             raise TypeError('a template applies to molecules; this one was handed a %s' % type(m).__name__)
     if not molecules:
         raise ValueError('a template needs at least one molecule to apply to')
-    return smk_enumerate(t, list(molecules), automorphism_filter, log, report)
+    return smk_enumerate(t, list(molecules), automorphism_filter, log, report, dedupe)
 
 
-def smk_enumerate(ReactionTemplate t, list inputs, bint automorphism_filter, object log, bint report):
+def smk_enumerate(ReactionTemplate t, list inputs, bint automorphism_filter, object log, bint report,
+                  bint dedupe):
     """Every distinct outcome of one template over one set of inputs.
 
     The inputs are unioned into one working container, which is why an intramolecular template needs
@@ -1259,10 +1302,11 @@ def smk_enumerate(ReactionTemplate t, list inputs, bint automorphism_filter, obj
             continue
         if made is None:
             continue
-        key = (<tuple> made)[1]
-        if key in seen_keys:
-            continue
-        seen_keys.add(key)
+        if dedupe:
+            key = (<tuple> made)[1]
+            if key in seen_keys:
+                continue
+            seen_keys.add(key)
         if len(log) > start:      # `_smiles_read.pxi:smi_one` states why the touch is guarded
             (<object> (<tuple> made)[0]).log.absorb('react', log[start:])
         if report:

{chython-3.3.2 → chython-3.4}/chython/core/_smirks_read.pxi

@@ -1121,7 +1121,8 @@ cdef class ReactionTemplate:
     def __repr__(self):
         return 'read_smirks(%r)' % self.smirks
 
-    def __call__(self, *molecules, bint automorphism_filter=True, log=None, bint report=False):
+    def __call__(self, *molecules, bint automorphism_filter=True, log=None, bint report=False,
+                 bint dedupe=True):
         """Apply this template to one molecule or to several, yielding one `ReactionContainer` per
         distinct outcome.
 
@@ -1158,9 +1159,15 @@ cdef class ReactionTemplate:
         reaction alone.  The ids are the yielded products' own, and they survive `copy()` and `split()`,
         so a caller that must edit "the atom the product side called :1" can reach it -- by map number,
         the template's `:N` space, which is still not the reaction's imposed mapping.
+
+        `dedupe=False` yields one outcome per embedding, including outcomes that build the same
+        structure from different atoms: `C1CNCCN1` cut at either nitrogen.  A caller that filters
+        outcomes by atom id needs every one, since the default keeps only the first of each structure.
+        `automorphism_filter` is a different collapse -- over the template's own symmetry, not the
+        outcome's.
         """
         return smk_apply(self, molecules, automorphism_filter,
-                         log if log is not None else [], report)
+                         log if log is not None else [], report, dedupe)
 
 
 def read_smirks(text, log=None, *, rule_id=None):