chython 2.4__cp312-cp312-win_amd64.whl

chython/reactor/scaffold.py

@@ -0,0 +1,122 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2024 Ramil Nugmanov <nougmanoff@protonmail.com>
+#  This file is part of chython.
+#
+#  chython is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation; either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#  GNU Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program; if not, see <https://www.gnu.org/licenses/>.
+#
+from .. import smarts, MoleculeContainer
+from .transformer import Transformer
+
+"""
+Predefined transformers for common reactive groups cleavage.
+"""
+
+_alcohol = (
+    ('[O;D1;z1;x0][C;z1;x1:1]', '[A:1]',  # rule
+     'CCO', 'CC',  # match test
+     'c1ccccc1O'),  # false-match test
+)
+
+_phenol = (
+    ('[O;D1;z1;x0][C;a:1]', '[A:1]', 'c1ccccc1O', 'c1ccccc1', 'CCO'),
+)
+
+_chloro_aryl = (
+    ('[Cl;D1;z1;x0][C;a:1]', '[A:1]', 'c1ccccc1Cl', 'c1ccccc1', 'c1ccccc1Br', 'CCCl'),
+)
+
+_bromo_aryl = (
+    ('[Br;D1;z1;x0][C;a:1]', '[A:1]', 'c1ccccc1Br', 'c1ccccc1', 'c1ccccc1I', 'CCBr'),
+)
+
+_iodo_aryl = (
+    ('[I;D1;z1;x0][C;a:1]', '[A:1]', 'c1ccccc1I', 'c1ccccc1', 'c1ccccc1Cl', 'CCI'),
+)
+
+_chloro_alkyl = (
+    ('[Cl;D1;z1;x0][C;x1;z1:1]', '[A:1]', 'CCCl', 'CC', 'c1ccccc1Cl'),
+)
+
+_bromo_alkyl = (
+    ('[Br;D1;z1;x0][C;x1;z1:1]', '[A:1]', 'CCBr', 'CC', 'c1ccccc1Br'),
+)
+
+_iodo_alkyl = (
+    ('[I;D1;z1;x0][C;x1;z1:1]', '[A:1]', 'CCI', 'CC', 'c1ccccc1I'),
+)
+
+_carboxy = (
+    ('[O;D1;z1;x0][C;D3;!R;x2;z2](=[O;D1])[C:1]', '[A:1]', 'CCC(=O)O', 'CC'),
+)
+
+_chloro_anhydride = (
+    ('[Cl;D1;z1;x0][C;D3;!R;x2;z2](=[O;D1])[C:1]', '[A:1]', 'CCC(=O)Cl', 'CC'),
+)
+
+_amine_primary = (
+    ('[N;D1;z1;x0][C;x1;z1:1]', '[A:1]', 'CCN', 'CC', 'CNC'),
+    ('[N;D1;z1;x0][C;a:1]', '[A:1]', 'c1ccccc1N', 'c1ccccc1', 'c1ccccc1NC'),
+)
+
+#################
+# Magic Factory #
+#################
+
+_groups = [k[1:] for k, v in globals().items() if k.startswith('_') and isinstance(v, tuple) and v]
+__all__ = ['apply_all'] + _groups
+_cache = {}
+
+
+def _prepare_reactor(rules, name):
+    rxn = [Transformer(smarts(r), smarts(p)) for r, p, *_ in rules]
+
+    def w(molecule: MoleculeContainer, /) -> MoleculeContainer:
+        """
+        Remove reactive groups from the given molecule if applicable.
+        """
+        for r in rxn:
+            while True:
+                try:
+                    molecule = next(r(molecule))
+                except StopIteration:
+                    break
+        return molecule
+
+    w.__module__ = __name__
+    w.__qualname__ = w.__name__ = name
+    return w
+
+
+def apply_all(molecule: MoleculeContainer, /) -> MoleculeContainer:
+    """
+    Remove all found reactive groups from the given molecule.
+    """
+    for name in _groups:
+        molecule = __getattr__(name)(molecule)
+    return molecule
+
+
+def __getattr__(name):
+    try:
+        return _cache[name]
+    except KeyError:
+        if name in _groups:
+            _cache[name] = t = _prepare_reactor(globals()[f'_{name}'], name)
+            return t
+        raise AttributeError
+
+
+def __dir__():
+    return __all__

chython/reactor/test/__init__.py

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2022 Ramil Nugmanov <nougmanoff@protonmail.com>
+#  This file is part of chython.
+#
+#  chython is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation; either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#  GNU Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program; if not, see <https://www.gnu.org/licenses/>.
+#

chython/reactor/test/test_deprotection.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2022-2024 Ramil Nugmanov <nougmanoff@protonmail.com>
+#  This file is part of chython.
+#
+#  chython is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation; either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#  GNU Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program; if not, see <https://www.gnu.org/licenses/>.
+#
+from chython import smiles, smarts, Transformer
+from chython.reactor import deprotection
+from itertools import product
+
+
+def test_deprotection():
+    qs = set()
+    ts = set()
+    for x in dir(deprotection):
+        if x == 'apply_all':
+            continue
+        for r in getattr(deprotection, '_' + x):
+            if len(r) > 2:  # has test
+                q, p, t, a, *bs = r
+                t = smiles(t)
+                t.canonicalize()
+                q = smarts(q)
+                qs.add(q)
+                ts.add(t)
+                a = smiles(a)
+                a.canonicalize()
+                # test match
+                assert q < t, f'{x}: {q} !< {t}'
+                o = next(Transformer(q, smarts(p))(t))
+                assert o == a, f'{x}: {o} != {a}'
+                for b in bs:
+                    b = smiles(b)
+                    b.canonicalize()
+                    assert not q < b, f'{x}: {q} < {b}'
+
+    # test rule-test is unique pair
+    assert len(qs) == len(ts)
+
+    m = 0
+    for q, t in product(qs, ts):
+        m += q < t
+
+    # test selectivity of rules
+    assert len(qs) == m

chython/reactor/test/test_reactor.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2025 Ramil Nugmanov <nougmanoff@protonmail.com>
+#  This file is part of chython.
+#
+#  chython is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation; either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#  GNU Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program; if not, see <https://www.gnu.org/licenses/>.
+#
+from chython import smiles, smarts, Reactor
+from pytest import mark
+
+
+data = [
+    (('[B;D3;x2;z1:4]([O:5])([O:6])-[C;@@;h1:3]1([O;M][C;M]1)', '[Cl,Br,I;D1:1]-[C;a:2]'), ('[A;@:3]-[A:2]',),
+     ('CC1O[C@@H]1B(O)O', 'Brc1ccccc1'), ('CC1O[C@H]1c1ccccc1',)),  # inverse stereo check
+    (('[B;D3;x2;z1:4]([O:5])([O:6])-[C;@@;h1:3]1([O;M][C;M]1)', '[Cl,Br,I;D1:1]-[C;a:2]'), ('[A;@@:3]-[A:2]',),
+     ('CC1O[C@@H]1B(O)O', 'Brc1ccccc1'), ('CC1O[C@@H]1c1ccccc1',)),  # keep stereo on RC
+    (('[B;D3;x2;z1:4]([O:5])([O:6])-[C;@@;h1:3]1([O;M][C;M]1)', '[Cl,Br,I;D1:1]-[C;a:2]'), ('[A:3]-[A:2]',),
+     ('CC1O[C@@H]1B(O)O', 'Brc1ccccc1'), ('CC1OC1c1ccccc1',)),  # drop stereo on RC
+]
+
+
+@mark.parametrize('patterns, products, source, result', data)
+def test_transformer(patterns, products, source, result):
+    for q, m in zip(patterns, source):
+        assert smarts(q) <= smiles(m)
+
+    reactor = Reactor([smarts(x) for x in patterns], [smarts(x) for x in products])
+    out = {format(smiles(x), 'h') for x in result}
+    assert {format(x, 'h') for x in next(reactor(*(smiles(x) for x in source))).products} == out

chython/reactor/test/test_scaffold.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2024 Ramil Nugmanov <nougmanoff@protonmail.com>
+#  This file is part of chython.
+#
+#  chython is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation; either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#  GNU Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program; if not, see <https://www.gnu.org/licenses/>.
+#
+from chython import smiles, smarts, Transformer
+from chython.reactor import scaffold
+from itertools import product
+
+
+def test_scaffold():
+    qs = set()
+    ts = set()
+    for x in dir(scaffold):
+        if x == 'apply_all':
+            continue
+        for r in getattr(scaffold, '_' + x):
+            if len(r) > 2:  # has test
+                q, p, t, a, *bs = r
+                t = smiles(t)
+                t.canonicalize()
+                q = smarts(q)
+                qs.add(q)
+                ts.add(t)
+                a = smiles(a)
+                a.canonicalize()
+                # test match
+                assert q < t, f'{x}: {q} !< {t}'
+                o = next(Transformer(q, smarts(p))(t))
+                assert o == a, f'{x}: {o} != {a}'
+                for b in bs:
+                    b = smiles(b)
+                    b.canonicalize()
+                    assert not q < b, f'{x}: {q} < {b}'
+
+    # test rule-test is unique pair
+    assert len(qs) == len(ts)
+
+    m = 0
+    for q, t in product(qs, ts):
+        m += q < t
+
+    # test selectivity of rules
+    assert len(qs) == m

chython/reactor/test/test_transformer.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2025 Ramil Nugmanov <nougmanoff@protonmail.com>
+#  This file is part of chython.
+#
+#  chython is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation; either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#  GNU Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program; if not, see <https://www.gnu.org/licenses/>.
+#
+from chython import smiles, smarts, Transformer
+from pytest import mark
+
+
+data = [
+    ('[C:1]Br', '[A:1][O;M]', 'C[C@H](OC)CBr', 'C[C@H](OC)CO'),  # keep stereo out of match
+    ('[C:2][C:1]Br', '[A:2][A:1][O;M]', 'C[C@H](OC)CBr', 'C[C@H](OC)CO'),  # keep stereo inside match
+    ('[C;M][C;@;h1:1]([O;M])[N;M]', '[A;@@:1]', 'CC[C@H](O)N', 'CC[C@@H](O)N'),  # inversion of stereo
+    ('[C:1]Br', '[A:1][O;M]', 'C/C=C/CBr', 'C/C=C/CO'),  # keep stereo out of match
+    ('[C:1]Br', '[A:1][O;M]', 'CC=[C@]=CCBr', 'CC=[C@]=CCO'),  # keep
+    ('[C:1]Br', '[A:1][O;M]', 'CC=[C@]=CBr', 'CC=C=CO'),  # drop stereo on RC
+    ('[C:1]Br', '[A:1][O;M]', 'C/C=C/Br', 'CC=CO'),  # drop stereo on RC
+]
+
+
+@mark.parametrize('pattern, replacement, source, result', data)
+def test_transformer(pattern, replacement, source, result):
+    transformer = Transformer(smarts(pattern), smarts(replacement))
+
+    mol = smiles(source)
+    out = {format(smiles(x), 'h') for x in ([result] if isinstance(result, str) else result)}
+    assert {format(x, 'h') for x in transformer(mol)} == out

chython/reactor/transformer.py

@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2014-2024 Ramil Nugmanov <nougmanoff@protonmail.com>
+#  Copyright 2019 Adelia Fatykhova <adelik21979@gmail.com>
+#  This file is part of chython.
+#
+#  chython is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation; either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#  GNU Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program; if not, see <https://www.gnu.org/licenses/>.
+#
+from typing import Union
+from .base import BaseReactor
+from ..containers import QueryContainer, MoleculeContainer
+
+
+class Transformer(BaseReactor):
+    """
+    Editor for molecules.
+    generates modified molecules from input molecule using template.
+    Transformer calling returns generator of all possible replacements.
+    """
+    def __init__(self, pattern: QueryContainer, replacement: Union[MoleculeContainer, QueryContainer],
+                 delete_atoms: bool = True, automorphism_filter: bool = True, fix_aromatic_rings: bool = True,
+                 fix_tautomers: bool = True, copy_metadata: bool = False):
+        """
+        :param pattern: Search pattern.
+        :param replacement: Resulted structure.
+        :param delete_atoms: If True atoms exists in reactants but not exists in products will be removed.
+        :param fix_aromatic_rings: Proceed kekule and thiele on products.
+        :param fix_tautomers: See `thiele()` docs.
+        :param automorphism_filter: Skip matches to same atoms.
+        :param copy_metadata: Copy metadata from structure to transformed
+        """
+        if not isinstance(pattern, QueryContainer) or not isinstance(replacement, (MoleculeContainer, QueryContainer)):
+            raise TypeError('invalid params')
+
+        self._pattern = pattern
+        self._automorphism_filter = automorphism_filter
+        self._copy_metadata = copy_metadata
+        super().__init__(pattern, replacement, delete_atoms, fix_aromatic_rings, fix_tautomers)
+
+    def __call__(self, structure: MoleculeContainer):
+        if not isinstance(structure, MoleculeContainer):
+            raise TypeError('only Molecules possible')
+
+        for mapping in self._pattern.get_mapping(structure, automorphism_filter=self._automorphism_filter):
+            transformed = self._patcher(structure, mapping)
+            if self._copy_metadata:
+                transformed.meta.update(structure.meta)
+            yield transformed
+
+
+__all__ = ['Transformer']

chython/utils/__init__.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2019-2025 Ramil Nugmanov <nougmanoff@protonmail.com>
+#  This file is part of chython.
+#
+#  chython is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation; either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#  GNU Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program; if not, see <https://www.gnu.org/licenses/>.
+#
+from importlib.util import find_spec
+from .free_wilson import *
+from .grid import *
+from .retro import *
+from .svg import *
+from ..containers.graph import Graph
+
+
+_patched = False
+
+
+def patch_pandas():
+    """
+    Fix pandas molecules representation.
+    """
+    # prevent recursive patching
+    global _patched
+    if _patched:
+        return
+    _patched = True
+
+    from pandas.io.formats import printing
+    from pandas.io.formats.printing import is_sequence
+
+    def w(obj):
+        if isinstance(obj, Graph):
+            return False
+        return is_sequence(obj)
+
+    printing.is_sequence = w
+
+
+__all__ = ['fw_prepare_groups', 'fw_decomposition_tree',
+           'grid_depict', 'GridDepict', 'retro_depict', 'RetroDepict', 'svg2png', 'patch_pandas']
+
+
+if find_spec('rdkit'):
+    from .rdkit import *
+    __all__.extend(['from_rdkit_molecule', 'to_rdkit_molecule'])

chython/utils/free_wilson.py

@@ -0,0 +1,114 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2022-2024 Ramil Nugmanov <nougmanoff@protonmail.com>
+#  This file is part of chython.
+#
+#  chython is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation; either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#  GNU Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program; if not, see <https://www.gnu.org/licenses/>.
+#
+from itertools import product
+from typing import Union, List
+from .retro import Tree
+from ..containers import MoleculeContainer, QueryContainer
+from ..periodictable import H
+
+
+def fw_prepare_groups(core: Union[MoleculeContainer, QueryContainer], molecule: MoleculeContainer) -> \
+       List[MoleculeContainer]:
+    """
+    Prepare list of core with connected groups. Hydrogens added to groups for marking connection point.
+    Hydrogens have isotope marks equal to mapping of core atoms.
+    Groups connected multiple times (rings) - contains multiple hydrogens.
+
+    :param core: core structure for searching
+    :param molecule: target structure
+    """
+    try:
+        core_map = next(core.get_mapping(molecule))
+    except StopIteration:
+        return []
+
+    reverse = {v: k for k, v in core_map.items()}
+    cs = set(core_map.values())
+    groups = molecule.substructure(molecule._atoms.keys() - cs, recalculate_hydrogens=False)
+    gs = set(groups)
+
+    cf = molecule.substructure(cs, recalculate_hydrogens=False)
+
+    for n, m, b in molecule.bonds():
+        if n in cs:
+            if m in gs:
+                a = molecule.atom(n)
+                h = H(x=a.x, y=a.y)
+                h._isotope = reverse[n]  # mark mapping to isotope
+                groups.add_bond(groups.add_atom(h, _skip_calculation=True), m, b.copy(), _skip_calculation=True)
+
+                a = molecule.atom(m)
+                h = H(x=a.x, y=a.y)
+                h._isotope = reverse[n]  # mark mapping to isotope
+                cf.add_bond(cf.add_atom(h, _skip_calculation=True), n, b.copy(), _skip_calculation=True)
+        elif m in cs and n in gs:
+            a = molecule.atom(m)
+            h = H(x=a.x, y=a.y)
+            h._isotope = reverse[m]
+            groups.add_bond(groups.add_atom(h, _skip_calculation=True), n, b.copy(), _skip_calculation=True)
+
+            a = molecule.atom(n)
+            h = H(x=a.x, y=a.y)
+            h._isotope = reverse[m]  # mark mapping to isotope
+            cf.add_bond(cf.add_atom(h.copy(), _skip_calculation=True), n, b.copy(), _skip_calculation=True)
+    groups = groups.split()
+    groups.insert(0, cf)
+    return groups
+
+
+def fw_decomposition_tree(groups: List[MoleculeContainer]) -> Tree:
+    assert len(groups) == len(set(groups))
+
+    pred = {}  # directed graph from substructures to superstructures
+    succ = {}
+    for m in groups:
+        pred[m] = set()
+        succ[m] = set()
+
+    for m in groups:
+        for n in groups:
+            if m < n:
+                pred[n].add(m)
+                succ[m].add(n)
+
+    # break triangles
+    scope = {m for m, ns in succ.items() if len(ns) > 1}
+    while scope:
+        m = sorted(scope, key=lambda x: len(pred[x]))[0]
+        s = succ[m]
+        scope.discard(m)
+        while True:
+            for x, y in product((x for x in s if succ[x]), (x for x in s if len(pred[x]) > 1)):
+                if y in succ[x]:
+                    s.discard(y)
+                    pred[y].discard(m)
+                    break
+            else:
+                break
+
+    def _rec_tree(x):
+        return x, [_rec_tree(y) for y in succ[x]]
+
+    m = MoleculeContainer()
+    m.add_atom('H')
+
+    return m, [_rec_tree(x) for x, p in pred.items() if not p]
+
+
+__all__ = ['fw_prepare_groups', 'fw_decomposition_tree']