chython 2.4__cp312-cp312-win_amd64.whl

chython/reactor/reactions/ufe.py

@@ -0,0 +1,99 @@
+# -*- 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 typing import Iterator
+from ._amidation import template as amidation_template
+from ._amine_isocyanate import template as amine_isocyanate_template
+from ._buchwald_hartwig import template as buchwald_hartwig_template
+from ._esterification import template as esterification_template
+from ._macmillan import template as macmillan_template
+from ._reductive_amination import template as reductive_amination_template
+from ._sonogashira import template as sonogashira_template
+from ._sulfonamidation import template as sulfonamidation_template
+from ._suzuki_miyaura import template as suzuki_miyaura_template
+from ..transformer import Transformer
+from ... import MoleculeContainer, smarts
+from ...periodictable import At
+
+
+__all__ = ['PreparedUFE']
+__all__.extend(k[:-9] for k, v in globals().items() if k.endswith('_template') and isinstance(v, dict) and v)
+_cache = {}
+
+
+class TransformerWrapper:
+    def __init__(self, query, transformation, name):
+        if isinstance(transformation, str):
+            self.transformer = Transformer(smarts(query), smarts(transformation), copy_metadata=True,
+                                           fix_aromatic_rings=False, fix_tautomers=False)
+        else:
+            self.query = smarts(query)
+            self.mapping = transformation
+            self.transformer = None
+        self.name = name
+
+    def __call__(self, molecule: MoleculeContainer) -> Iterator[MoleculeContainer]:
+        if self.transformer is None:
+            for mapping in self.query.get_mapping(molecule):
+                n = mapping[self.mapping]
+                copy = molecule.copy()
+                copy._atoms[n].__class__ = At  # ad-hoc for masking leaving group
+                copy._hydrogens[n] = 0
+                copy.meta[self.name] = n
+                yield copy
+        else:
+            for copy in self.transformer(molecule):
+                copy.meta[self.name] = max(copy)
+                yield copy
+
+
+class PreparedUFE:
+    def __init__(self, rules, name):
+        self.name = name
+        self.rules = rules
+        self.transformations = []
+
+        for n, rule in enumerate(rules['templates']):
+            for g in 'AB':
+                for s in rule[g]:
+                    t = TransformerWrapper(s, rule['ufe'][g], f'{name}_{g}{n}')
+                    self.transformations.append(t)
+
+    def __call__(self, molecule: MoleculeContainer) -> Iterator[MoleculeContainer]:
+        for transformer in self.transformations:
+            yield from transformer(molecule)
+
+    def __repr__(self):
+        return f'{__name__}.{self.name}'
+
+    def __str__(self):
+        return f'UFE<{self.rules["name"]}>'
+
+
+def __getattr__(name):
+    try:
+        return _cache[name]
+    except KeyError:
+        if name in __all__:
+            _cache[name] = t = PreparedUFE(globals()[f'{name}_template'], name)
+            return t
+        raise AttributeError
+
+
+def __dir__():
+    return __all__

chython/reactor/reactor.py

@@ -0,0 +1,170 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2019-2025 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 collections import deque
+from functools import reduce
+from itertools import count, permutations, combinations
+from logging import getLogger, INFO
+from operator import or_
+from typing import List, Iterator, Tuple, Union
+from .base import BaseReactor
+from .._functions import lazy_product
+from ..containers import QueryContainer, MoleculeContainer, ReactionContainer
+
+
+logger = getLogger('chython.reactor')
+logger.setLevel(INFO)
+
+
+class Reactor(BaseReactor):
+    """
+    Reactor for molecules transformations.
+    Generates reaction from input molecules using transformation template.
+
+    Reactor calling transforms reactants to products and
+    returns generator of reaction transformations with all
+    possible reactions.
+    """
+    def __init__(self, patterns: Tuple[QueryContainer, ...],
+                 products: Tuple[Union[MoleculeContainer, QueryContainer], ...], *,
+                 delete_atoms: bool = True, one_shot: bool = True, polymerise_limit: int = 10,
+                 automorphism_filter: bool = True, fix_aromatic_rings: bool = True, fix_tautomers: bool = True):
+        """
+        :param patterns: Search patterns for each reactant.
+        :param products: Resulted structures.
+        :param delete_atoms: If True atoms exists in reactants but not exists in products will be removed.
+        :param one_shot: Do only single reaction center then True, else do all possible combinations of reactions.
+        :param polymerise_limit: Limit of self reactions. Make sense than one_shot = False.
+        :param fix_aromatic_rings: Proceed kekule and thiele on products.
+        :param fix_tautomers: See `thiele()` docs.
+        :param automorphism_filter: Skip matches to same atoms.
+        """
+        if not patterns or not products:
+            raise ValueError('empty template')
+
+        if not all(isinstance(x, QueryContainer) for x in patterns):
+            raise TypeError('invalid params')
+        elif not all(isinstance(x, (QueryContainer, MoleculeContainer)) for x in products):
+            raise TypeError('invalid params')
+        self._patterns = patterns
+        self._products = products
+
+        self._one_shot = one_shot
+        self._polymerise_limit = polymerise_limit
+        self._products_atoms = tuple(set(m) for m in products)
+        self._automorphism_filter = automorphism_filter
+        super().__init__(reduce(or_, patterns), reduce(or_, products), delete_atoms, fix_aromatic_rings, fix_tautomers)
+
+    def __call__(self, *structures: MoleculeContainer):
+        if any(not isinstance(structure, MoleculeContainer) for structure in structures):
+            raise TypeError('only list of Molecules possible')
+
+        len_patterns = len(self._patterns)
+        structures = fix_mapping_overlap(structures)
+        s_nums = set(range(len(structures)))
+        seen = set()
+        if self._one_shot:
+            for chosen in permutations(s_nums, len_patterns):
+                ignored = [structures[x] for x in s_nums.difference(chosen)]
+                chosen = [structures[x] for x in chosen]
+                for new in self._single_stage(chosen, {x for x in ignored for x in x}):
+                    # store reacted molecules in same order as matched pattern
+                    r = ReactionContainer([x.copy() for x in chosen] + [x.copy() for x in ignored],
+                                          new + [x.copy() for x in ignored])
+                    if len(new) > 1:  # try to keep salts
+                        r.contract_ions()
+                    if str(r) in seen:
+                        continue
+                    seen.add(str(r))
+                    yield r
+        else:
+            queue = deque(([structures[x] for x in chosen], [structures[x] for x in s_nums.difference(chosen)], 0)
+                          for chosen in permutations(s_nums, len_patterns))
+            while queue:
+                chosen, ignored, depth = queue.popleft()
+                depth += 1
+                for new in self._single_stage(chosen, {x for x in ignored for x in x}):
+                    r = ReactionContainer([x.copy() for x in structures], new + [x.copy() for x in ignored])
+                    if len(new) > 1:
+                        r.contract_ions()  # try to keep salts
+                        if str(r) in seen:
+                            continue
+                        seen.add(str(r))
+                        if len(r.products) != len(ignored) + len(self._products_atoms):
+                            logger.info('ambiguous multicomponent structures. skip multistage processing')
+                            yield r
+                            continue
+                    elif str(r) in seen:
+                        continue
+                    else:
+                        seen.add(str(r))
+
+                    if depth < self._polymerise_limit:
+                        prod = r.products
+                        if len_patterns == 1:  # simple case. only products or ignored can be transformed.
+                            for i in range(len(prod)):
+                                queue.append(([prod[i]], [*prod[:i], *prod[i + 1:]], depth))
+                        else:  # one of products molecule combined with previously chosen
+                            for chp in combinations(chosen, len_patterns - 1):
+                                for i in range(len(prod)):
+                                    for ch in permutations(fix_mapping_overlap((prod[i], *chp)), len_patterns):
+                                        queue.append((ch, [*prod[:i], *prod[i + 1:]], depth))
+                    yield r
+
+    def _single_stage(self, chosen, ignored) -> Iterator[List[MoleculeContainer]]:
+        max_ignored_number = united_chosen = None
+        split = len(self._products_atoms) > 1
+        for match in lazy_product(*(x.get_mapping(y, automorphism_filter=self._automorphism_filter) for x, y in
+                                    zip(self._patterns, chosen))):
+            mapping = match[0].copy()
+            for m in match[1:]:
+                mapping.update(m)
+            if united_chosen is None:
+                united_chosen = reduce(or_, chosen)
+                max_ignored_number = max(ignored, default=0)
+            new = self._patcher(united_chosen, mapping)
+            collision = set(new).intersection(ignored)
+            if collision:
+                new.remap(dict(zip(collision, count(max(max_ignored_number, max(new)) + 1))))
+
+            if split:
+                yield new.split()
+            else:
+                yield [new]
+
+
+def fix_mapping_overlap(structures) -> List[MoleculeContainer]:
+    if len(structures) == 1:
+        return list(structures)
+    checked = []
+    checked_atoms = set()
+    for structure in structures:
+        intersection = set(structure).intersection(checked_atoms)
+        if intersection:
+            mapping = dict(zip(intersection, count(max(max(checked_atoms), max(structure)) + 1)))
+            structure = structure.copy()
+            structure.remap(mapping)
+            logger.info('some atoms in input structures had the same numbers.\n'
+                        f'atoms {list(mapping)} were remapped to {list(mapping.values())}')
+        checked_atoms.update(structure)
+        checked.append(structure)
+    return checked
+
+
+__all__ = ['Reactor', 'fix_mapping_overlap']

chython/reactor/retro/__init__.py

@@ -0,0 +1,77 @@
+# -*- 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 Reactor, ReactionContainer, smarts
+from typing import Iterator
+from ._amidation import template as amidation_template
+from ._aryl_amination import template as aryl_amination_template
+from ._mitsunobu import template as mitsunobu_template
+from ._sonogashira import template as sonogashira_template
+from ._suzuki_miyaura import template as suzuki_miyaura_template
+
+
+__all__ = ['PreparedReactor']
+__all__.extend(k[:-9] for k, v in globals().items() if k.endswith('_template') and isinstance(v, dict) and v)
+_cache = {}
+
+
+class PreparedReactor:
+    """
+    Prepared retrosynthetic reactors with predefined sets of templates.
+    """
+    def __init__(self, rules, name):
+        self.name = name
+        self.rules = rules
+
+        self.rxn = rxn = []
+        for tmp in rules['templates']:
+            p = smarts(tmp['product'])
+            rs = [smarts(x) for x in tmp['reactants']]
+            rxn.append(Reactor([p], rs, automorphism_filter=False))  # noqa
+
+    def __repr__(self):
+        return f'{__name__}.{self.name}'
+
+    def __str__(self):
+        return f'RetroReactor<{self.rules["name"]}>'
+
+    def __call__(self, molecule) -> Iterator[ReactionContainer]:
+        """
+        :param molecule: Product molecule
+        """
+        seen = set()
+        for rx in self.rxn:
+            for r in rx(molecule):
+                if str(r) in seen:
+                    continue
+                seen.add(str(r))
+                yield r
+
+
+def __getattr__(name):
+    try:
+        return _cache[name]
+    except KeyError:
+        if name in __all__:
+            _cache[name] = t = PreparedReactor(globals()[f'{name}_template'], name)
+            return t
+        raise AttributeError
+
+
+def __dir__():
+    return __all__

chython/reactor/retro/_amidation.py

@@ -0,0 +1,39 @@
+# -*- 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/>.
+#
+
+template = {
+    'name': 'Amidation reaction',
+    'description': 'Amide Coupling with Amines and Acids/Halo-Anhydrides',
+    'templates': [
+        {
+            'product': '[N;D2,D3;z1:1]-;!@[C;x2;z2:2]=[O;M]',  # any SP3 nitrogen with carboxy
+            'reactants': [
+                '[A:1]',
+                '[A:2]-[O;M]'
+            ]
+        },
+        {
+            'product': '[N;D2;z2;x0:1]-;!@[C;x2;z2:2]=[O;M]',  # C=N-C(=O)R
+            'reactants': [
+                '[A:1]',
+                '[A:2]-[O;M]'
+            ]
+        }
+    ]
+}

chython/reactor/retro/_aryl_amination.py

@@ -0,0 +1,32 @@
+# -*- 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/>.
+#
+
+template = {
+    'name': 'Aryl amination reaction',
+    'description': 'C-N coupling of halo-aryles and amines',
+    'templates': [
+        {
+            'product': '[N;D2,D3;z1:1]-;!@[C;a:2]',
+            'reactants': [
+                '[A:1]',
+                '[A:2]-[Br;M]'
+            ]
+        }
+    ]
+}

chython/reactor/retro/_mitsunobu.py

@@ -0,0 +1,49 @@
+# -*- 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/>.
+#
+
+template = {
+    'name': 'Mitsunobu reaction',
+    'description': 'Phenol-Alcohol Phenol-Acid Acid-Alcohol couplings',
+    'templates': [
+        {
+            # Ph-O-Alk
+            'product': '[O;D2;x0;z1:1](-;!@[C;a;M])[C;z1;x1:2]',
+            'reactants': [
+                '[A:1]',
+                '[A:2]-[O;M]'
+            ]
+        },
+        {
+            # Ac-O-Alk
+            'product': '[O;D2;x0;z1:1](-;!@[C;x2;z2;M]=[O;M])[C;z1;x1:2]',
+            'reactants': [
+                '[A:1]',
+                '[A:2]-[O;M]'
+            ]
+        },
+        {
+            # Ph-O-Ac
+            'product': '[O;D2;x0;z1:1](-;!@[C;D3;x2;z2:2]=[O;M])[C;a;M]',
+            'reactants': [
+                '[A:1]',
+                '[A:2]-[O;M]'
+            ]
+        }
+    ]
+}

chython/reactor/retro/_sonogashira.py

@@ -0,0 +1,49 @@
+# -*- 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/>.
+#
+
+template = {
+    'name': 'Sonogashira reaction',
+    'description': 'Alkyne Ar-X CSP2-X Ac-X couplings',
+    'templates': [
+        {
+            # Ar
+            'product': '[C;D2;x0;z3:1](-;!@[C;a:2])#[C;D2;x0;M]',
+            'reactants': [
+                '[A:1]',
+                '[A:2]-[Br;M]'
+            ]
+        },
+        {
+            # Ac
+            'product': '[C;D2;x0;z3:1](-;!@[C;D3;x1;z2:2]=[O;M])#[C;D2;x0;M]',
+            'reactants': [
+                '[A:1]',
+                '[A:2]-[Cl;M]'
+            ]
+        },
+        {
+            # CSP2
+            'product': '[C;D2;x0;z3:1](-;!@[C;x0;z2:2])#[C;D2;x0;M]',
+            'reactants': [
+                '[A:1]',
+                '[A:2]-[Br;M]'
+            ]
+        }
+    ]
+}

chython/reactor/retro/_suzuki_miyaura.py

@@ -0,0 +1,54 @@
+# -*- 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/>.
+#
+
+template = {
+    'name': 'Suzuki-Miyaura reaction',
+    'description': 'Ar-Ar Ar-CSP2 CSP2-CSP2 couplings',
+    'templates': [
+        {
+            'product': '[C;a;D3:1]-;!@[C;a:2]',
+            'reactants': [
+                '[A:1]-[B;M]([O;M])[O;M]',
+                '[A:2]-[Br;M]'
+            ]
+        },
+        {
+            'product': '[C;a;D3:1]-;!@[C;z2:2]=[C;M]',
+            'reactants': [
+                '[A:1]-[B;M]([O;M])[O;M]',
+                '[A:2]-[Br;M]'
+            ]
+        },
+        {
+            # reverse
+            'product': '[C;a;D3:1]-;!@[C;z2:2]=[C;M]',
+            'reactants': [
+                '[A:1]-[Br;M]',
+                '[A:2]-[B;M]([O;M])[O;M]'
+            ]
+        },
+        {
+            'product': '[C;D2,D3;z2:1](-;!@[C;z2:2]=[C;M])=[C;M]',
+            'reactants': [
+                '[A:1]-[B;M]([O;M])[O;M]',
+                '[A:2]-[Br;M]'
+            ]
+        }
+    ]
+}