chython 2.19__cp313-cp313-win_amd64.whl

chython/algorithms/tautomers/__init__.py

@@ -0,0 +1,167 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2020-2026 Ramil Nugmanov <nougmanoff@protonmail.com>
+#  Copyright 2020 Nail Samikaev <samikaevn@yandex.ru>
+#  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 collections.abc import Iterator
+from .acid_base import *
+from .heteroarenes import *
+from .keto_enol import *
+
+
+class Tautomers(AcidBase, HeteroArenes, KetoEnol):
+    """
+    Oxides and sulphides ignored.
+    """
+    __slots__ = ()
+
+    def enumerate_tautomers(self, *, prepare_molecules=True, zwitter=True,
+                            partial=False, increase_aromaticity=True, keep_sugars=True, heteroarenes=True,
+                            keto_enol=True, limit: int = 1000) -> Iterator['MoleculeContainer']:
+        """
+        Enumerate all possible tautomeric forms of molecule.
+
+        :param prepare_molecules: Standardize structures for correct processing
+        :param zwitter: Do zwitter-ions enumeration
+        :param partial: Allow OC=CC=C>>O=CCC=C or O=CC=CC>>OC=C=CC
+        :param increase_aromaticity: prevent aromatic ring destruction
+        :param keep_sugars: prevent carbonyl moving in sugars
+        :param heteroarenes: enumerate heteroarenes
+        :param keto_enol: enumerate keto-enols
+        :param limit: Maximum attempts count
+        """
+        if limit < 1:
+            raise ValueError('limit should be greater or equal 1')
+        counter = 0
+
+        copy = self.copy(keep_sssr=True, keep_components=True)
+        if prepare_molecules:  # transform to kekule form without hydrogens
+            copy.kekule()
+            copy.implicify_hydrogens()
+
+        # transform to thiele to prevent duplicates and dearomatization
+        thiele = copy.copy(keep_sssr=True, keep_components=True)
+        thiele.thiele(fix_tautomers=False)
+        yield thiele  # return original structure as first tautomer
+
+        seen = {thiele: None}  # value is parent molecule - required for preventing migrations in sugars.
+
+        # first try to neutralize
+        if copy.neutralize():  # found neutral form
+            thiele = copy.copy(keep_sssr=True, keep_components=True)
+            thiele.thiele(fix_tautomers=False)
+            yield thiele
+            counter += 1
+            seen[thiele] = None
+
+        # lets iteratively do keto-enol transformations.
+        rings_count = len(thiele.aromatic_rings)  # increase rings strategy.
+        if keto_enol:
+            queue = deque([(copy, thiele)])
+        else:
+            queue = None
+        new_queue = [thiele]  # new_queue - molecules suitable for hetero-arenes enumeration.
+        # store aromatic form to seen. kekule forms not suitable for duplicate checking.
+
+        while queue:
+            current, thiele_current = queue.popleft()
+            for mol, ket in current._enumerate_keto_enol_tautomers(partial):
+                thiele = mol.copy(keep_sssr=True, keep_components=True)
+                thiele.thiele(fix_tautomers=False)
+
+                if thiele not in seen:
+                    seen[thiele] = current
+                    rc = len(thiele.aromatic_rings)
+                    if increase_aromaticity:
+                        if rc < rings_count:  # skip aromatic rings destruction
+                            continue
+                        elif rc > rings_count:  # higher aromaticity found. flush old queues.
+                            rings_count = rc
+                            queue = deque([(mol, thiele)])
+                            new_queue = [thiele]
+                            copy = mol  # new entry point.
+                            yield thiele
+                            break
+                    if keep_sugars and current is not copy and ket:
+                        # prevent carbonyl migration in sugars. skip entry point.
+                        # search alpha hydroxy ketone inversion
+                        before = seen[thiele_current]._sugar_groups
+                        if any((k, e) in before for e, k in mol._sugar_groups):
+                            continue
+
+                    queue.append((mol, thiele))
+                    new_queue.append(thiele)
+                    yield thiele
+                counter += 1
+                if counter == limit:
+                    return
+
+        # heteroarenes tautomers enumeration
+        if heteroarenes:
+            queue = deque(new_queue)
+        while queue:
+            current = queue.popleft()
+            for mol in current._enumerate_hetero_arene_tautomers():
+                if mol not in seen:
+                    seen[mol] = None
+                    queue.append(mol)
+                    new_queue.append(mol)  # new hetero-arenes also should be included to this list.
+                    yield mol
+                counter += 1
+                if counter == limit:
+                    return
+
+        # zwitter-ions enumeration
+        if zwitter:
+            queue = deque(new_queue)
+        while queue:
+            current = queue.popleft()
+            for mol in current._enumerate_zwitter_tautomers():
+                if mol not in seen:
+                    seen[mol] = None
+                    queue.append(mol)
+                    yield mol
+                counter += 1
+                if counter == limit:
+                    return
+
+    def enumerate_charged_tautomers(self, *, prepare_molecules=True, partial=False,
+                                    increase_aromaticity=True, keep_sugars=True, heteroarenes=True,
+                                    keto_enol=True, deep: int = 4, limit: int = 1000) -> Iterator['MoleculeContainer']:
+        """
+        Enumerate tautomers and protonated-deprotonated forms.
+        Better to use on neutralized non-ionic molecules.
+
+        See `enumerate_tautomers` and `enumerate_charged_forms` params description.
+        """
+        count = 0
+        for t in self.enumerate_tautomers(prepare_molecules=prepare_molecules, zwitter=False, partial=partial,
+                                          increase_aromaticity=increase_aromaticity, keep_sugars=keep_sugars,
+                                          heteroarenes=heteroarenes, keto_enol=keto_enol, limit=limit):
+            yield t
+            count += 1
+            if count == limit:
+                return
+            for c in t.enumerate_charged_forms(deep=deep, limit=limit):
+                yield c
+                count += 1
+                if count == limit:
+                    return
+
+
+__all__ = ['Tautomers']

chython/algorithms/tautomers/_acid.py

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2021-2026 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 lazy_object_proxy import Proxy
+
+
+def _stripped_rules():
+    from ... import smarts
+
+    rules = []
+
+    # Ammonia, H-imine,guanidine,amidine. [H][N+]=,-,:
+    q = smarts('[N;h1,h2,h3,h4;+]')
+    rules.append(q)
+    return rules
+
+
+def _rules():
+    from ... import smarts
+
+    rules = _stripped_rules()
+
+    # Phenoles
+    q = smarts('[O,S,Se;D1;z1][C,N;a]')
+    rules.append(q)
+
+    # Oxo-acids
+    q = smarts('[O,S,Se;D1;z1][C,N,P,S,Se,Cl,Br,I]=O')
+    rules.append(q)
+
+    # Nitro acid
+    q = smarts('[N;D3;z2;+]([O;D1:1])([O-])=O')
+    rules.append(q)
+
+    q = smarts('[F,Cl,Br,I;D0]')
+    rules.append(q)
+    return rules
+
+
+stripped_rules = Proxy(_stripped_rules)
+rules = Proxy(_rules)
+
+
+__all__ = ['stripped_rules', 'rules']

chython/algorithms/tautomers/_base.py

@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2021-2026 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 lazy_object_proxy import Proxy
+
+
+def _stripped_rules():
+    from ... import smarts
+
+    rules = []
+
+    # Oxo-acid salts
+    q = smarts('[O,S,Se;D1;z1;-][C,Si,N,P,S,Se,Cl,Br,I]=O')
+    rules.append(q)
+
+    # Thiophosphate salts
+    q = smarts('P([O,S,Se;D1;-:1])=[S,Se]')
+    rules.append(q)
+
+    # Phenole salts, alcoholates
+    q = smarts('[O,S,Se;D1;z1;-][C,N]')
+    rules.append(q)
+
+    # Nitrate
+    q = smarts('[N;D3;z2;+]([O;-:1])([O-])=O')
+    rules.append(q)
+
+    # imide
+    q = smarts('[N;D1,D2;z1;-]')
+    rules.append(q)
+
+    # ions
+    q = smarts('[O,S,F,Cl,Br,I;D0;-]')
+    rules.append(q)
+    return rules
+
+
+def _rules():
+    from ... import smarts
+
+    rules = _stripped_rules()
+
+    # Guanidine
+    q = smarts('[N;x0;z2]=C(N)N')
+    rules.append(q)
+
+    # Oxo-guanidine, Amino-guanidine
+    q = smarts('[N;D2;x1;z2]([O,N])=C(N)N')
+    rules.append(q)
+
+    # O-alkyl-isourea, S-alkyl-isothiaurea
+    q = smarts('[N;x0;z2]=C([O,S;D2;x0;z1])N')
+    rules.append(q)
+
+    # Dialkyl imidocarbonate
+    q = smarts('[N;x0;z2]=C([O;D2;x0])[O;D2;x0]')
+    rules.append(q)
+
+    # Amidine
+    q = smarts('[N;x0;z2]=[C;x2]N')
+    rules.append(q)
+
+    # O-alkyl-imidate (oxazoline)
+    q = smarts('[N;x0;z2]=[C;x2][O;D2;x0]')
+    rules.append(q)
+
+    # Amidoxime. O-N=C([C,H])N
+    q = smarts('[N;D2;x1;z2](O)=[C;x2]N')
+    rules.append(q)
+
+    # Oxime, Hydrazone. [O,N]-N=C([C,H])[C,H]
+    q = smarts('[N;D2;x1;z2]([N,O])=[C;x1;z2]')
+    rules.append(q)
+
+    # Imine
+    q = smarts('[N;x0;z2]=[C;x1;z2]')
+    rules.append(q)
+
+    # Alkyl amine, Hydroxylamine, Hydrazine
+    q = smarts('[N;D1;z1][C,N,O;x1;z1]')
+    rules.append(q)
+
+    # Dialkyl amine, Alkyl hydroxylamine, Alkyl hydrazine
+    q = smarts('[N;D2;z1]([C,N,O;x1;z1])[C;x1;z1]')
+    rules.append(q)
+
+    # Trialkyl amine, Dialkyl-hydroxylamine, Dialkyl-hydrazine
+    q = smarts('[N;D3;z1]([C,N,O;x1;z1])([C;x1;z1])[C;x1;z1]')
+    rules.append(q)
+
+    # Pyridine. Imidazole. Triazole. :N:
+    q = smarts('[N;a;h0;D2]')
+    rules.append(q)
+    return rules
+
+
+stripped_rules = Proxy(_stripped_rules)
+rules = Proxy(_rules)
+
+
+__all__ = ['stripped_rules', 'rules']

chython/algorithms/tautomers/_keto_enol.py

@@ -0,0 +1,107 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2022-2026 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 lazy_object_proxy import Proxy
+
+
+def _sugar_group():
+    from ... import smarts
+
+    return smarts('[N,O;D1,D2:1][C;z1][C;z2]=[N,O:2]')
+
+
+def _keto_rules():
+    from ... import smarts
+
+    rules = []
+    # first atom is H-acceptor
+    # second is direction
+
+    # C-C=[O,S,NH]
+    q = smarts('[N,O,S;D1;z2]=[C;D2,D3;x1;z2]')
+    rules.append(q)
+
+    # C-C=N-[C,N,O]
+    q = smarts('[N;D2;z2](=[C;D2,D3;x1;z2])[C,N,O]')
+    rules.append(q)
+
+    # [C,H]-N=N-C
+    q = smarts('[N;D1,D2;x1;z2]=N[C;x1]')
+    rules.append(q)
+
+    # [S,O,NR;H]-C=N
+    q = smarts('[N;z2]=C[N,O,S;h1]')
+    rules.append(q)
+
+    # [NH2]-C=N-R
+    q = smarts('[N;D2;z2]=C[N;D1]')
+    rules.append(q)
+
+    # S=C-[N,O;H]
+    q = smarts('[S;D1;z2]=C[N,O;h1,h2]')
+    rules.append(q)
+
+    # O=C-[N,S;H]
+    q = smarts('[O;D1;z2]=C[N,S;h1,h2]')
+    rules.append(q)
+    return rules
+
+
+def _enol_rules():
+    from ... import smarts
+
+    rules = []
+    # first atom is H-donor
+    # second is direction
+
+    # C=C-[OH,SH,NH2]
+    q = smarts('[N,O,S;D1;z1][C;D2,D3;x1;z2]')
+    rules.append(q)
+
+    # C=C-[NH]-[C,N,O]
+    q = smarts('[N;D2;z1]([C;D2,D3;x1;z2])[C,N,O]')
+    rules.append(q)
+
+    # [C,H]-[NH]-N=C
+    q = smarts('[N;D1,D2;x1;z1][N;z2]=[C;x1]')
+    rules.append(q)
+
+    # [S,O,NR;H]-C=N
+    q = smarts('[N,O,S;h1;z1][C;z2]=N')
+    rules.append(q)
+
+    # [NH2]-C=N-R
+    q = smarts('[N;D1;z1][C;z2]=[N;D2]')
+    rules.append(q)
+
+    # S=C-[N,O;H]
+    q = smarts('[N,O;h1,h2;z1][C;z2]=[S;D1]')
+    rules.append(q)
+
+    # O=C-[N,S;H]
+    q = smarts('[N,S;h1,h2;z1][C;z2]=O')
+    rules.append(q)
+    return rules
+
+
+keto_rules = Proxy(_keto_rules)
+enol_rules = Proxy(_enol_rules)
+sugar_group = Proxy(_sugar_group)
+
+
+__all__ = ['keto_rules', 'enol_rules', 'sugar_group']

chython/algorithms/tautomers/acid_base.py

@@ -0,0 +1,208 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2022-2026 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 collections.abc import Iterator
+from itertools import combinations, product
+from ._acid import rules as acid_rules, stripped_rules as stripped_acid_rules
+from ._base import rules as base_rules, stripped_rules as stripped_base_rules
+
+
+class AcidBase:
+    __slots__ = ()
+
+    def neutralize(self, *, keep_charge=True, logging=False) -> bool | list:
+        """
+        Convert organic salts to neutral form if possible. Only one possible form used for charge unbalanced structures.
+
+        :param keep_charge: do partial neutralization to keep total charge of molecule.
+        :param logging: return changed atoms list.
+        """
+        try:
+            mol, changed = next(self._neutralize(keep_charge))
+        except StopIteration:
+            if logging:
+                return []
+            return False
+
+        self._atoms = mol._atoms
+        self.flush_cache(keep_sssr=True, keep_components=True, keep_special_connectivity=True)
+        self.fix_stereo()
+        if logging:
+            return list(changed)
+        return True
+
+    def enumerate_charged_forms(self, *, deep: int = 4, limit: int = 1000) -> Iterator['MoleculeContainer']:
+        """
+        Enumerate protonated and deprotonated ions. Use on neutralized molecules.
+
+        :param deep: Maximum amount of added or removed protons.
+        :param limit: Maximum amount of generated structures.
+        """
+        if limit < 1:
+            raise ValueError('limit should be greater or equal 1')
+
+        donors = set()
+        acceptors = set()
+        for q in acid_rules:
+            for mapping in q.get_mapping(self, automorphism_filter=False):
+                donors.add(mapping[1])
+        for q in base_rules:
+            for mapping in q.get_mapping(self, automorphism_filter=False):
+                acceptors.add(mapping[1])
+
+        h_source = [None] * deep + list(donors)
+        h_drain = list(acceptors) + [None] * deep
+
+        seen = set()
+        seen_combo = set()
+        for r in range(min(len(acceptors), deep), 0, -1):  # number of acceptors to protonate
+            for ac in combinations(acceptors, r):  # acceptors atoms to protonate
+                uniq = set()
+                for dc in combinations(h_source, r):  # H donors
+                    if dc in uniq:  # filter None-containing duplicates
+                        continue
+                    uniq.add(dc)
+                    seen_combo.add((dc, ac))
+                    mol = self.copy(keep_sssr=True, keep_components=True)
+                    for n in ac:
+                        a = mol._atoms[n]
+                        a._implicit_hydrogens += 1
+                        a._charge += 1
+                    for n in dc:
+                        if n is not None:
+                            a = mol._atoms[n]
+                            a._implicit_hydrogens -= 1
+                            a._charge -= 1
+                    if mol not in seen:
+                        seen.add(mol)
+                        yield mol
+                    limit -= 1
+                    if not limit:
+                        return
+
+        for r in range(1, min(len(donors), deep) + 1):
+            for dc in combinations(donors, r):
+                uniq = set()
+                for ac in combinations(h_drain, r):  # H acceptors
+                    if ac in uniq:
+                        continue
+                    uniq.add(ac)
+                    if (dc, ac) in seen_combo:
+                        continue
+                    mol = self.copy(keep_sssr=True, keep_components=True)
+                    for n in ac:
+                        if n is not None:
+                            a = mol._atoms[n]
+                            a._implicit_hydrogens += 1
+                            a._charge += 1
+                    for n in dc:
+                        if n is not None:
+                            a = mol._atoms[n]
+                            a._implicit_hydrogens -= 1
+                            a._charge -= 1
+                    if mol not in seen:
+                        seen.add(mol)
+                        yield mol
+                    limit -= 1
+                    if not limit:
+                        return
+
+    def _neutralize(self, keep_charge=True):
+        donors = set()
+        acceptors = set()
+        for q in stripped_acid_rules:
+            for mapping in q.get_mapping(self, automorphism_filter=False):
+                donors.add(mapping[1])
+        for q in stripped_base_rules:
+            for mapping in q.get_mapping(self, automorphism_filter=False):
+                acceptors.add(mapping[1])
+
+        if keep_charge:
+            if not donors or not acceptors:
+                return  # neutralization impossible
+            elif len(donors) > len(acceptors):
+                copy = self.copy(keep_sssr=True, keep_components=True)
+                for n in acceptors:
+                    a = copy._atoms[n]
+                    a._implicit_hydrogens += 1
+                    a._charge += 1
+                for c in combinations(donors, len(acceptors)):
+                    mol = copy.copy(keep_sssr=True, keep_components=True)
+                    for n in c:
+                        a = mol._atoms[n]
+                        a._implicit_hydrogens -= 1
+                        a._charge -= 1
+                    yield mol, acceptors.union(c)
+            elif len(donors) < len(acceptors):
+                copy = self.copy(keep_sssr=True, keep_components=True)
+                for n in donors:
+                    a = copy._atoms[n]
+                    a._implicit_hydrogens -= 1
+                    a._charge -= 1
+                for c in combinations(acceptors, len(donors)):
+                    mol = copy.copy(keep_sssr=True, keep_components=True)
+                    for n in c:
+                        a = mol._atoms[n]
+                        a._implicit_hydrogens += 1
+                        a._charge += 1
+                    yield mol, donors.union(c)
+            else:  # balanced!
+                mol = self.copy(keep_sssr=True, keep_components=True)
+                for n in donors:
+                    a = mol._atoms[n]
+                    a._implicit_hydrogens -= 1
+                    a._charge -= 1
+                for n in acceptors:
+                    a = mol._atoms[n]
+                    a._implicit_hydrogens += 1
+                    a._charge += 1
+                yield mol, donors | acceptors
+        elif donors or acceptors:
+            mol = self.copy(keep_sssr=True, keep_components=True)
+            for n in donors:
+                a = mol._atoms[n]
+                a._implicit_hydrogens -= 1
+                a._charge -= 1
+            for n in acceptors:
+                a = mol._atoms[n]
+                a._implicit_hydrogens += 1
+                a._charge += 1
+            yield mol, donors | acceptors
+
+    def _enumerate_zwitter_tautomers(self):
+        donors = set()
+        acceptors = set()
+        for q in acid_rules:
+            for mapping in q.get_mapping(self, automorphism_filter=False):
+                donors.add(mapping[1])
+        for q in base_rules:
+            for mapping in q.get_mapping(self, automorphism_filter=False):
+                acceptors.add(mapping[1])
+
+        for d, a in product(donors, acceptors):
+            mol = self.copy(keep_sssr=True, keep_components=True)
+            d = mol._atoms[d]
+            a = mol._atoms[a]
+            d._implicit_hydrogens -= 1
+            a._implicit_hydrogens += 1
+            d._charge -= 1
+            a._charge += 1
+            yield mol
+
+
+__all__ = ['AcidBase']