chython 2.4__cp312-cp312-win_amd64.whl

chython/algorithms/mapping/_groups.py

@@ -0,0 +1,94 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2021-2023 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 _xonyl_groups():
+    from ... import smarts
+
+    rules = []
+    # atom 1 - axis
+    # atoms 2, 3 - swapping
+    q = smarts('[N;D3;z2;+]([O;D1;-])=[O;D1]')
+    rules.append(q)
+
+    q = smarts('[N,O,S,Se;D1;z2:3]=[C,P,As,Sb,Bi,S,Se,Te,Po,Cl,Br,I,At:1][N,O,S,Se;D1:2]')
+    rules.append(q)
+
+    q = smarts('[N,O,S,Se;D1;z2:3]=[C,P,As,Sb,Bi,S,Se,Te,Po,Cl,Br,I,At:1][N,O,S,Se;D1;-:2]')
+    rules.append(q)
+    return rules
+
+
+def _substituents():
+    """
+    Rules for switchable functional groups remapping
+    """
+    from ... import smarts
+
+    rules = []
+
+    # nitro addition
+    #
+    #      O [3]     [2] O -- *
+    #     //            /:
+    # * - N+   >>  * = N+
+    #      \            \
+    #       O- [2]       O- [3]
+    #
+    q = smarts('[N;D3;z2,z4;+]([O;D1;-])-,:[O;D2]')
+    rules.append((q, ((2, 3), (3, 2))))
+
+    #
+    #      NH [3]          NH2 [3]
+    #     //               /
+    # * - X       >>  * - X
+    #      \              :
+    #       NH2 [2]       N [2]
+    #
+    q = smarts('[N;D2;h0;z2,z4:3]=,:[C;D3:1][N:2]')
+    rules.append((q, ((2, 3), (3, 2))))
+
+    #
+    #      O [3]        [3] O - R
+    #     //               /
+    # * - X       >>  * - X
+    #      \              \\
+    #       OH [2]         O [2]
+    #
+    q = smarts('[N,O,S,Se;D1;z2:3]=[C,P,As,Sb,Bi,S,Se,Te,Po,Cl,Br,I,At:1][N,O,S,Se;D2:2]')
+    rules.append((q, ((2, 3), (3, 2))))
+
+    #
+    #      O [3]            A
+    #     //               /
+    # * - X       >>  * - X
+    #      \              \\
+    #       OH [2]         O [2]
+    #
+    q = smarts('[N,O,S,Se;D1;z2:3]=[C,P,As,Sb,Bi,S,Se,Te,Po,Cl,Br,I,At:1][A:2]')
+    rules.append((q, ((3, 2),)))  # possible only: (3, 2)
+    return rules
+
+
+xonyl_groups = Proxy(_xonyl_groups)
+substituents_groups = Proxy(_substituents)
+
+
+__all__ = ['xonyl_groups', 'substituents_groups']

chython/algorithms/mapping/_reactions.py

@@ -0,0 +1,72 @@
+# -*- 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/>.
+#
+from lazy_object_proxy import Proxy
+
+
+def _rules():
+    from ... import smiles, smarts
+    raw_rules = []
+
+    # phenol etherification
+    r = smiles('[OH:5][cH:1]:[cH2:2].[CH3:4][OH:3]>>[CH3:4][O:3][cH:1]:[cH2:2]')
+    m = smarts('[O;D1:5].[O;D1:3]')  # reactant restriction.
+    raw_rules.append((r, {3: 5}, m))
+
+    # esterification
+    r = smiles('[OH:2][CH:1]=[O:3].[CH3:4][OH:5]>>[CH3:4][O:2][CH:1]=[O:3]')
+    m = smarts('[O;D1:2].[O;D1:5]')
+    raw_rules.append((r, {2: 5}, m))
+
+    # acid reduction
+    r = smiles('[CH3:2][C:1]([OH:3])=[O:4]>>[CH3:2][CH2:1][OH:3]')
+    m = smarts('[O;D1:3]')
+    raw_rules.append((r, {3: 4, 4: 3}, m))
+
+    # ester reduction
+    r = smiles('[CH3:5][O:3][C:1]([CH3:2])=[O:4]>>[CH3:2][CH2:1][OH:3]')
+    raw_rules.append((r, {3: 4}, None))
+
+    # ozonolysis
+    r = smiles('[O-:4][O+:1]=[O:6].[CH3:3][CH:2]=[CH2:5]>>[CH3:3][CH:2]=[O:1]')
+    raw_rules.append((r, {1: 4}, None))
+
+    # peroxide oxirane
+    r = smiles('[CH3:6][O:1][OH:5].[CH3:4][CH:2]=[CH2:3]>>[CH3:4][CH:2]1[CH2:3][O:1]1')
+    m = smarts('[O;D1:5]')
+    raw_rules.append((r, {1: 5}, m))
+
+    # claisen rearrangement
+    r = smiles('[cH2:4]:[cH:3]:[cH:2][O:1][CH2:5][CH:6]=[CH2:7]>>[OH:1][cH:2]:[c:3](:[cH2:4])[CH2:5][CH:6]=[CH2:7]')
+    raw_rules.append((r, {5: 7, 7: 5}, None))
+
+    # metathesis
+    r = smiles('[CH3:1][CH:2]=[CH2:3].[CH3:5][CH:4]=[CH2:6]>>[CH3:5][CH:3]=[CH:2][CH3:1]')
+    raw_rules.append((r, {3: 4, 4: 3}, None))
+
+    rules = []
+    for r, f, m in raw_rules:
+        c = ~r
+        rules.append((c, str(c.substructure(c.center_atoms)), m, f))
+    return rules
+
+
+rules = Proxy(_rules)
+
+
+__all__ = ['rules']

chython/algorithms/mapping/attention.py

@@ -0,0 +1,216 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2022-2024 Ramil Nugmanov <nougmanoff@protonmail.com>
+#  Copyright 2024 Philippe Gantzer <p.gantzer@icredd.hokudai.ac.jp>
+#  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 CachedMethods import class_cached_property
+from itertools import chain, count, repeat
+from logging import getLogger, INFO
+from numpy import ix_, unravel_index, argmax, zeros, array, isclose, nonzero, ones, mean
+from typing import TYPE_CHECKING, Union
+
+
+if TYPE_CHECKING:
+    from chython import ReactionContainer
+
+logger = getLogger('chython.attention')
+logger.setLevel(INFO)
+
+
+class Attention:
+    __slots__ = ()
+    __class_cache__ = {}
+
+    def reset_mapping(self: Union['ReactionContainer', 'Attention'], *, return_score: bool = False, multiplier=1.75,
+                      keep_reactants_numbering=False) -> Union[bool, float]:
+        """
+        Do atom-to-atom mapping. Return True if mapping changed.
+        """
+        if any(len(bs) > 14 for m in self.molecules() for bs in m._bonds.values()):
+            logger.info('atom-to-atom mapping not supported for hypervalent compounds')
+            return False
+        fixed = self.__fix_collisions()
+        equal_atoms, p2r, r2p, r_adj, p_adj, r_map, p_map, pa, rg_map = self.__prepare_remapping()
+
+        # rxnmapper-inspired algorithm
+        am = self.__get_attention()
+        # sum of reactants to products attention and vice-versa for equal atom types only
+        am = (am[p2r] + am[r2p].T) * equal_atoms
+        amc = am.copy()
+
+        mapping = {}
+        scope = zeros(pa, dtype=bool)
+        seen = ones(pa, dtype=bool)
+        score = []
+        for x in range(pa):  # iteratively map each product atom to reactant
+            # select highest attention
+            # todo: optimize
+            if not x:
+                i, j = unravel_index(argmax(am), am.shape)
+            else:
+                ams = am[scope]
+                if ams.size:
+                    i, j = unravel_index(argmax(ams), ams.shape)
+                    i = nonzero(scope)[0][i]
+                else:
+                    i, j = unravel_index(argmax(am), am.shape)
+            if isclose(am[i, j], 0.):  # no more products atoms in reactants
+                # mark as unmapped
+                for n in set(p_map).difference(mapping):
+                    mapping[n] = 0
+                break
+            else:
+                score.append(amc[i, j])
+            mapping[p_map[i]] = r_map[j]
+            am[ix_(p_adj[i], r_adj[j])] *= multiplier  # highlight neighbors
+            am[i] = am[:, j] = 0  # mask mapped product and reactant atoms
+            seen[i] = False
+            scope[i] = False
+            scope[p_adj[i] & seen] = True
+
+        score = float(mean(score)) if score else 0.
+        # mapping done.
+        if any(n != m for n, m in mapping.items()):  # old mapping changed
+            if keep_reactants_numbering or fixed:
+                r_mapping = {n: n for n in r_map}
+            else:
+                r_mapping = {m: n for n, m in enumerate(r_map, 1)}  # remap reactants to contiguous range
+                for m in self.reactants:
+                    m.remap(r_mapping)
+
+            p_mapping = {}
+            nm = max(r_mapping.values())
+            for n, m in mapping.items():
+                if m := r_mapping.get(m):
+                    p_mapping[n] = m
+                else:  # not found in reactants atoms. set unique numbers.
+                    nm += 1
+                    p_mapping[n] = nm
+
+            for m in self.products:
+                m.remap(p_mapping)
+
+            if not keep_reactants_numbering and not fixed:
+                rg_mapping = {m: n for n, m in enumerate(rg_map, nm+1)}  # remap reagents to contiguous range without overlapping
+                for m in self.reagents:
+                    m.remap(rg_mapping)
+
+            self.flush_cache()
+            fixed = True
+
+        if self.fix_groups_mapping():  # fix carboxy etc
+            fixed = True
+        if self.fix_mapping():  # fix common mistakes in mechanisms
+            fixed = True
+        if return_score:
+            return score
+        return fixed
+
+    def __fix_collisions(self: 'ReactionContainer'):
+        r = [n for m in chain(self.reactants, self.reagents) for n in m._atoms]
+        p = [n for m in self.products for n in m._atoms]
+        c = count(1)
+        if len(r) != len(set(r)):
+            for m in chain(self.reactants, self.reagents):
+                m.remap({n: next(c) for n in m._atoms})
+        if len(p) != len(set(p)):
+            for m in self.products:
+                m.remap({n: next(c) for n in m._atoms})
+        if next(c) != 1:
+            self.flush_cache()
+            return True
+        return False
+
+    def __prepare_remapping(self: 'ReactionContainer'):
+        r_map = [n for m in self.reactants for n in m]
+        p_map = [n for m in self.products for n in m]
+        rg_map = [n for m in self.reagents for n in m]
+        ra = len(r_map)  # number of reactants atoms
+        pa = len(p_map)  # number of products atoms
+
+        ram = [False]  # reactants atoms mask
+        r_atoms = []
+        r_adj = zeros((ra, ra), dtype=bool)
+        i = 0
+        for m in self.reactants:
+            ram.append(False)
+            ram.extend(repeat(True, len(m)))
+            a = m.adjacency_matrix()
+            j = i + len(m)
+            r_adj[i:j, i:j] = a
+            i = j
+            r_atoms.extend(a.atomic_number for _, a in m.atoms())
+        r_atoms = array(r_atoms, dtype=int)
+
+        pam = [False] * len(ram)  # products atoms mask
+        p_atoms = []
+        p_adj = zeros((pa, pa), dtype=bool)
+        i = 0
+        for m in self.products:
+            pam.append(False)
+            pam.extend(repeat(True, len(m)))
+            a = m.adjacency_matrix()
+            j = i + len(m)
+            p_adj[i:j, i:j] = a
+            i = j
+            p_atoms.extend(a.atomic_number for _, a in m.atoms())
+        p_atoms = array(p_atoms, dtype=int)
+
+        ram.extend(repeat(False, len(pam) - len(ram)))
+        ram = array(ram, dtype=bool)
+        pam = array(pam, dtype=bool)
+        return p_atoms[:, None] == r_atoms, ix_(pam, ram), ix_(ram, pam), r_adj, p_adj, r_map, p_map, pa, rg_map
+
+    @class_cached_property
+    def __attention_model(self):
+        from chython import torch_device
+        from chytorch.zoo.rxnmap import Model
+
+        return Model().to(torch_device)
+
+    @class_cached_property
+    def __autocast(self):
+        from chython import torch_device
+
+        if torch_device.startswith('cuda'):
+            try:
+                from torch import autocast
+            except ImportError:  # torch 1.8 ad-hoc
+                from torch.cuda.amp import autocast
+
+                return autocast()
+            else:
+                return autocast('cuda')
+        return autocast_filler()
+
+    def __get_attention(self):
+        from torch import no_grad
+
+        with no_grad(), self.__autocast:
+            am = self.__attention_model(self).float().cpu().numpy()
+        return am
+
+
+class autocast_filler:
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        ...
+
+
+__all__ = ['Attention']

chython/algorithms/mapping/fixmapper.py

@@ -0,0 +1,84 @@
+# -*- 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 collections import ChainMap
+from itertools import count
+from typing import List, Tuple, TYPE_CHECKING, Union
+from ._reactions import rules
+
+
+if TYPE_CHECKING:
+    from chython import ReactionContainer
+
+
+class FixMapper:
+    __slots__ = ()
+
+    def fix_mapping(self: 'ReactionContainer', *, logging: bool = False) -> \
+            Union[bool, List[Tuple[int, str, Tuple[int, ...]]]]:
+        """
+        Fix mapping by using loaded rules.
+        """
+        if not self:
+            if logging:
+                return []
+            return False
+
+        cgr = ~self
+        if not cgr.center_atoms:
+            if logging:
+                return []
+            return False
+        del self.__dict__['__cached_method_compose']
+
+        log = []
+        free_number = count(max(cgr) + 1)
+        components = [(cgr.substructure(c),
+                       cgr.augmented_substructure(c, 2),  # deep DEPENDS on rules!
+                       c)
+                      for c in cgr.substructure(cgr.center_atoms).connected_components]
+
+        r_atoms = ChainMap(*(x._atoms for x in self.reactants))
+        for c, ac, cs in components:
+            for rule_num, (query, signature, restrict, fix) in enumerate(rules):
+                if str(c) == signature:
+                    for mapping in query.get_mapping(ac, automorphism_filter=False):
+                        if not cs.issubset(mapping.values()):
+                            continue
+                        if restrict is not None and any(a != r_atoms.get(mapping[n]) for n, a in restrict.atoms()):
+                            continue
+                        mapping = {mapping[n]: next(free_number) if m is None else mapping[m] for n, m in fix.items()}
+                        for m in self.products:
+                            m.remap(mapping)
+                        log.append((rule_num, signature, tuple(mapping.values())))
+                        break
+                    else:
+                        continue
+                    break  # component remapped!
+
+        if log:
+            self.flush_cache()
+            if logging:
+                return log
+            return True
+        elif logging:
+            return log
+        return False
+
+
+__all__ = ['FixMapper']

chython/algorithms/mapping/groups.py

@@ -0,0 +1,137 @@
+# -*- 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/>.
+#
+from itertools import chain, repeat
+from typing import List, Tuple, TYPE_CHECKING, Union
+from ._groups import *
+
+
+if TYPE_CHECKING:
+    from chython import ReactionContainer
+
+
+class GroupsFix:
+    __slots__ = ()
+
+    def fix_groups_mapping(self: 'ReactionContainer', *, logging: bool = False) -> \
+            Union[bool, List[Tuple[str, Tuple[int, ...]]]]:
+        """
+        Fix atom-to-atom mapping of some functional groups. Return True if found AAM errors.
+        """
+        if not self:
+            if logging:
+                return []
+            return False
+
+        log = []
+        seen = set()
+        remap = {}
+        pamer = {}
+        r_groups = set()
+        p_groups = set()
+        r_subs = set()
+        p_subs = set()
+
+        # find xonyl groups. any charged-neutral combinations
+        for pattern in xonyl_groups:
+            for m, g in chain(zip(self.reactants, repeat(r_groups)), zip(self.products, repeat(p_groups))):
+                atoms = m._atoms
+                for mapping in pattern.get_mapping(m, automorphism_filter=False):
+                    n1, n2, n3 = mapping[1], mapping[2], mapping[3]
+                    if (t := atoms[n2].atomic_number) == atoms[n3].atomic_number:
+                        g.add((n1, n2, n3, atoms[n1].atomic_number, t))
+
+        for pattern, _map in substituents_groups:
+            for m, g in chain(zip(self.reactants, repeat(r_subs)), zip(self.products, repeat(p_subs))):
+                atoms = m._atoms
+                for mapping in pattern.get_mapping(m, automorphism_filter=False):
+                    g.add((n := mapping[1], atoms[n].atomic_number,
+                           tuple((n := mapping[x], y - 2, atoms[n].atomic_number) for x, y in _map), m))
+
+        r_groups = list(r_groups)
+        p_groups = list(p_groups)
+
+        # find pairs
+        if r_groups and p_groups:
+            for n1, n2, n3, x1, x2 in r_groups:
+                if n1 in seen:  # already remapped
+                    continue
+                for i, (m1, m2, m3, y1, y2) in enumerate(p_groups):
+                    if m1 not in seen and n1 == m1 and x1 == y1 and x2 == y2:  # found pair
+                        if n2 == m3 and n3 == m2:  # found switch
+                            remap[m2] = m3
+                            remap[m3] = m2
+                            seen.add(n1)
+                        break
+                else:
+                    continue
+                del p_groups[i]
+
+        if not p_groups:  # optimize
+            r_subs.clear()
+
+        # hydrolysis, etc.
+        for (n1, x1, _map, m), g, r in chain(zip(r_subs, repeat(p_groups), repeat(remap)),
+                                             zip(p_subs, repeat(r_groups), repeat(pamer))):
+            if n1 in seen:
+                continue
+            for i, (m1, *m23, y1, y2) in enumerate(g):
+                if m1 not in seen and n1 == m1 and x1 == y1:  # found center
+                    if len(_map) == 1:  # acids substitutions.
+                        ni, _, xi = _map[0]
+                        # second neighbor should be disconnected from central atom.
+                        if xi == y2 and m23[0] == ni and (m23[1] not in m._atoms or m23[1] not in m._bonds[n1]):
+                            m2, m3 = m23
+                            r[m2] = m3
+                            r[m3] = m2
+                            seen.add(n1)
+                            break
+                    elif all(xi == y2 and m23[mi] == ni for ni, mi, xi in _map):
+                        m2, m3 = m23
+                        r[m2] = m3
+                        r[m3] = m2
+                        seen.add(n1)
+                        break
+            else:
+                continue
+            del g[i]
+
+        if remap:
+            seen = set(remap)
+            for m in self.products:
+                if not seen.isdisjoint(m):
+                    m.remap(remap)
+            log.append(('products groups remapped', tuple(remap)))
+        if pamer:
+            seen = set(pamer)
+            for m in self.reactants:
+                if not seen.isdisjoint(m):
+                    m.remap(pamer)
+            log.append(('reactants groups remapped', tuple(pamer)))
+
+        if log:
+            self.flush_cache()
+            if logging:
+                return log
+            return True
+        elif logging:
+            return []
+        return False
+
+
+__all__ = ['GroupsFix']