chython 3.3.2__tar.gz → 3.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chython
-Version: 3.3.2
+Version: 3.5
 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.5}/chython/__init__.py

@@ -29,8 +29,8 @@ from sys import modules as _modules
 from types import ModuleType as _ModuleType
 from .core import *
 from .core import read_smarts as smarts
-from .depict import (Clean2DEngine, DepictStyle, get_clean2d_engine, get_depict_style,
-                     set_clean2d_engine, set_depict_style)
+from .depict import (Clean2DEngine, DepictStyle, get_chain_layout, get_clean2d_engine, get_depict_style,
+                     get_peptide_layout, set_chain_layout, set_clean2d_engine, set_depict_style, set_peptide_layout)
 from .formats import *
 # By full path, not through `formats`' star: `pdb` is that subpackage's name too and the function
 # would shadow it.
@@ -45,8 +45,9 @@ from .interop.config import _facade_alias as _interop_facade_alias
 
 
 class _Facade(_ModuleType):
-    """Gives `chython` itself a property, so `chython.clean2d_engine` forwards both the read and the
-    write to its one home in `depict/_config.py` and the setter validates the name on the spot.
+    """Gives `chython` itself properties, so `chython.clean2d_engine` and `chython.chain_layout` (alias
+    `chython.peptide_layout`) forward both the read and the write to their one home in `depict/_config.py`,
+    validated on the spot.
     """
     @property
     def clean2d_engine(self) -> Clean2DEngine:
@@ -56,6 +57,22 @@ class _Facade(_ModuleType):
     def clean2d_engine(self, engine: Clean2DEngine):
         set_clean2d_engine(engine)
 
+    @property
+    def chain_layout(self) -> bool:
+        return get_chain_layout()
+
+    @chain_layout.setter
+    def chain_layout(self, flag: bool):
+        set_chain_layout(flag)
+
+    @property
+    def peptide_layout(self) -> bool:
+        return get_peptide_layout()
+
+    @peptide_layout.setter
+    def peptide_layout(self, flag: bool):
+        set_peptide_layout(flag)
+
 
 _modules[__name__].__class__ = _Facade
 

{chython-3.3.2 → chython-3.5}/chython/chemistry/__init__.py

@@ -49,6 +49,7 @@ from ._salts import ComponentRow, DEFAULT_STABILIZER_CLASSES, SaltComposition, d
 from ._saturate import saturate
 from ._smarts import SmartsSyntaxError, compile_smarts
 from ._standardize import LogRecord, standardize
+from ._stereo_audit import Fix, Finding, StereoAudit, audit_stereo
 from ._tables import (ACID_ROLES, AbbreviationRow, AcidRow, Endpoint, RESONANCE_ROLES, Rule,
                       SALT_CLASSES, SALT_MATCHES, SaltRow, abbreviation_row, abbreviations_rows,
                       acids_rules, acids_rules_by_role, acids_table_text, groups_rules,
@@ -56,6 +57,7 @@ from ._tables import (ACID_ROLES, AbbreviationRow, AcidRow, Endpoint, RESONANCE_
                       resonance_table_text, salts_rows, salts_rows_by_klass, salts_species_keys,
                       salts_table_text, standardize_rules)
 from ._tpsa import tpsa
+from ..core.monomers import PeptideBranch, Peptide, Residue, monomers
 from ..core._core import (_set_canonicalize_fn, _set_featurizer_fns, _set_hydrogens_fns,
                           _set_isomers_fn, _set_kekule_form_fn, _set_protomers_fn,
                           _set_resonance_fn, _set_salts_fns, _set_standardize_fn,
@@ -63,13 +65,14 @@ from ..core._core import (_set_canonicalize_fn, _set_featurizer_fns, _set_hydrog
 
 
 __all__ = ['ACID_ROLES', 'AbbreviationRow', 'ComponentRow', 'DEFAULT_STABILIZER_CLASSES',
-           'LogRecord', 'SALT_CLASSES', 'SALT_MATCHES', 'SaltComposition',
-           'abbreviation_row', 'abbreviations_rows', 'alert_count',
+           'Finding', 'Fix', 'LogRecord', 'Peptide', 'PeptideBranch', 'Residue',
+           'SALT_CLASSES', 'SALT_MATCHES', 'SaltComposition', 'StereoAudit',
+           'abbreviation_row', 'abbreviations_rows', 'alert_count', 'audit_stereo',
            'calc_implicit', 'canonicalize', 'check_valence', 'crippen_logp', 'crippen_mr',
            'decompose_salts', 'expand_abbreviations', 'explicify_hydrogens', 'fix_resonance',
            'hydrogen_bond_acceptors_count',
            'hydrogen_bond_donors_count', 'implicify_hydrogens', 'maccs_bit_set', 'maccs_keys',
-           'neutralize', 'perceive_bonds', 'pharmacophore_invariants', 'qed', 'qed_properties',
+           'monomers', 'neutralize', 'perceive_bonds', 'pharmacophore_invariants', 'qed', 'qed_properties',
            'rotatable_bonds_count',
            'saturate', 'split_salts', 'standardize', 'standardize_isomers',
            'standardize_kekule', 'tpsa']

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

@@ -19,9 +19,9 @@
 """`canonicalize()` -- the pre-pass that makes `canonical_bytes` a compound identity rather than a
 drawing identity, so equal compounds hash equal and a corpus deduplicates by hash.  The stage order
 is a correctness constraint, not taste: `kekule()`, `validate_stereo()`, `standardize()`,
-`implicify_hydrogens()`, `neutralize()`, `standardize_kekule()`, `thiele()`, `standardize_isomers()`, and
-`kekule()` again only under `keep_kekule=True`.  Each ordering pair is justified at its numbered step
-below.
+`implicify_hydrogens()`, `neutralize()`, `standardize_kekule()`, `thiele()`, `standardize_isomers()`,
+`kekule()` again only under `keep_kekule=True`, and `canonicalize_stereo_groups()`.  Each ordering pair
+is justified at its numbered step below.
 
 The order alone is not enough, because the last stage can unblock the third one: a `tautomer` row
 wanting a free ring nitrogen cannot fire while the mobile hydrogen sits on it, and the placement is
@@ -48,8 +48,46 @@ _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(canonical=True).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(canonical=True)
+        return True
+    return False
+
+
 def canonicalize(molecule: MoleculeContainer, *, fix_tautomers: bool = True,
-                 keep_kekule: bool = False) -> bool:
+                 keep_kekule: bool = False, stereo_groups: bool = True,
+                 recover_racemate: bool = False) -> bool:
     """Bring `molecule` to the representation two drawings of one compound share.  Did it change?
 
     Run before deduplicating by `canonical_bytes`, `__hash__` or `__eq__`, which otherwise answer "same
@@ -61,7 +99,10 @@ def canonicalize(molecule: MoleculeContainer, *, fix_tautomers: bool = True,
     (`Oc1ccccn1` and `O=c1cccc[nH]1` stop hashing equal); it deliberately does not reach
     `standardize_isomers()`, which picks between two valid annular forms rather than repairing one.
     `keep_kekule=True` costs a second kekulisation rather than a skipped `thiele()`, the placement stage
-    needing the aromatic form.
+    needing the aromatic form.  `stereo_groups=False` skips step 11 and keeps the stored collection
+    labels and AND phases, which a reaction needs for a collection joined across its arrow.
+    `recover_racemate` is forwarded to `validate_stereo()`: a bridgehead pair no bicycle realises is then
+    read as the racemate instead of cleared.
 
     CHARGES ARE PAIRED OFF, not preserved atom by atom: glycine's zwitterion and its neutral drawing
     share a key, because step 5 runs `neutralize()`.  `neutralize()` leaves the NET charge untouched, so
@@ -95,7 +136,11 @@ def canonicalize(molecule: MoleculeContainer, *, fix_tautomers: bool = True,
     #    Nothing is recorded here about `result.unresolved`: the kekuliser writes a `LOST` record per
     #    system to `molecule.log` itself, naming it in `atoms`, so a second one here would summarise an
     #    event already reported.  `check_valence()` is still how those atoms are found.
-    molecule.kekule()
+    #    Canonically, so the group rules see one form of the compound whatever the atom order.  A drawing
+    #    already in a Kekule form is aromatised first, or the rules would read whichever form was drawn:
+    #    the two Kekule drawings of HBTU's benzotriazole oxide repair to two resonance forms.
+    molecule.thiele()
+    molecule.kekule(canonical=True)
 
     # 2. Drop the parities the constitution does not justify, on the localised form and before step 6
     #    hides a bond order behind an aromatic one.  A cis/trans sign on a double bond an alternating
@@ -103,28 +148,34 @@ def canonicalize(molecule: MoleculeContainer, *, fix_tautomers: bool = True,
     #    `canonical_bytes` whether or not the unit is stereogenic -- so the two bond-shift drawings of
     #    1,2-dimethylcyclooctatetraene keep two keys until it is gone.  The report is not recorded: the
     #    parities it names are the reader's own input and `validate_stereo()` returns them to a caller
-    #    that wants them.
-    molecule.validate_stereo()
+    #    that wants them.  A coupled bridgehead set signed as no bicycle is built is cleared, or with
+    #    `recover_racemate` read as the racemate its drawer most likely meant.
+    molecule.validate_stereo(recover_racemate=recover_racemate)
 
-    # 3. Repair the drawing.
-    standardize(molecule, fix_tautomers=fix_tautomers)
-
-    # 4. Explicit hydrogens are a `canonical_bytes` difference, so they have to go.
+    # 3. Explicit hydrogens are a `canonical_bytes` difference, so they have to go -- before step 4,
+    #    whose rows read implicit counts and move no hydrogen atom: `[H]Oc1ccncc1` would flip to the
+    #    4-pyridone with its hydrogen atom still on the oxygen.
     implicify_hydrogens(molecule)
 
+    # 4. Repair the drawing.
+    repaired = standardize(molecule, fix_tautomers=fix_tautomers)
+
     # 5. Pair off the charges an acid/base row can pair off, so a zwitterion and its neutral drawing
-    #    hash equal.  AFTER step 4, because `acids.tsv` reads implicit hydrogens: a cation drawn with
+    #    hash equal.  AFTER step 3, because `acids.tsv` reads implicit hydrogens: a cation drawn with
     #    hydrogen ATOMS is invisible to it until they have been folded in.  `keep_charge` stays at its
     #    default -- the net charge is part of the compound, so a canonical form may move a proton but
     #    never create or destroy one.  A quaternary ammonium keeps its counterion: it has no proton to
-    #    give, so the pass finds no donor and declines.
-    neutralize(molecule)
+    #    give, so the pass finds no donor and declines.  A repair or a pairing moves bonds and hydrogens
+    #    step 2 judged, so it is asked again: a parity a moved hydrogen leaves on an alternating cycle
+    #    would be dropped by the next canonicalisation, and the first answer would not be a fixed point.
+    if neutralize(molecule) | repaired:
+        molecule.validate_stereo(recover_racemate=recover_racemate)
 
     # 6. Which Kekule form, decided before step 7 reads one.  `thiele()` refuses a candidate ring whose
     #    atom holds its double bond outside the ring, so a compound with several Kekule forms has one
     #    aromatic form per form until this stage picks between them; a ring too big for `thiele()` to
     #    consider gets a canonical alternation here instead, nothing later collapsing its two.  AFTER
-    #    step 3, whose group rules are written against the orders the drawing carried, and after step 2,
+    #    step 4, whose group rules are written against the orders the drawing carried, and after step 2,
     #    whose parities would otherwise pin the very bond this stage moves.
     standardize_kekule(molecule)
 
@@ -142,32 +193,40 @@ def canonicalize(molecule: MoleculeContainer, *, fix_tautomers: bool = True,
 
     # 9. Steps 3 to 8 again, while the placement keeps unblocking a repair.  `Oc1[nH]cnc2nncc1-2` is
     #    the shape: its mobile hydrogen sits on the one ring nitrogen the hydroxy-azine rows need free,
-    #    so step 3 declines, and by the time step 8 has moved it the repair is behind us -- the drawing
+    #    so step 4 declines, and by the time step 8 has moved it the repair is behind us -- the drawing
     #    kept its hydroxy form and the same compound drawn the other way got the oxo form and a
     #    different key.  Only the placement is re-entered from, since it is the one stage that can put
     #    the molecule back into a shape an earlier stage would have acted on.
     #
     #    `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 4 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.
+    #    Step 2 is re-entered every round, on the localised form ahead of step 6: the placement moved a
+    #    hydrogen, and which double bonds an alternating cycle can move depends on where it sits.
+    #
+    #    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(canonical=True)
+        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)
+        molecule.validate_stereo(recover_racemate=recover_racemate)     # the placement moved a hydrogen
         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 '
@@ -178,8 +237,14 @@ def canonicalize(molecule: MoleculeContainer, *, fix_tautomers: bool = True,
     # 10. `keep_kekule` undoes step 7 rather than skipping it: skipping 7 would skip 8 with it, and the
     #     flag would then decide which tautomer the caller gets.  Step 6 is not re-run behind it and
     #     would have nothing to do: an aromatic ring is unwound into a ring holding every double bond it
-    #     has room for, and which of its alternations comes back is the kekuliser's answer to give.
+    #     has room for, and which of its alternations comes back is the kekuliser's answer to give --
+    #     canonical, so the flag keeps the guarantee.
     if keep_kekule:
-        molecule.kekule()
+        molecule.kekule(canonical=True)
+
+    # 11. Store the collections the canonical SMILES states: dead labels dropped, canonical ids, each AND
+    #     collection in its canonical phase.  Last, because every stage above can move a parity or a
+    #     unit.  `canonical_bytes` does not see it, so its answer is ORed in.
+    grouped = stereo_groups and molecule.canonicalize_stereo_groups()
 
-    return molecule.canonical_bytes != before
+    return molecule.canonical_bytes != before or grouped

{chython-3.3.2 → chython-3.5}/chython/chemistry/_hydrogens.py

@@ -92,13 +92,31 @@ def _plan(molecule: MoleculeContainer, log):
         doomed.append(n)
         counts[other] = current + 1
 
-    # Read every affected anchor's parity now.  `delete_atom` clears it, and it cannot be read back
-    # from inside the session.
-    parities: dict[int, int] = {}
-    for n in counts:
-        p = molecule.parity_of(n)
-        if p:
-            parities[n] = p
+    # Read every affected anchor's configuration now, in a direction order that already puts each doomed
+    # hydrogen where the implicit direction will be: last in its group, the whole frame for a centre and
+    # its own pair for a bond unit.  `delete_atom` clears the parity, and the unit's refs after the fold
+    # are not the refs before it, so a verbatim copy of the byte inverts the centre whenever the move is
+    # an odd permutation -- `[2H][C@@]([H])(Cl)Br` folded to the enantiomer of `[H][C@]([2H])(Cl)Br`.
+    gone = frozenset(doomed)
+    parities: dict[int, tuple[int, tuple]] = {}
+    for u in molecule.stereo_units():
+        n = u['anchor']
+        if n not in counts or not molecule.parity_of(n):
+            continue
+        refs = u['refs']
+        groups = [refs] if u['kind'] == 0 else [refs[:2], refs[2:]]
+        before, after = [], []
+        for group in groups:
+            kept = [r for r in group if r not in gone]
+            dropped = [r for r in group if r in gone]
+            before.extend(kept + dropped)
+            after.extend(kept + [None] * len(dropped))
+        if sum(r is None for r in after) > 1:
+            continue                    # two unnamed directions: no configuration survives the fold
+        try:
+            parities[n] = (molecule.translate_stereo(n, tuple(before)), tuple(after))
+        except ValueError:              # a kind whose refs are not read in these groups: as stored
+            parities[n] = (molecule.parity_of(n), None)
     return doomed, counts, parities
 
 
@@ -129,10 +147,12 @@ def _implicify_apply(molecule, doomed, counts, parities):
             molecule.delete_atom(n)
         for n, total in counts.items():
             molecule.set_hydrogens(n, total)
-        for n, p in parities.items():
-            # restore what `delete_atom` cleared, verbatim: without this, deleting the explicit
-            # hydrogen of `F[C@]([H])(Cl)Br` racemises the centre.
-            molecule.set_parity(n, p)
+    if parities:
+        # restore what `delete_atom` cleared, in the order `_plan` read it: a second session, since
+        # `order=` reads the frame and the first one changed the graph
+        with molecule.edit():
+            for n, (p, order) in parities.items():
+                molecule.set_parity(n, p, order=order)
 
 
 def explicify_hydrogens(molecule: MoleculeContainer) -> int: