chython 2.19__cp313-cp313-win_amd64.whl

chython/algorithms/tautomers/heteroarenes.py

@@ -0,0 +1,103 @@
+# -*- 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 import deque, defaultdict
+from itertools import product
+from ..aromatics.kekule import _kekule_component
+from ...exceptions import InvalidAromaticRing
+
+
+# atomic number constants
+B = 5
+C = 6
+N = 7
+P = 15
+
+
+class HeteroArenes:
+    __slots__ = ()
+
+    def _enumerate_hetero_arene_tautomers(self):
+        atoms = self._atoms
+        bonds = self._bonds
+
+        rings = defaultdict(list)  # aromatic skeleton
+        for n, m_bond in bonds.items():
+            for m, bond in m_bond.items():
+                if bond == 4:
+                    rings[n].append(m)
+        if not rings:
+            return
+
+        acceptors = set()
+        donors = set()
+        single_bonded = set()
+        for n, ms in rings.items():
+            a = atoms[n]
+            if len(ms) == 2:
+                if a in (B, N, P):
+                    if not a.charge and not a.is_radical:
+                        # only neutral B, N, P
+                        if a.implicit_hydrogens:  # pyrrole
+                            donors.add(n)
+                        elif len(bonds[n]) == 2:  # pyridine
+                            acceptors.add(n)
+                        else:
+                            single_bonded.add(n)
+                elif a.charge == -1 and a == C:  # ferrocene
+                    single_bonded.add(n)
+            elif len(ms) == 3 and a in (B, N, P) and not a.charge and not a.is_radical:
+                single_bonded.add(n)
+        if not donors or not acceptors:
+            return
+
+        atoms = set(rings)
+        components = []
+        while atoms:
+            start = atoms.pop()
+            component = {start: rings[start]}
+            queue = deque([start])
+            while queue:
+                current = queue.popleft()
+                for n in rings[current]:
+                    if n not in component:
+                        queue.append(n)
+                        component[n] = rings[n]
+
+            atoms.difference_update(component)
+            if donors.isdisjoint(component) or acceptors.isdisjoint(component):
+                continue
+            components.append(component)
+
+        if not components:
+            return
+        for component in components:
+            for d, a in product(component.keys() & donors, component.keys() & acceptors):
+                sb = component.keys() & single_bonded
+                sb.add(a)  # now pyrrole
+                try:
+                    next(_kekule_component(component, sb, (), 0))
+                except InvalidAromaticRing:
+                    continue
+                mol = self.copy(keep_sssr=True, keep_components=True)
+                mol._atoms[d]._implicit_hydrogens = 0
+                mol._atoms[a]._implicit_hydrogens = 1
+                yield mol
+
+
+__all__ = ['HeteroArenes']

chython/algorithms/tautomers/keto_enol.py

@@ -0,0 +1,143 @@
+# -*- 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 import defaultdict
+from functools import cached_property
+from itertools import chain, repeat
+from ._keto_enol import *
+
+
+# atomic number constants
+C = 6
+
+
+class KetoEnol:
+    __slots__ = ()
+
+    def _enumerate_keto_enol_tautomers(self, partial=False):
+        for fix, ket in self.__enumerate_bonds(partial):
+            if ket:
+                a = fix[-1][1]
+                d = fix[0][0]
+            else:
+                a = fix[0][0]
+                d = fix[-1][1]
+
+            mol = self.copy(keep_sssr=True, keep_components=True)
+            m_bonds = mol._bonds
+            for n, m, b in fix:
+                m_bonds[n][m]._order = b
+
+            a = mol._atoms[a]
+            d = mol._atoms[d]
+            a._implicit_hydrogens += 1
+            d._implicit_hydrogens -= 1
+            a._hybridization -= 1  # -C=X>=C-X or -C=C=X>=C-C=X
+            d._hybridization += 1
+            yield mol, ket
+
+    @cached_property
+    def _sugar_groups(self):
+        ek = []
+        for mapping in sugar_group.get_mapping(self, automorphism_filter=False):
+            e, k = mapping[1], mapping[2]
+            ek.append((e, k))
+        return ek
+
+    def __enumerate_bonds(self, partial):
+        atoms = self._atoms
+        bonds = self._bonds
+        rings = self.atoms_rings_sizes
+
+        # search neutral oxygen and nitrogen
+        donors = defaultdict(set)
+        acceptors = defaultdict(set)
+        for q in enol_rules:
+            for mapping in q.get_mapping(self, automorphism_filter=False):
+                donors[mapping[1]].add(mapping[2])
+        for q in keto_rules:
+            for mapping in q.get_mapping(self, automorphism_filter=False):
+                acceptors[mapping[1]].add(mapping[2])
+
+        for (atom, dirs), hydrogen, anti in chain(zip(donors.items(), repeat(True), repeat(acceptors)),
+                                                  zip(acceptors.items(), repeat(False), repeat(donors))):
+            path = []
+            seen = {atom}
+            stack = [(atom, n, 2 if hydrogen else 1, 0) for n in dirs]
+            while stack:
+                last, current, bond, depth = stack.pop()
+
+                if partial and path and not len(path) % 2 and \
+                        (hydrogen or  # enol > ketone
+                         atoms[(x := path[-1][1])].implicit_hydrogens and
+                         (x not in rings or all(x > 7 for x in rings[x]))):  # ketone>
+                    # return partial hops. ignore allenes in small rings.
+                    yield path, hydrogen
+                if len(path) > depth:  # fork found
+                    if not partial and not len(path) % 2 and (hydrogen or atoms[path[-1][1]].implicit_hydrogens):
+                        # end of path found. return it and start new one.
+                        yield path, hydrogen
+                    seen.difference_update(x for _, x, _ in path[depth:])
+                    path = path[:depth]
+
+                path.append((last, current, bond))
+
+                # adding neighbors
+                depth += 1
+                seen.add(current)
+                if bond == 2:
+                    next_bond = 1
+                else:
+                    next_bond = 2
+
+                for n, b in bonds[current].items():
+                    if n == last:
+                        continue
+                    elif n in seen:  # aromatic ring destruction. pyridine double bonds shift
+                        continue
+                    elif n in anti:  # enol-ketone switch
+                        if current in anti[n]:  # keton or enol bond
+                            if hydrogen:
+                                cp = path.copy()
+                                cp.append((current, n, 1))  # double to single in keton end
+                                yield cp, True
+                            else:
+                                cp = path.copy()
+                                cp.append((current, n, 2))  # single to double in enol end
+                                yield cp, False
+                    elif b == bond and (a := atoms[n]) == C:  # classic keto-enol route
+                        if a.hybridization == 2:  # grow up
+                            stack.append((current, n, next_bond, depth))
+                        elif hydrogen:
+                            if a.hybridization == 3:  # OC=CC=C=C case
+                                cp = path.copy()
+                                cp.append((current, n, 1))
+                                yield cp, True  # ketone found
+                        elif a.hybridization == 1 and a.implicit_hydrogens:  # ketone >> enol
+                            cp = path.copy()
+                            cp.append((current, n, 2))
+                            yield cp, False
+
+            if path and not len(path) % 2 and \
+                    (hydrogen or  # enol > ketone
+                     atoms[(x := path[-1][1])].implicit_hydrogens and
+                     (x not in rings or all(x > 7 for x in rings[x]))):
+                yield path, hydrogen
+
+
+__all__ = ['KetoEnol']

chython/algorithms/tautomers/test/__init__.py

@@ -0,0 +1,18 @@
+# -*- 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/>.
+#

chython/algorithms/tautomers/test/test_tautomers.py

@@ -0,0 +1,80 @@
+# -*- 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 chython import smiles
+from itertools import zip_longest
+
+
+def test_keto_enol_2h_pyrrole():
+    """
+    2H‐pyrrole. [N:1]=1[C:2][C:3]=,:[C:4][C:5]=1
+    """
+    for t, v in zip(['C1C=CC=N1', 'C1N=CC2=C1C=CC=C2'], ['C=1C=CNC=1', 'N1C=C2C=CC=CC2=C1']):
+        s = smiles(t)
+        t = set(s.enumerate_tautomers())
+        v = smiles(v)
+        s.thiele()
+        v.thiele()
+        assert len(t) == 2, ' '.join(str(x) for x in t)
+        assert t == {s, v}, f'{", ".join(str(x) for x in t)} != {s}, {v}'
+
+
+def test_acid_protonated_nitrogen():
+    """
+    Ammonia, H-imine,guanidine,amidine. [H][N+]=,-,:
+    """
+    for t, v in zip_longest(['C=[NH2+].[Cl-]', 'C=[NH+]C.[Cl-]', 'C[NH3+].[Cl-]', 'C[NH2+]C.[Cl-]', 'C[NH1+](C)C.[Cl-]',
+                             '[NH4+].[Cl-]', 'C=[N+](C)C.[Cl-]', 'C[N+](C)(C)C.[Cl-]'],
+                            ['C=N.Cl', 'C=NC.Cl', 'CN.Cl', 'CNC.Cl', 'CN(C)C.Cl', 'N.Cl']):
+        s = smiles(t)
+        t = set(s.enumerate_tautomers())
+        if v:
+            assert len(t) == 2, ' '.join(str(x) for x in t)
+            assert t == {s, smiles(v)}
+        else:
+            assert len(t) == 1
+
+
+def test_base_nitrogen():
+    for t, v in zip_longest(['N1C=CN=N1.Cl', 'NC(N)=N.Cl', 'CN(C)C(=NO)N(C)C.Cl', 'CN(C)C(=NC)N(C)C.Cl',
+                             'CN(C)C(=NN)N(C)C.Cl', 'COC(N)=N.Cl', 'CSC(N)=N.Cl', 'COC(OC)=N.Cl', 'COC(C)=N.Cl',
+                             'CNN.Cl', 'CN.Cl',
+                             'N.Cl', 'N1C=CC=C1.Cl'],
+                            [('N1N=NC=C1.Cl', 'N1=CC=NN1.Cl', '[NH+]=1NC=CN=1.[Cl-]', 'N1=[NH+]C=CN1.[Cl-]',
+                              'N1=CC=[NH+]N1.[Cl-]'),
+                             ('NC(N)=N.Cl', 'NC(N)=[NH2+].[Cl-]'),
+                             ('CN(C)C(=NO)N(C)C.Cl', 'CN(C)C(N(C)C)=[NH+]O.[Cl-]'),
+                             ('CN(C)C(=NC)N(C)C.Cl', 'CN(C)C(N(C)C)=[NH+]C.[Cl-]'),
+                             ('CN(C)C(=NN)N(C)C.Cl', 'CN(C)C(N(C)C)=[NH+]N.[Cl-]'),
+                             ('Cl.NC(=N)OC', '[NH2+]=C(N)OC.[Cl-]'), ('Cl.NC(=N)SC', '[NH2+]=C(N)SC.[Cl-]'),
+                             ('COC(OC)=N.Cl', 'COC(OC)=[NH2+].[Cl-]'),
+                             ('COC(C)=N.Cl', 'COC(C)=[NH2+].[Cl-]'),
+                             ('CNN.Cl', 'CN[NH3+].[Cl-]', 'C[NH2+]N.[Cl-]'),
+                             ('CN.Cl', 'C[NH3+].[Cl-]')]):
+        s = smiles(t)
+        t = set(s.enumerate_tautomers(zwitter=True))
+        if v:
+            assert len(t) == len(v), ' '.join(str(x) for x in t)
+            vs = set()
+            for x in v:
+                x = smiles(x)
+                x.thiele(fix_tautomers=False)
+                vs.add(x)
+            assert t == vs, ' '.join(str(x) for x in t) + ' != ' + ' '.join(str(x) for x in vs)
+        else:
+            assert len(t) == 1, ' '.join(str(x) for x in t)

chython/algorithms/test/__init__.py

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2025, 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/>.
+#

chython/algorithms/test/test_isomorphism.py

@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2025, 2026 Ramil Nugmanov <nougmanoff@protonmail.com>
+#  Copyright 2025 Tagir Akhmetshin <tagirshin@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 chython import smiles
+
+
+def test_basic():
+    # Test basic atom mapping in simple molecules
+    mol1 = smiles('CC(=O)O')  # acetic acid
+    mol2 = smiles('CC(O)=O')  # acetic acid
+
+    assert mol1 <= mol2
+    assert mol2 <= mol1
+
+    mappings = list(mol1.get_mapping(mol2))
+    assert len(mappings) == 1
+    assert mappings[0] == {1: 1, 2: 2, 3: 4, 4: 3}
+    assert not smiles('CC(O)O') <= mol1
+    assert smiles('C[O-]') <= smiles('CC[O-]')
+    assert not smiles('C[O-]') <= smiles('CCO')
+
+
+def test_substructure_mapping():
+    # Test mapping of a substructure
+    mol = smiles('CCC(=O)OC')
+    substructure = smiles('CC(=O)O')
+
+    assert substructure < mol
+    mappings = list(substructure.get_mapping(mol))
+    assert len(mappings) == 1
+    assert mappings[0] == {1: 2, 2: 3, 3: 4, 4: 5}
+
+
+def test_multiple_mappings():
+    # Test cases where multiple valid mappings exist
+    mol = smiles('CC(=O)OC(=O)C')
+    pattern = smiles('CC(=O)O')  # acetone pattern
+
+    mappings = list(pattern.get_mapping(mol))
+    assert len(mappings) == 2  # should find multiple matches
+    assert {1: 1, 2: 2, 3: 3, 4: 4} in mappings
+    assert {1: 7, 2: 5, 3: 6, 4: 4} in mappings

chython/algorithms/test/test_smiles.py

@@ -0,0 +1,76 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2025, 2026 Ramil Nugmanov <nougmanoff@protonmail.com>
+#  Copyright 2025 Tagir Akhmetshin <tagirshin@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 chython import smiles
+
+
+def test_basic_smiles():
+    # Test basic SMILES generation
+    mol = smiles('CO')  # methanol
+    assert str(mol) in ('CO', 'OC')
+
+    mol = smiles('c1ccccc1')  # benzene
+    assert str(mol) == 'c1ccccc1'
+
+
+def test_format_options():
+    # Test different format options
+    mol = smiles('C=1C=CC=CC=1')
+
+    # Test asymmetric closures
+    assert str(mol) == 'C=1C=CC=CC=1'
+    assert format(mol, 'a') == 'C=1C=CC=CC1'
+
+    assert format(mol, '!b') == 'C1CCCCC1'
+
+    # Test disable stereo
+    mol = smiles('C[C@H](O)CC')
+    assert '@' in str(mol)
+    assert '@' not in format(mol, '!s')
+
+    mol = smiles('c1ccccc1')
+    assert format(mol, 'A') == 'C:1:C:C:C:C:C:1'
+    assert format(mol, 'Aa') == 'C:1:C:C:C:C:C1'
+    assert format(mol, 'm') == '[cH:1]1[cH:2][cH:3][cH:4][cH:5][cH:6]1'
+    assert format(mol, 'h') == '[cH]1[cH][cH][cH][cH][cH]1'
+
+    assert format(mol, 'Ah') == '[CH]:1:[CH]:[CH]:[CH]:[CH]:[CH]:1'
+    assert format(mol, 'Ah!b') == '[CH]1[CH][CH][CH][CH][CH]1'
+
+    mol = smiles('[K+]')
+    assert str(mol) == '[K+]'
+    assert format(mol, '!z') == '[K]'
+
+    mol = smiles('[CH3]')
+    assert str(mol) == '[CH3] |^1:0|'
+    assert format(mol, '!x') == '[CH3]'
+
+    mol = smiles('CCO')
+    assert len({format(mol, 'r') for _ in range(50)}) == 4
+
+
+def test_smiles_comparison():
+    # Test SMILES comparison functionality
+    mol1 = smiles('CCO')
+    mol2 = smiles('OCC')
+    mol3 = smiles('CCC')
+
+    assert mol1 == mol2  # same molecules
+    assert mol1 != mol3  # different molecules
+    assert hash(mol1) == hash(mol2)  # same hash for same molecules