chython 3.3__tar.gz → 3.3.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chython
-Version: 3.3
+Version: 3.3.2
 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 → chython-3.3.2}/chython/chemistry/_salts.py

@@ -397,9 +397,12 @@ def _tags(build: list[dict], roles: list[str], guarded: bool) -> frozenset[str]:
     if len(formers) > 1:
         tags.add('competing_formers')
     if len(build) > 1:
-        if any(row['klass'] == 'water' for row in build):
+        # A SOLVENT TAG NEEDS THE COMPONENT DRAWN NEUTRAL.  `klass` is read off the neutralized probe,
+        # which is right for identity -- a conjugate is not a row -- and wrong for this question: the
+        # hydroxide of `[OH-].[Na+]` keys as water and is the counterion, not solvent of crystallization.
+        if any(row['klass'] == 'water' and not row['charge'] for row in build):
             tags.add('hydrate')
-        if any(row['klass'] in _SOLVENT_CLASSES - {'water'} for row in build):
+        if any(row['klass'] in _SOLVENT_CLASSES - {'water'} and not row['charge'] for row in build):
             tags.add('solvate')
 
     if any(row['residual_charge'] for row, role in zip(build, roles) if role == 'parent'):
@@ -545,6 +548,34 @@ _RULE_PROTON = 'salts:charge-transfer'
 #: charges -- and 0 is the f block's unknown, which refuses for the same reason.
 _DETERMINATE_VALENCE = 3
 
+#: The s block, as `valence_electrons`: group 1 answers 1 and group 2 answers 2, while the d block answers
+#: its full count (Fe 8, Ag 11, Zn 12) and aluminium 3, so these two values name no other metal.
+_REDUCING_ELECTRONS = frozenset({1, 2})
+
+#: Beryllium, the one s-block metal that does not reduce water or an alcohol, excluded by element.
+_BERYLLIUM = 4
+
+
+def _hydride(molecule: MoleculeContainer, n: int, log: MutableSequence) -> bool:
+    """Does charging free metal `n` mean losing a hydrogen it was drawn with?  Logs the refusal if so.
+
+    `standardize()` recomputes the implicit hydrogen count of every atom this stage writes, and the count
+    an ionic metal derives is 0, so writing a charge here is what would delete the hydride.  `[NaH].CCO` is
+    sodium hydride in ethanol AS DRAWN; sodium ethoxide and H2 is a reaction, which this pass does not run.
+    The same guard `split_salts` applies before cutting a bond, for the same reason.
+    """
+    hydrogens = molecule.implicit_h_of(n)
+    if hydrogens is None:
+        count = 'an unknown number of'
+    elif hydrogens:
+        count = str(hydrogens)
+    else:
+        return False
+    log.append(LogRecord(_RULE_METAL, (n,),
+                         f'atom {n} is a free metal carrying {count} implicit hydrogen(s); charging it '
+                         f'would drop them, so the whole record is left as drawn', REFUSED))
+    return True
+
 
 def fix_salt_charges(molecule: MoleculeContainer, log: MutableSequence) -> set[int]:
     """Move the charges a salt was drawn without: `CC(=O)O.[Na]` is `CC(=O)[O-].[Na+]`.  Written ids.
@@ -563,6 +594,11 @@ def fix_salt_charges(molecule: MoleculeContainer, log: MutableSequence) -> set[i
     ALL-OR-NOTHING PER RECORD, not per site, and both steps are planned entirely in reads: step 1 charges a
     metal on the strength of a balance step 2 may refuse.  `[Na]` alone is that case, and it comes back as
     `[Na]`.
+
+    WATER AND AN ALCOHOL ARE SITES ONLY FOR AN S-BLOCK METAL.  `CCO.[Na]` is sodium ethoxide and
+    `CCO.[Zn]` is left as drawn: the table's `metal_protic` rows join the rung ladder only when every free
+    metal in the record is group 1 or group 2 and none is beryllium.  They sit on rung 6, below every acid,
+    so a record holding both an acid and an alcohol spends its metal on the acid.
     """
     metals = [atom.n for atom in molecule.atoms() if atom.is_metal and not atom.degree]
     if not metals:
@@ -574,6 +610,8 @@ def fix_salt_charges(molecule: MoleculeContainer, log: MutableSequence) -> set[i
     if not any(charges.values()):
         # step 1: no metal carries a charge, so the drawing states nothing to override
         for n in metals:
+            if _hydride(molecule, n, log):
+                return set()
             electrons = molecule.atom(n).valence_electrons
             if not 0 < electrons <= _DETERMINATE_VALENCE:
                 if electrons == 0:
@@ -600,9 +638,14 @@ def fix_salt_charges(molecule: MoleculeContainer, log: MutableSequence) -> set[i
 
     sites: list[tuple[int, int, int, str]] = []
     if total > anions:
+        by_klass = salts_rows_by_klass()
+        rows = by_klass['protic_acid']
+        if all(molecule.atom(n).valence_electrons in _REDUCING_ELECTRONS and
+               molecule.element_of(n) != _BERYLLIUM for n in metals):
+            rows += by_klass['metal_protic']
         ranks = molecule.atoms_order
         best: dict[int, tuple[int, str]] = {}
-        for row in salts_rows_by_klass()['protic_acid']:
+        for row in rows:
             for mapping in row.query.get_mapping(molecule):
                 n = mapping[row.anchor]
                 if molecule.charge_of(n) or (n in best and best[n][0] <= row.order):
@@ -646,6 +689,9 @@ def fix_salt_charges(molecule: MoleculeContainer, log: MutableSequence) -> set[i
             group_numbers[n] = electrons
         held = {n: planned.get(n, charges[n]) for n in metals}
         raises = {n: group_numbers[n] for n in metals if held[n] < group_numbers[n]}
+        for n in raises:
+            if _hydride(molecule, n, log):
+                return set()
         reached = sum(raises.get(n, held[n]) for n in metals)
         if reached != anions:
             log.append(LogRecord(_RULE_METAL, tuple(metals),

{chython-3.3 → chython-3.3.2}/chython/chemistry/_tables.py

@@ -303,14 +303,18 @@ SALT_MATCHES = ('embed', 'whole')
 
 #: The closed class vocabulary.  A row naming anything else is a load-time error, because a class the
 #: passes never ask for is a row that silently does nothing.
-SALT_CLASSES = ('metal_cation', 'charge_acceptor', 'protic_acid',
+SALT_CLASSES = ('metal_cation', 'charge_acceptor', 'protic_acid', 'metal_protic',
                 'mineral_acid', 'sulfonic_acid', 'short_carboxylic_acid', 'carboxylic_acid',
                 'aromatic_acid', 'fatty_acid', 'amino_acid', 'amine_base', 'quaternary_ammonium',
                 'water', 'alcohol', 'hydrocarbon', 'halo_solvent', 'aprotic_solvent')
 
 #: Which classes are matched by embedding.  Pinned here rather than trusted from the row so a typo in
 #: `match` is a load-time error instead of a row that never fires.
-_EMBED_CLASSES = frozenset({'metal_cation', 'charge_acceptor', 'protic_acid'})
+_EMBED_CLASSES = frozenset({'metal_cation', 'charge_acceptor', 'protic_acid', 'metal_protic'})
+
+#: Which classes carry an acidity rung.  Both, and on one scale: `fix_salt_charges` ranks the two pools
+#: together, so a rung that meant something different per class would decide nothing.
+_RUNGED_CLASSES = frozenset({'protic_acid', 'metal_protic'})
 
 
 class SaltRow(NamedTuple):
@@ -319,9 +323,10 @@ class SaltRow(NamedTuple):
     Exactly one of `query` (an `embed` row) and `key` (a `whole` row) is set.  `anchor` is the stable id
     of the query atom mapped `:1` -- the subject, since a row may name a whole neighbourhood.  `key` is
     `format(species, '!s')`, the stereo-free canonical SMILES a species row is matched by.  `charges` is
-    the set of charges a cation may end up with, `metal_cation` only.  `order` is the acidity rung,
-    `protic_acid` only, low being more acidic; equal values are tied.  `heavy_atoms` is the species' atom
-    count, `0` for an `embed` row -- a size judgement the caller would otherwise re-measure per component.
+    the set of charges a cation may end up with, `metal_cation` only.  `order` is the acidity rung on one
+    scale over `protic_acid` and `metal_protic`, low being more acidic; equal values are tied.
+    `heavy_atoms` is the species' atom count, `0` for an `embed` row -- a size judgement the caller would
+    otherwise re-measure per component.
     """
     id: str
     match: str
@@ -393,11 +398,11 @@ def _compile_salts() -> tuple[SaltRow, ...]:
 
         if row['order'] == '-':
             order = 0
-            if klass == 'protic_acid':
-                raise ValueError(f'{row_id}: a protic_acid row must state its acidity rung; without one '
-                                 'the proton fix_salt_charges() moves would be chosen by file position')
+            if klass in _RUNGED_CLASSES:
+                raise ValueError(f'{row_id}: a {klass} row must state its acidity rung; without one the '
+                                 'proton fix_salt_charges() moves would be chosen by file position')
         else:
-            if klass != 'protic_acid':
+            if klass not in _RUNGED_CLASSES:
                 raise ValueError(f'{row_id}: order is the acidity rung and means nothing for a {klass} '
                                  'row; write `-`')
             order = int(row['order'])

{chython-3.3 → chython-3.3.2}/chython/chemistry/tables/salts.tsv

@@ -17,6 +17,8 @@
 #                             that one atom -- a lone [Na+].  All 93 metals `[M]` accepts qualify.
 #   charge_acceptor   embed   split_salts (the atom that keeps the electron pair)
 #   protic_acid       embed   decompose_salts (the acid_salt tag), fix_salt_charges (the proton source)
+#   metal_protic      embed   fix_salt_charges ONLY, and only when every free metal is s-block -- a site a
+#                             reducing metal opens and no acid table calls an acid
 #   the fourteen species classes  whole   decompose_salts
 #
 # A SPECIES ROW IS COMPARED BY `format(component, '!s')` -- the canonical SMILES with stereo disabled,
@@ -38,14 +40,19 @@
 # at charge+k; the row lists every value that is allowed to be, and the whole atom is refused before
 # anything is cut -- all-or-nothing, never a partially split molecule.
 #
-# `order` IS THE ACIDITY RUNG AND ONLY A `protic_acid` ROW HAS ONE.  Low is more acidic; rows sharing a
-# value are tied, and a tie is resolved by canonical order and logged rather than by file position.
+# `order` IS THE ACIDITY RUNG AND ONLY A `protic_acid` OR `metal_protic` ROW HAS ONE.  Low is more acidic;
+# rows sharing a value are tied, and a tie is resolved by canonical order and logged rather than by file
+# position.  ONE SCALE FOR BOTH CLASSES, because `fix_salt_charges` ranks them in one pool: a carboxylic
+# acid beside an alcohol and one sodium gives the carboxylate, rung 4 against rung 6.
 #
-# ALCOHOLS ARE DELIBERATELY ABSENT.  `CCO.[Na]` is more often sodium metal in ethanol than sodium ethoxide,
-# and a row here would resolve that against the commoner reading.  So is every azole but tetrazole: below
-# sulfonamide's rung an N-H needs a hydride or an organolithium, and a metal drawn beside one is reagent
-# chemistry.  An acid with no row refuses, logs, and surfaces as a `charges_undrawn` tag -- the count of
-# those refusals is what would justify a row.
+# WATER AND ALCOHOL ARE NOT ACIDS, THEY ARE WHAT A FREE S-BLOCK METAL REDUCES.  `CCN.CCO` is a mixture and
+# `CCO` is no acid site, so `decompose_salts` reads neither as a salt and a hydrate stays droppable;
+# `CCO.[Na]` is sodium ethoxide, because sodium does not stand beside a hydroxyl.  That distinction is the
+# whole of `metal_protic`.  Beryllium is the one s-block metal outside it, not reducing water.
+#
+# EVERY AZOLE BUT TETRAZOLE IS ABSENT.  Below sulfonamide's rung an N-H needs a hydride or an
+# organolithium, and a metal drawn beside one is reagent chemistry.  An acid with no row refuses, logs, and
+# surfaces as a `charges_undrawn` tag -- the count of those refusals is what would justify a row.
 #
 # There is no `elements` column: `pattern` already names the elements a row applies to, and `keep=['Na']` is
 # resolved against the MOLECULE's atoms.
@@ -58,18 +65,26 @@ salts:thiophosphate	embed	charge_acceptor	[O,S,Se;D2;z1:1]-[P]=[S,Se]	-	-	thio-
 salts:phenolate	embed	charge_acceptor	[O,S,Se;D2;z1:1]-[C,N;a]	-	-	phenolate, thiophenolate, N-hydroxy azole
 salts:nitrate	embed	charge_acceptor	[O;D2;z1:1]-[N+](-[O-])=O	-	-	nitrate, drawn charge-separated as standardize() leaves it
 salts:halide-hydroxide	embed	charge_acceptor	[O,F,Cl,Br,I;D1;z1:1]	-	-	a terminal halogen or oxygen: halide, hydroxide, alkoxide
+salts:alkoxide	embed	charge_acceptor	[O,S,Se;D2;z1:1](-[C,Si;z1])-[M]	-	-	alkoxide, thiolate, silanolate drawn with the metal bonded.  The `[M]` is the row: without it the pattern is true of diethyl ether
 # --- acidic sites: which hydrogen a metal may take, most acidic first ----------------------------- #
 salts:sulfonic-oh	embed	protic_acid	[O;D1;z1;h1:1]-[S;z5](=O)=O	-	1	sulfonic and sulfuric acid
 salts:oxo-acid-oh	embed	protic_acid	[O;D1;z1;h1:1]-[N,P,Cl,Br,I]=O	-	2	phosphoric, phosphonic, nitrous, perchloric
 salts:nitric-oh	embed	protic_acid	[O;D1;z1;h1:1]-[N+,P+,Cl+,Br+,I+]-[O-]	-	2	nitric, drawn charge-separated as standardize() leaves it
 salts:acyl-sulfonamide	embed	protic_acid	[N;D2;z1;h1:1](-[C;z2]=O)-[S;z5](=O)=O	-	2	acyl sulfonamide: saccharin
+salts:sulfinic-oh	embed	protic_acid	[O;D1;z1;h1:1]-[S;z2]=O	-	2	sulfinic acid.  The sulfonic row above is `z5`, which this S is not
+salts:thio-acid-sh	embed	protic_acid	[S;D1;z1;h1:1]-[C;z2]=[O,S]	-	2	thioacid, dithioacid, xanthic acid, dithiocarbamic acid.  Thioacetic acid is a rung optimistic here, which costs a tie broken the wrong way when one component holds two sites
 salts:hydrogen-halide	embed	protic_acid	[F,Cl,Br,I;D0;h1:1]	-	3	HF HCl HBr HI: the unbonded halogen holding its hydrogen
 salts:carboxylic-oh	embed	protic_acid	[O;D1;z1;h1:1]-[C;z2]=O	-	4	carboxylic acid
 salts:tetrazole-1h	embed	protic_acid	[nH;r5:1]:1:n:n:n:c:1	-	4	tetrazole 1H, the carboxylic-acid bioisostere
 salts:tetrazole-2h	embed	protic_acid	n:1:[nH;r5:1]:n:n:c:1	-	4	tetrazole 2H: standardize() converges no mobile hydrogen, so both tautomers get a row
+salts:thiophenol-sh	embed	protic_acid	[S;D1;z1;h1:1]-[C,N;a]	-	4	thiophenol
 salts:phenol-oh	embed	protic_acid	[O;D1;z1;h1:1]-[C,N;a]	-	5	phenol, N-hydroxy azole
 salts:imide	embed	protic_acid	[N;D2;z1;h1:1](-[C;z2]=O)-[C;z2]=O	-	5	imide: phenytoin, succinimide
 salts:sulfonamide	embed	protic_acid	[N;z1;h1,h2:1]-[S;z5](=O)=O	-	5	sulfonamide, tosylamide
+salts:thiol-sh	embed	protic_acid	[S;D1;z1;h1:1]-[C;z1]	-	5	thiol
+# --- sites only an s-block metal opens, on the same rung scale ------------------------------------ #
+salts:water-oh	embed	metal_protic	[O;D0;z1;h2:1]	-	6	water
+salts:alcohol-oh	embed	metal_protic	[O;D1;z1;h1:1]-[C,Si;z1]	-	6	alcohol, silanol.  `D1` and `z1`, so a phenol, a carboxylic acid and an ether are each somebody else's row or nobody's
 # --- species: the acids --------------------------------------------------------------------------- #
 salts:hf	whole	mineral_acid	F	-	-	hydrofluoric
 salts:hcl	whole	mineral_acid	Cl	-	-	hydrochloric

{chython-3.3 → chython-3.3.2}/chython/chemistry/test/test_salts.py

@@ -57,6 +57,24 @@ def test_the_metals_chython_two_left_alone_now_split():
         assert format(m) == expect, s
 
 
+def test_an_alkoxide_drawn_with_the_metal_bonded_splits():
+    """The drawn O-metal bond states the alkoxide, so there is nothing left to disambiguate and
+    `salts:alkoxide` reads it.  Silicon and boron are outside `[M]`, so a silyl ether is untouched."""
+    for s, expect in [('CCO[Na]', 'C(C)[O-].[Na+]'),                          # sodium ethoxide
+                      ('CC(C)(C)O[K]', 'C(C)([O-])(C)C.[K+]'),                # potassium tert-butoxide
+                      ('CCS[K]', 'C(C)[S-].[K+]'),                            # potassium ethanethiolate
+                      ('C[Si](C)(C)O[Na]', 'C[Si]([O-])(C)C.[Na+]'),          # sodium trimethylsilanolate
+                      ('CCO[Mg]OCC', 'C(C)[O-].C(C)[O-].[Mg+2]')]:
+        m = smiles(s)
+        assert split_salts(m) is True, s
+        assert format(m) == expect, s
+    for s in ['CCOCC', 'CSC', 'CCO[Si](C)(C)C', 'CCOB(OCC)OCC']:              # no metal, no acceptor
+        m = smiles(s)
+        before = m.canonical_bytes
+        assert split_salts(m) is False, s
+        assert m.canonical_bytes == before, s
+
+
 def test_the_atom_count_never_changes():
     """The atom count is a contract of this pass; nothing in this module deletes a component."""
     for s in ['CC(=O)O[Na]', 'CC(=O)O[Zn]OC(C)=O', '[Al](OC(C)=O)(OC(C)=O)OC(C)=O', '[Na][Cl]']:
@@ -627,7 +645,8 @@ def test_classes_are_grouped_and_none_is_missing():
     assert set(grouped) == set(SALT_CLASSES)
     assert sum(len(rows) for rows in grouped.values()) == len(salts_rows())
     assert len(grouped['metal_cation']) == 1
-    assert len(grouped['charge_acceptor']) == 5
+    assert len(grouped['charge_acceptor']) == 6
+    assert len(grouped['metal_protic']) == 2
     assert len(grouped['water']) == 1
 
 
@@ -646,9 +665,10 @@ def test_only_the_metal_cation_row_carries_charges():
         assert bool(row.charges) == (row.klass == 'metal_cation'), row.id
 
 
-def test_only_a_protic_acid_row_carries_an_order():
+def test_only_a_runged_row_carries_an_order():
+    """One rung scale over the two classes `fix_salt_charges` ranks together, and no rung anywhere else."""
     for row in salts_rows():
-        assert bool(row.order) == (row.klass == 'protic_acid'), row.id
+        assert bool(row.order) == (row.klass in ('protic_acid', 'metal_protic')), row.id
 
 
 def test_the_metal_row_covers_every_metal_the_core_calls_one():
@@ -700,17 +720,30 @@ ACID_LADDER = (
     ('salts:oxo-acid-oh', 2, 'OP(=O)(O)O'),
     ('salts:nitric-oh', 2, 'O[N+](=O)[O-]'),
     ('salts:acyl-sulfonamide', 2, 'O=C1NS(=O)(=O)c2ccccc21'),
+    ('salts:sulfinic-oh', 2, 'CS(=O)O'),
+    ('salts:thio-acid-sh', 2, 'CCOC(=S)S'),
     ('salts:hydrogen-halide', 3, 'Cl'),
     ('salts:carboxylic-oh', 4, 'CC(=O)O'),
     ('salts:tetrazole-1h', 4, 'c1nnn[nH]1'),
     ('salts:tetrazole-2h', 4, 'c1nn[nH]n1'),
+    ('salts:thiophenol-sh', 4, 'Sc1ccccc1'),
     ('salts:phenol-oh', 5, 'Oc1ccccc1'),
     ('salts:imide', 5, 'O=C1CCC(=O)N1'),
     ('salts:sulfonamide', 5, 'Cc1ccc(cc1)S(N)(=O)=O'),
+    ('salts:thiol-sh', 5, 'CCS'),
 )
 
-#: Nothing here is a salt-forming acid, and no row may fire on any of it.  Every azole people draw is in
-#: the list: only tetrazole sits in the salt-forming range, so every other one is a refusal by design.
+#: Every `metal_protic` row, on the same rung scale and below every acid.  A separate ladder because a
+#: separate class: these fire for a free s-block metal and for nothing else in the library.
+METAL_PROTIC_LADDER = (
+    ('salts:water-oh', 6, 'O'),
+    ('salts:alcohol-oh', 6, 'CCO'),
+)
+
+#: Nothing here is a salt-forming acid, and no `protic_acid` row may fire on any of it.  Every azole people
+#: draw is in the list: only tetrazole sits in the salt-forming range, so every other one is a refusal by
+#: design.  Water and the alcohols are here too -- they are `metal_protic`, which is a different question
+#: and a different class, so a row of this table must not call either an acid.
 NOT_ACIDS = (
     'c1cc[nH]c1', 'c1cnc[nH]1', 'c1cn[nH]c1', 'c1cn[nH]n1', 'c1c[nH]nn1', 'c1nc[nH]n1',
     'c1ccc2[nH]nnc2c1', 'c1ccc2[nH]ccc2c1', 'Cn1c(=O)c2[nH]cnc2n(C)c1=O',
@@ -718,6 +751,14 @@ NOT_ACIDS = (
     'CCO', 'O', 'CO', 'CC(C)(C)O', 'OC1CCCCC1', 'OCC1OC(O)C(O)C(O)C1O',
     'CC(C)=O', 'CS(C)=O', 'CC(=O)OC', 'COS(C)(=O)=O', 'C1CCOC1', 'c1ccncc1',
     'c1ccccc1[N+](=O)[O-]', 'C[N+](C)(C)[O-]', 'Clc1ccccc1', 'CCCl',
+    'CSC', 'CCSSCC', 'CSc1ccccc1', 'CC(=O)SC',
+)
+
+#: What a `metal_protic` row must not fire on.  Every other O-H the table already places -- a phenol and a
+#: carboxylic acid are acids and rank above these -- plus the ethers, which hold no hydrogen at all.
+NOT_METAL_PROTIC = (
+    'Oc1ccccc1', 'CC(=O)O', 'CS(=O)(=O)O', 'ON=O', 'CCOCC', 'C1CCOC1', 'COC', 'C[Si](C)(C)OC',
+    'CCS', 'CC(=O)OC', 'CC(C)=O', 'NO', 'OO',
 )
 
 
@@ -746,6 +787,33 @@ def test_no_acid_row_fires_on_a_non_acid():
         assert not fired, (spelling, fired)
 
 
+def test_the_metal_protic_ladder_is_the_table():
+    rows = salts_rows_by_klass()['metal_protic']
+    assert [(row.id, row.order) for row in rows] == [(i, o) for i, o, _ in METAL_PROTIC_LADDER]
+    acids = salts_rows_by_klass()['protic_acid']
+    assert min(row.order for row in rows) > max(row.order for row in acids), \
+        'a metal_protic rung must sit below every acid: the metal spends itself on the acid first'
+
+
+def test_every_metal_protic_row_fires_on_its_compound():
+    rows = {row.id: row for row in salts_rows_by_klass()['metal_protic']}
+    for row_id, _, spelling in METAL_PROTIC_LADDER:
+        mol = smiles(spelling)
+        mol.standardize()
+        mol.thiele()
+        assert next(rows[row_id].query.get_mapping(mol), None) is not None, row_id
+
+
+def test_no_metal_protic_row_fires_on_an_acid_or_an_ether():
+    rows = salts_rows_by_klass()['metal_protic']
+    for spelling in NOT_METAL_PROTIC:
+        mol = smiles(spelling)
+        mol.standardize()
+        mol.thiele()
+        fired = [row.id for row in rows if next(row.query.get_mapping(mol), None) is not None]
+        assert not fired, (spelling, fired)
+
+
 def test_a_nitrophenol_is_a_phenol_and_not_a_nitric_acid():
     rows = {row.id: row for row in salts_rows_by_klass()['protic_acid']}
     mol = smiles('c1cc(O)ccc1[N+](=O)[O-]')
@@ -765,6 +833,12 @@ TAGGINGS = (
     ('CC(=O)Oc1ccccc1C(=O)O.O', {'hydrate'}),
     ('CCN.Cl', {'acid_salt'}),
     ('c1ccncc1.OC(=O)C(F)(F)F', {'acid_salt'}),
+    ('CCN.CCS', {'acid_salt'}),                           # a thiol is an acid site, so this is a salt
+    ('CCN.Sc1ccccc1', {'acid_salt'}),
+    ('CCN.CCOC(=S)S', {'acid_salt'}),                     # xanthic acid
+    ('CCN.CS(=O)O', {'acid_salt'}),                       # sulfinic: the sulfonic row is z5, this S is z2
+    ('CCN.CCO', {'solvate'}),                             # and an alcohol is still no acid site
+    ('CCS.[Na].CCBr', {'metal_salt', 'acid_salt'}),       # the thiol is what the lone sodium owes to
     ('CC(=O)[O-].[Na+]', {'metal_salt', 'ion_pair'}),
     ('CC(=O)O[Na]', {'metal_salt', 'ion_pair'}),
     ('CC(=O)O.[Na+]', {'metal_salt', 'charge_unbalanced'}),
@@ -807,6 +881,37 @@ def test_a_tag_does_not_flip_when_classes_widen():
     assert 'solvate' in narrow and narrow == wide
 
 
+def test_a_solvent_tag_needs_the_component_drawn_neutral():
+    """`klass` is read off the neutralized probe and the solvent tags are not.
+
+    Sodium hydroxide keys as water, because a conjugate is not a row and that is what makes the inventory
+    small; it is the counterion all the same, and `hydrate` is a claim about solvent of crystallization.
+    The roles are untouched -- both components stay parents and nothing is stripped.
+    """
+    for spelling in ('[OH-].[Na+]', 'CC[O-].[Na+]', 'CC(C)(C)[O-].[K+]', 'C[O-].[Na+]'):
+        answer = smiles(spelling).decompose_salts()
+        assert 'hydrate' not in answer.tags and 'solvate' not in answer.tags, spelling
+        assert {'metal_salt', 'ion_pair'} <= answer.tags, spelling
+        assert len(answer.parents) == 2 and not answer.stabilizers, spelling
+    # and the drawn-neutral water is still the hydrate it was
+    for spelling in ('CC(=O)Oc1ccccc1C(=O)O.O', 'CCCS([O-])(=O)=O.[Na+].O', 'O.[Na]'):
+        assert 'hydrate' in smiles(spelling).decompose_salts().tags, spelling
+
+
+def test_an_attachment_point_is_a_parent_like_any_other():
+    """A supported-synthesis drawing keys and desalts like anything else: the `[R]` is skeleton.
+
+    `[R]` alone is `single` and no more -- it is neither a lone metal nor a recognized solvent, so the
+    parent guard has nothing to promote back.
+    """
+    answer = smiles('[R]CCN.Cl').decompose_salts()
+    assert [format(row.molecule, '!s') for row in answer.parents] == ['C(N)C[R]']
+    assert [row.klass for row in answer.stabilizers] == ['mineral_acid']
+    assert answer.tags == frozenset({'acid_salt'})
+    assert 'hydrate' in smiles('[R]CCN.O').decompose_salts().tags
+    assert smiles('[R]').decompose_salts().tags == frozenset({'single'})
+
+
 def test_the_three_records_the_default_keeps_whole():
     api = 'CC(=O)Oc1ccccc1C(=O)O'                                  # aspirin: a carboxylic acid site
     for record, tag in ((f'{api}.Cc1ccccc1', 'solvate'),
@@ -928,6 +1033,25 @@ def test_canonicalize_does_not_undo_the_repair():
     assert mol.canonical_bytes == smiles('CC(=O)[O-].[Na+]').canonical_bytes
 
 
+def test_a_free_s_block_metal_beside_water_or_an_alcohol_is_the_alcoholate():
+    """Through `standardize()` and through `canonicalize()`, which reaches this stage by running it: a
+    hydroxide's own hydrogen comes back from `calc_implicit` like any other."""
+    for drawn, after in (('CCO.[Na]', 'CC[O-].[Na+]'),
+                         ('O.[Na]', '[OH-].[Na+]'),
+                         ('CC(C)(C)O.[K]', 'CC(C)(C)[O-].[K+]'),
+                         ('CCS.[Na]', 'CC[S-].[Na+]'),
+                         ('C[Si](C)(C)O.[Na]', 'C[Si](C)(C)[O-].[Na+]'),
+                         ('CCO.[Zn]', 'CCO.[Zn]')):        # not the s block: left as drawn
+        for pipeline in ('standardize', 'canonicalize'):
+            mol = smiles(drawn)
+            getattr(mol, pipeline)()
+            assert mol.canonical_bytes == smiles(after).canonical_bytes, (drawn, pipeline)
+            assert not mol.check_valence(), (drawn, pipeline)
+    mol = smiles('O.[Na]')
+    mol.standardize()
+    assert next(atom for atom in mol.atoms() if atom.element == 8).total_h == 1
+
+
 def test_the_log_carries_one_stage_name_for_one_call():
     mol = smiles('CC(=O)O.[Na]')
     mol.standardize()
@@ -949,6 +1073,14 @@ CHARGE_FIXES = (
     ('CS(=O)(=O)O.[Na]', 'CS(=O)(=O)[O-].[Na+]'),           # rung 1
     ('Cl.[Na]', '[Cl-].[Na+]'),                              # rung 3
     ('Oc1ccccc1.[Na]', '[O-]c1ccccc1.[Na+]'),                # rung 5
+    ('CCS.[Na]', 'CC[S-].[Na+]'),                            # rung 5: a thiol, for any metal at all
+    ('CCO.[Na]', 'CC[O-].[Na+]'),                            # rung 6: only an s-block metal opens this
+    ('O.[Na]', '[OH-].[Na+]'),
+    ('O.O.[Mg]', '[OH-].[OH-].[Mg+2]'),                      # two equivalents, two sites
+    ('CC(=O)O.CCO.[Na]', 'CC(=O)[O-].CCO.[Na+]'),            # rung 4 beats rung 6: the acid spends it
+    ('CCO.[Sc]', None),                                      # d block: an alcohol is no site for it
+    ('CCO.[Al]', None),                                      # p block: the same
+    ('CCO.[Be]', None),                                      # the s-block metal that reduces neither
     ('CC(=O)O.[Mg]', None),                                  # case 4: one equivalent, two wanted
     ('CC(=O)O.[Zn]', None),                                  # step 1 refused
     ('CCCCCC.[Na+]', None),                                  # case 4: nothing to sit on
@@ -1006,6 +1138,39 @@ def test_the_chosen_site_and_the_moved_charge_are_named_in_the_log():
     assert 'salts:carboxylic-oh' in transfer.message
 
 
+def test_a_metal_protic_site_is_named_in_the_log_like_any_other():
+    _, _, log = _fixed('CCO.[Na]')
+    transfer = next(record for record in log if record.rule == 'salts:charge-transfer')
+    assert 'salts:alcohol-oh' in transfer.message and 'rung 6' in transfer.message
+
+
+def test_the_alcohol_is_a_site_for_the_s_block_and_for_no_other_metal():
+    """The ruling: a free group 1 or 2 metal does not stand beside a hydroxyl.  Beryllium is the one
+    s-block metal outside it, and the d and p blocks are outside it as blocks."""
+    for symbol in ('Li', 'Na', 'K', 'Cs', 'Mg', 'Ca', 'Ba'):
+        # one alcohol per equivalent: the stage is all-or-nothing, so a group 2 metal needs two
+        charge = smiles('[%s]' % symbol).atom(1).valence_electrons
+        mol, written, log = _fixed('.'.join(['CCO'] * charge + ['[%s]' % symbol]))
+        assert written, symbol
+        assert all(record.severity == REPAIRED for record in log), symbol
+        assert sum(atom.charge for atom in mol.atoms() if atom.charge > 0) == charge, symbol
+    for symbol in ('Be', 'Sc', 'Al', 'Zn', 'Fe', 'Ce'):
+        mol, written, log = _fixed('.'.join(['CCO'] * 4 + ['[%s]' % symbol]))
+        assert not written, symbol
+        assert all(record.severity == REFUSED for record in log), symbol
+
+
+def test_a_thiol_is_an_acid_for_every_metal_and_not_a_metal_protic_site():
+    """The sulfur rows are `protic_acid`, so they need no s-block gate -- what gates them is the same
+    determinate-valence step every acid goes through."""
+    mol, written, log = _fixed('CCS.CCS.CCS.[Al]')
+    assert mol.canonical_bytes == smiles('CC[S-].CC[S-].CC[S-].[Al+3]').canonical_bytes
+    assert all(record.severity == REPAIRED for record in log)
+    # and the alcohol is not, for the same metal and the same count
+    mol, written, log = _fixed('CCO.CCO.CCO.[Al]')
+    assert not written and all(record.severity == REFUSED for record in log)
+
+
 def test_the_ladder_picks_the_more_acidic_of_two_sites():
     # a phenol and a carboxylic acid on one molecule: rung 4 beats rung 5
     mol, written, log = _fixed('OC(=O)c1ccccc1O.[Na]')
@@ -1076,6 +1241,42 @@ def test_a_refused_case_2_leaves_no_hydrogen_behind():
     assert mol.canonical_bytes == smiles('[Al+].[O-]S(=O)(=O)[O-]').canonical_bytes
 
 
+#: A free metal drawn with a hydrogen, one record per path that would have written its charge: the four
+#: acidity rungs an alcohol, water, a carboxylic acid and a benzylic alcohol reach, and the case-2 raise.
+#: `[H-].[Na+].CCO` is the control -- drawn ionically, the hydride is a component and nothing is at risk.
+HYDRIDE_RECORDS = ('[NaH]', '[NaH].CCO', '[NaH].O', '[NaH].CC(=O)O', '[NaH].c1ccccc1CO', '[KH].CCO',
+                   '[AlH2].CCO', '[MgH+].[O-]S(=O)(=O)[O-]')
+
+
+@mark.parametrize('spelling', HYDRIDE_RECORDS)
+def test_an_implicit_hydrogen_on_the_free_metal_refuses_the_transfer(spelling):
+    """Charging a free metal drops nothing it was drawn with.
+
+    `[NaH].CCO` is sodium hydride in ethanol AS DRAWN.  Sodium ethoxide and H2 is a reaction, not a
+    repair, and the hydride has nowhere to go, so the record is left alone -- the guard `split_salts()`
+    already applies before cutting a bond, on the path that writes a charge without cutting one.
+    """
+    mol = smiles(spelling)
+    metal = next(atom.n for atom in mol.atoms() if atom.is_metal)
+    brutto, hydrogens = mol.brutto, mol.implicit_h_of(metal)
+    log = mol.log
+    mol.standardize()
+    assert mol.brutto == brutto, spelling
+    assert mol.implicit_h_of(metal) == hydrogens, spelling
+    assert mol.canonical_bytes == smiles(spelling).canonical_bytes, spelling
+    assert 'implicit hydrogen' in log.refused()[0], spelling
+
+
+def test_the_ionically_drawn_hydride_is_not_the_guard_s_business():
+    """`[H-]` is a component and not a count on the metal, so the record standardizes as any other."""
+    mol = smiles('[H-].[Na+].CCO')
+    brutto = mol.brutto
+    mol.standardize()
+    assert mol.brutto == brutto
+    assert mol.canonical_bytes == smiles('[H-].[Na+].CCO').canonical_bytes
+    assert not mol.log.refused()
+
+
 def test_case_2_requires_drawn_anions():
     mol, written, log = _fixed('[Na-]')
     assert mol.canonical_bytes == smiles('[Na-]').canonical_bytes

{chython-3.3 → chython-3.3.2}/chython/reactions/_enumerate.py

@@ -110,8 +110,66 @@ def _selected(rules: Mapping[str, tuple[ReactionRule, ...]],
     return chain.from_iterable(rules.values())
 
 
+#: `{rule id: (its groups as a set, its groups as a multiset)}`.  The prefilter's left-hand side is a
+#: constant of the row while the right-hand side is the pool's, so an enumerator walking many pools over
+#: one corpus would otherwise rebuild every row's `Counter` once per pool.
+_NEEDS_CACHE: dict[str, tuple[frozenset, Counter]] = {}
+
+
+def _needs(rule: ReactionRule) -> tuple[frozenset, Counter]:
+    """`rule.groups` as a set and as a multiset, built once per row.
+
+    Two spellings of one requirement because the set settles most pools on its own: only a row whose
+    groups are all present at all goes on to the subtraction that also counts them.
+    """
+    needs = _NEEDS_CACHE.get(rule.id)
+    if needs is None:
+        needs = _NEEDS_CACHE[rule.id] = (frozenset(rule.groups), Counter(rule.groups))
+    return needs
+
+
+def _fitting(molecules: Sequence[MoleculeContainer], rules: Mapping[str, tuple[ReactionRule, ...]],
+             reaction: str | None = None, carried: Sequence[Mapping[str, int]] | None = None
+             ) -> Iterator[ReactionRule]:
+    """The rows whose groups this pool could satisfy.  `_run`'s prefilter, and nothing after it.
+
+    Separate from `_run` because a caller may hold a test this file cannot: reconstruction knows the
+    recorded product, so it can bound what a row could BUILD from a pool before paying to build it.
+    Both filters and why each one is sound are documented on `_run`.
+
+    `carried` is the caller's own `[functional_groups(m) for m in molecules]`, positional, where it has
+    one already: a molecule's groups do not depend on what it is enumerated beside, so an enumerator
+    walking many pools over the same inputs scans each input once instead of once per pool.
+    """
+    if carried is None:
+        carried = [functional_groups(molecule) for molecule in molecules]
+    available = Counter()
+    for groups in carried:
+        available.update(groups)
+    have = available.keys()
+
+    for rule in _selected(rules, reaction):
+        wanted, counts = _needs(rule)
+        if not wanted <= have or counts - available:
+            continue
+        if any(wanted.isdisjoint(groups) for groups in carried):
+            continue
+        yield rule
+
+
+def _outcomes(rule: ReactionRule, molecules: Sequence[MoleculeContainer]
+              ) -> Iterator[EnumeratedReaction]:
+    """Every reaction `rule` produces on `molecules` that touched all of them."""
+    inputs = len(molecules)
+    for template in rule.templates:
+        for rxn in template(*molecules):
+            if len(rxn.reactants) == inputs:
+                yield EnumeratedReaction(rule.name, rxn, rule.id)
+
+
 def _run(molecules: Sequence[MoleculeContainer], rules: Mapping[str, tuple[ReactionRule, ...]],
-         reaction: str | None = None) -> Iterator[EnumeratedReaction]:
+         reaction: str | None = None, carried: Sequence[Mapping[str, int]] | None = None
+         ) -> Iterator[EnumeratedReaction]:
     """The enumeration itself.  One presence scan per input, then every row that fits.
 
     Separate from `react()` only so a test can hand it a rule fixture the corpus has no row for.
@@ -122,19 +180,16 @@ def _run(molecules: Sequence[MoleculeContainer], rules: Mapping[str, tuple[React
     (`len(rxn.reactants) == inputs`), so a three-molecule question is never answered by a row that
     ignores one; an untouched COMPONENT of a touched input is different and survives, which is the salt
     rule.  Nothing between them knows how many molecules a row "expects".
-    """
-    available = Counter()
-    for molecule in molecules:
-        available.update(functional_groups(molecule))
-    inputs = len(molecules)
 
-    for rule in _selected(rules, reaction):
-        if Counter(rule.groups) - available:
-            continue
-        for template in rule.templates:
-            for rxn in template(*molecules):
-                if len(rxn.reactants) == inputs:
-                    yield EnumeratedReaction(rule.name, rxn, rule.id)
+    THAT OUTGOING RULE IS ALSO A PREFILTER READ PER INPUT: an input carrying none of a row's groups can
+    never be one of its reactants, so a row is skipped where any single input is disjoint from it.  The
+    union test cannot see this -- it asks only whether the groups are there, not whether they are spread
+    across every molecule that has to be touched.
+
+    `carried` is `_fitting`'s, and means the same thing here.
+    """
+    for rule in _fitting(molecules, rules, reaction, carried):
+        yield from _outcomes(rule, molecules)
 
 
 def react(molecule: MoleculeContainer, others=(), reaction: str | None = None