chython 2.19__cp313-cp313-win_amd64.whl

chython/algorithms/mapping/__init__.py

@@ -0,0 +1,188 @@
+# -*- 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 ChainMap
+from itertools import count , chain, repeat
+from .attention import Attention
+from .reconstruct import Reconstruct
+from ._groups import xonyl_groups, substituents_groups
+from ._reactions import rules
+
+
+class Mapping(Reconstruct, Attention):
+    __slots__ = ()
+
+    def reset_mapping(self) -> bool:
+        """
+        Reset atom-to-atom mapping by remapping atoms to unique numbers.
+        """
+        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 fix_mapping(self, *, logging: bool = False) -> bool | list:
+        """
+        Fix mapping of plipped functional groups and common mechanism errors.
+        """
+        if not self:
+            if logging:
+                return []
+            return False
+        log = self.__fix_groups()
+        log.extend(self.__fix_cgr())
+        if logging:
+            return log
+        return bool(log)
+
+    def __fix_cgr(self):
+        cgr = ~self
+        if not cgr.center_atoms:
+            return []
+
+        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()
+        return log
+
+    def __fix_groups(self):
+        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()
+        return log
+
+
+__all__ = ['Mapping']

chython/algorithms/mapping/_groups.py

@@ -0,0 +1,94 @@
+# -*- 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 _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-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 _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,266 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2022-2026 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 functools import cache
+from itertools import repeat
+from logging import getLogger, INFO
+from numpy import array, argmax, clip, concatenate, int32, int64, isclose, ix_, mean, nan_to_num
+from numpy import nonzero, ones, unravel_index, zeros
+from scipy.sparse.csgraph import shortest_path
+
+logger = getLogger('chython.attention')
+logger.setLevel(INFO)
+
+_max_distance = 10
+_max_neighbors = 14
+
+
+@cache
+def _get_session():
+    import onnxruntime as ort
+    from os import cpu_count
+
+    try:
+        from chython_rxnmap import model_path
+    except ImportError:
+        raise ImportError('chython-rxnmap package is required for attention mapping. '
+                          'Install it with: pip install chython-rxnmap')
+
+    opts = ort.SessionOptions()
+    opts.inter_op_num_threads = 1
+    opts.intra_op_num_threads = min(cpu_count() or 4, 8)
+    opts.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+    return ort.InferenceSession(model_path, opts, providers=['CPUExecutionProvider'])
+
+
+def _run_model(reactants, products, p2r, r2p, equal_atoms):
+    """Run ONNX model on reaction, return symmetrized attention filtered by atom type."""
+    atoms, neighbors, distances, roles = _encode_reaction(reactants, products)
+    am = _get_session().run(None, {
+        'atoms': atoms[None].astype(int64),
+        'neighbors': neighbors[None].astype(int64),
+        'distances': distances[None].astype(int64),
+        'roles': roles[None].astype(int64),
+    })[0]
+    return (am[p2r] + am[r2p].T) * equal_atoms
+
+
+def _encode_reaction(reactants, products):
+    """Encode reaction into model input tensors (atoms, neighbors, distances, roles)."""
+    atoms_list = [array([0], dtype=int32)]  # rxn_cls
+    neighbors_list = [array([0], dtype=int32)]
+    roles_list = [1]  # rxn_cls role
+    distances_list = []
+
+    for mol in reactants:
+        a, n, d = _encode_molecule(mol)
+        atoms_list.append(a)
+        neighbors_list.append(n)
+        distances_list.append(d)
+        roles_list.append(0)  # mol_cls (hidden)
+        roles_list.extend(repeat(2, len(mol)))
+
+    for mol in products:
+        a, n, d = _encode_molecule(mol)
+        atoms_list.append(a)
+        neighbors_list.append(n)
+        distances_list.append(d)
+        roles_list.append(0)
+        roles_list.extend(repeat(3, len(mol)))
+
+    atoms = concatenate(atoms_list)
+    neighbors = concatenate(neighbors_list)
+    roles = array(roles_list, dtype=int32)
+
+    total = len(roles)
+    distances = zeros((total, total), dtype=int32)
+    distances[0, 0] = 1  # rxn_cls self-loop
+    i = 1
+    for d in distances_list:
+        j = i + d.shape[0]
+        distances[i:j, i:j] = d
+        i = j
+
+    return atoms, neighbors, distances, roles
+
+
+def _encode_molecule(mol):
+    """Encode molecule into (atoms, neighbors, distances) tensors.
+
+    Encoding:
+        atoms: 0=padding, 1=mol_cls, 2+=atomic_number+2
+        neighbors: 0=cls, 2+=neighbor_count+2
+        distances: 0=padding, 1=unreachable/cross-component, 2+=shortest_path+2
+    """
+    n_atoms = len(mol)
+    size = n_atoms + 1  # +1 for mol_cls
+
+    atoms = zeros(size, dtype=int32)
+    neighbors = zeros(size, dtype=int32)
+    atoms[0] = 1  # mol_cls
+
+    bonds = mol._bonds
+    for i, (n, a) in enumerate(mol.atoms(), 1):
+        atoms[i] = a.atomic_number + 2
+        nb = len(bonds[n]) + (a.implicit_hydrogens or 0)
+        if nb > _max_neighbors:
+            nb = _max_neighbors
+        neighbors[i] = nb + 2
+
+    adj = mol.adjacency_matrix()
+    dist = shortest_path(adj, method='FW', directed=False, unweighted=True)
+    nan_to_num(dist, copy=False, posinf=1.0)  # unreachable -> 1 (cross-component attention)
+    clip(dist, None, _max_distance, out=dist)
+    dist = (dist + 2).astype(int32)
+
+    distances = ones((size, size), dtype=int32)  # mol_cls distance=1 to all atoms
+    distances[1:, 1:] = dist
+    return atoms, neighbors, distances
+
+
+def _prepare_masks(reactants, products, reagents):
+    """Build atom maps, adjacency matrices, element-equality mask, and token-level index slices."""
+    r_map = [n for m in reactants for n in m]
+    p_map = [n for m in products for n in m]
+    rg_map = [n for m in reagents for n in m]
+    ra = len(r_map)
+    pa = len(p_map)
+
+    # token layout: [rxn_cls, mol_cls_1, atoms_1, ..., mol_cls_n, atoms_n, ...]
+    ram = [False]  # rxn_cls
+    r_atoms = []
+    r_adj = zeros((ra, ra), dtype=bool)
+    i = 0
+    for m in reactants:
+        ram.append(False)  # mol_cls
+        ram.extend(repeat(True, len(m)))
+        j = i + len(m)
+        r_adj[i:j, i:j] = m.adjacency_matrix()
+        i = j
+        r_atoms.extend(a.atomic_number for _, a in m.atoms())
+
+    pam = [False] * len(ram)
+    p_atoms = []
+    p_adj = zeros((pa, pa), dtype=bool)
+    i = 0
+    for m in products:
+        pam.append(False)
+        pam.extend(repeat(True, len(m)))
+        j = i + len(m)
+        p_adj[i:j, i:j] = m.adjacency_matrix()
+        i = j
+        p_atoms.extend(a.atomic_number for _, a in m.atoms())
+
+    ram.extend(repeat(False, len(pam) - len(ram)))
+    ram = array(ram, dtype=bool)
+    pam = array(pam, dtype=bool)
+    r_atoms = array(r_atoms, dtype=int)
+    p_atoms = array(p_atoms, dtype=int)
+
+    equal_atoms = p_atoms[:, None] == r_atoms
+    return r_map, p_map, rg_map, equal_atoms, ix_(pam, ram), ix_(ram, pam), r_adj, p_adj
+
+
+def _greedy_mapping(am, r_map, p_map, r_adj, p_adj, multiplier):
+    """Greedy attention-based product-to-reactant atom assignment."""
+    amc = am.copy()
+    pa = len(p_map)
+    mapping = {}
+    scope = zeros(pa, dtype=bool)
+    seen = ones(pa, dtype=bool)
+    score = []
+
+    for x in range(pa):
+        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.):
+            for n in set(p_map).difference(mapping):
+                mapping[n] = 0
+            break
+
+        score.append(amc[i, j])
+        mapping[p_map[i]] = r_map[j]
+        am[ix_(p_adj[i], r_adj[j])] *= multiplier
+        am[i] = am[:, j] = 0
+        seen[i] = False
+        scope[i] = False
+        scope[p_adj[i] & seen] = True
+
+    return mapping, float(mean(score)) if score else 0.
+
+
+class Attention:
+    __slots__ = ()
+
+    def attention_mapping(self, *, return_score: bool = False, multiplier=1.75,
+                          keep_reactants_numbering=False) -> bool | float:
+        """Do atom-to-atom mapping. Return True if mapping changed."""
+        if any(len(bs) > _max_neighbors 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.reset_mapping()
+        r_map, p_map, rg_map, equal_atoms, p2r, r2p, r_adj, p_adj = _prepare_masks(
+            self.reactants, self.products, self.reagents
+        )
+
+        am = _run_model(self.reactants, self.products, p2r, r2p, equal_atoms)
+        mapping, score = _greedy_mapping(am, r_map, p_map, r_adj, p_adj, multiplier)
+
+        if any(n != m for n, m in mapping.items()):
+            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)}
+                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:
+                    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)}
+                for m in self.reagents:
+                    m.remap(rg_mapping)
+
+            self.flush_cache()
+            fixed = True
+
+        if self.fix_mapping():
+            fixed = True
+        return score if return_score else fixed
+
+
+__all__ = ['Attention']