aamutils 0.0.3__tar.gz → 0.0.5__tar.gz

{aamutils-0.0.3 → aamutils-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: aamutils
-Version: 0.0.3
+Version: 0.0.5
 Summary: Collection of atom-atom-mapping utility functions.
 Project-URL: homepage, https://github.com/klausweinbauer/AAMUtils
 Project-URL: source, https://github.com/klausweinbauer/AAMUtils
@@ -78,18 +78,18 @@ reported results can be reproduced by running the following commands:
 ### (1) Extend partial reaction center (50%, 75% and 100% missing atoms)  
 
 ```
-python3 benchmark.py --remove-mode rc --remove-ratio 0.5
+python3 benchmark.py --remove-mode rc --remove-ratio 0.5 --seed 42
 ```
 ```
-python3 benchmark.py --remove-mode rc --remove-ratio 0.75
+python3 benchmark.py --remove-mode rc --remove-ratio 0.75 --seed 42
 ```
 ```
-python3 benchmark.py --remove-mode rc --remove-ratio 1
+python3 benchmark.py --remove-mode rc --remove-ratio 1 --seed 42
 ```
 
 ### (2) Extend partial AAM with fully mapped RC 
 ```
-python3 benchmark.py --remove-mode keep_rc --remove-ratio 1
+python3 benchmark.py --remove-mode keep_rc --remove-ratio 1 --seed 42
 ```
 
 

{aamutils-0.0.3 → aamutils-0.0.5}/README.md

@@ -56,18 +56,18 @@ reported results can be reproduced by running the following commands:
 ### (1) Extend partial reaction center (50%, 75% and 100% missing atoms)  
 
 ```
-python3 benchmark.py --remove-mode rc --remove-ratio 0.5
+python3 benchmark.py --remove-mode rc --remove-ratio 0.5 --seed 42
 ```
 ```
-python3 benchmark.py --remove-mode rc --remove-ratio 0.75
+python3 benchmark.py --remove-mode rc --remove-ratio 0.75 --seed 42
 ```
 ```
-python3 benchmark.py --remove-mode rc --remove-ratio 1
+python3 benchmark.py --remove-mode rc --remove-ratio 1 --seed 42
 ```
 
 ### (2) Extend partial AAM with fully mapped RC 
 ```
-python3 benchmark.py --remove-mode keep_rc --remove-ratio 1
+python3 benchmark.py --remove-mode keep_rc --remove-ratio 1 --seed 42
 ```
 
 

aamutils-0.0.5/aamutils/__init__.py

@@ -0,0 +1 @@
+from .mapping import Mapper

{aamutils-0.0.3 → aamutils-0.0.5}/aamutils/algorithm/ilp.py

@@ -57,19 +57,48 @@ def _indicator_constraint(problem, D, G, S, k):
         for j in range(m):
             problem += (
                 D[i, j] <= k * G[i, j],
-                "g_indicator_constraint_lower_{}-{}".format(i, j),
+                "g_indicator_constraint1_{}-{}".format(i, j),
+            )
+            problem += (
+                D[i, j] >= -k + G[i, j] * (k + 1),
+                "g_indicator_constraint2_{}-{}".format(i, j),
             )
             problem += (
                 -D[i, j] <= k * S[i, j],
-                "s_indicator_constraint_lower_{}-{}".format(i, j),
+                "s_indicator_constraint1_{}-{}".format(i, j),
+            )
+            problem += (
+                -D[i, j] >= -k + S[i, j] * (k + 1),
+                "s_indicator_constraint2_{}-{}".format(i, j),
             )
 
 
+def _expected_rc_atoms_constraint(problem, G, S, expected_rc_atoms):
+    m = int(np.sqrt(len(G.keys())))
+    assert m == int(np.sqrt(len(S.keys())))
+
+    lp_io = lp.LpVariable.dicts("io", [i for i in range(m)], cat=lp.LpInteger)
+    lp_rc = lp.LpVariable.dicts("rc", [i for i in range(m)], cat=lp.LpBinary)
+    for i in range(m):
+        problem += (
+            lp_io[i] == lp.lpSum([G[i, j] + S[i, j] for j in range(m)]),
+            "idx_io_sum_{}".format(i),
+        )
+        problem += (lp_io[i] <= m * lp_rc[i], "is_rc_indicator1_{}".format(i))
+        problem += (lp_io[i] >= lp_rc[i], "is_rc_indicator_{}".format(i))
+
+    problem += (
+        expected_rc_atoms == lp.lpSum([lp_rc[i] for i in range(m)]),
+        "rc_atom_constraint",
+    )
+
+
 def expand_partial_aam_balanced(
     G: nx.Graph,
     H: nx.Graph,
     beta_map: None | list[tuple[int, int, int]] = None,
     bond_key="bond",
+    expected_rc: None | tuple[None | int, None | int] = None,
 ) -> tuple[np.ndarray, str, float]:
     """Function to extend the partial atom-atom map beta of the balanced
     reaction G \u2192 H to a full atom-atom map based on the Minimal Chemical
@@ -81,6 +110,14 @@ def expand_partial_aam_balanced(
         specified the existing mapping in G and H will be used.
     :param bond_key: (optional) The edge label in G and H which encodes the
         bond order.
+    :param expected_rc: (optional) Configuration for the expected reaction
+        center. The first parameter in the tuple is the number of atoms and
+        the second parameter is the number of bonds. The atoms and bonds are
+        only constraint if the value is not None. It is possible to constraint
+        only atoms or only bonds. Constraining the expected reaction center can
+        help to get correct AAM for reactions where the Minimal Chemical
+        Distance is unsuitable, e.g. for a Diels-Alder reaction you can set
+        expected_rc to (6, 6).
 
     :returns: A 3-tuple. The first element is the mapping matrix X. The second
         element is the status string of the ILP solver (e.g. 'Optimal') and the
@@ -134,6 +171,14 @@ def expand_partial_aam_balanced(
         lp_f == lp.lpSum([lp_G[i, j] + lp_S[i, j] for i in range(m) for j in range(m)]),
         "objective",
     )
+    if expected_rc is not None:
+        if not isinstance(expected_rc, tuple) or len(expected_rc) != 2:
+            raise ValueError("Argument expected_rc must be a tuple of size 2.")
+        expected_rc_atoms, expected_rc_bonds = expected_rc
+        if expected_rc_bonds is not None:
+            problem += (lp_f == 2 * expected_rc_bonds, "rc_bond_constraint")
+        if expected_rc_atoms is not None:
+            _expected_rc_atoms_constraint(problem, lp_G, lp_S, expected_rc_atoms)
 
     _bijection_constraint(problem, lp_X)
     _beta_constraint(problem, lp_X, beta_map)

aamutils-0.0.5/aamutils/mapping.py

@@ -0,0 +1,55 @@
+import rdkit.Chem.rdmolops as rdmolops
+import rdkit.Chem.rdmolfiles as rdmolfiles
+
+from aamutils.utils import graph_to_mol, mol_to_graph, set_aam
+from aamutils.algorithm.ilp import expand_partial_aam_balanced
+
+
+class Mapper:
+    def __init__(self, include_H=False):
+        self.include_H = include_H
+
+    def _map_rxn(self, rxn_smiles: str, expected_rc):
+        g_smiles, h_smiles = rxn_smiles.split(">>")
+        g_mol = rdmolfiles.MolFromSmiles(g_smiles)
+        h_mol = rdmolfiles.MolFromSmiles(h_smiles)
+        if self.include_H:
+            g_mol = rdmolops.AddHs(g_mol, 0)
+            h_mol = rdmolops.AddHs(h_mol, 0)
+        G = mol_to_graph(g_mol)
+        H = mol_to_graph(h_mol)
+
+        M, status, e_diff = expand_partial_aam_balanced(G, H, expected_rc=expected_rc)
+
+        set_aam(G, H, M)
+
+        g_mol = graph_to_mol(G)
+        h_mol = graph_to_mol(H)
+
+        aam_smiles = "{}>>{}".format(
+            rdmolfiles.MolToSmiles(g_mol), rdmolfiles.MolToSmiles(h_mol)
+        )
+        return aam_smiles
+
+    def get_aam(self, smiles: str | list[str], expected_rc) -> str | list[str]:
+        return_list = True
+        if isinstance(smiles, str):
+            smiles = [smiles]
+            return_list = False
+        if expected_rc is None:
+            expected_rc = [None for _ in range(len(smiles))]
+        elif not isinstance(expected_rc, list):
+            expected_rc = [expected_rc]
+        if len(smiles) != len(expected_rc):
+            raise ValueError(
+                "Argument min_bonds must be of same length ({}) as smiles.".format(
+                    len(smiles)
+                )
+            )
+        aam_smiles = []
+        print(expected_rc)
+        for smiles, exp_rc in zip(smiles, expected_rc):
+            aam_smiles.append(self._map_rxn(smiles, expected_rc=exp_rc))
+        if not return_list:
+            return aam_smiles[0]
+        return aam_smiles

{aamutils-0.0.3 → aamutils-0.0.5}/aamutils/utils.py

@@ -3,6 +3,7 @@ import numpy as np
 import networkx as nx
 import rdkit.Chem as Chem
 import rdkit.Chem.rdmolfiles as rdmolfiles
+import rdkit.Chem.rdDepictor as rdDepictor
 
 
 def mol_to_graph(mol: Chem.rdchem.Mol) -> nx.Graph:
@@ -26,6 +27,16 @@ def mol_to_graph(mol: Chem.rdchem.Mol) -> nx.Graph:
     return g
 
 
+def smiles_to_graph(smiles: str) -> nx.Graph | tuple[nx.Graph, nx.Graph]:
+    if ">>" in smiles:
+        smiles_token = smiles.split(">>")
+        g = mol_to_graph(rdmolfiles.MolFromSmiles(smiles_token[0]))
+        h = mol_to_graph(rdmolfiles.MolFromSmiles(smiles_token[1]))
+        return g, h
+    else:
+        return mol_to_graph(rdmolfiles.MolFromSmiles(smiles))
+
+
 def graph_to_mol(
     G: nx.Graph, symbol_key="symbol", aam_key="aam", bond_type_key="bond"
 ) -> Chem.rdchem.Mol:
@@ -37,13 +48,16 @@ def graph_to_mol(
         1.5: Chem.rdchem.BondType.AROMATIC,
     }
     rw_mol = Chem.rdchem.RWMol()
+    idx_map = {}
     for n, d in G.nodes(data=True):
         idx = rw_mol.AddAtom(Chem.rdchem.Atom(d[symbol_key]))
+        idx_map[n] = idx
         if aam_key in d.keys() and d[aam_key] >= 0:
             rw_mol.GetAtomWithIdx(idx).SetAtomMapNum(d[aam_key])
-        assert n == idx
     for n1, n2, d in G.edges(data=True):
-        rw_mol.AddBond(n1, n2, bond_order_map[d[bond_type_key]])
+        idx1 = idx_map[n1]
+        idx2 = idx_map[n2]
+        rw_mol.AddBond(idx1, idx2, bond_order_map[d[bond_type_key]])
     return rw_mol.GetMol()
 
 
@@ -123,3 +137,51 @@ def print_graph(graph):
             )
         )
     )
+
+
+def its2mol(its: nx.Graph, aam_key="aam", bond_key="bond") -> Chem.rdchem.Mol:
+    _its = its.copy()
+    for n in _its.nodes:
+        _its.nodes[n][aam_key] = n
+    for u, v in _its.edges():
+        _its[u][v][bond_key] = 1
+    return graph_to_mol(_its)
+
+
+def plot_its(
+    its, ax, bond_key="bond", aam_key="aam", symbol_key="symbol", use_mol_coords=True
+):
+    bond_char = {None: "∅", 1: "—", 2: "=", 3: "≡"}
+    mol = its2mol(its, aam_key=aam_key, bond_key=bond_key)
+
+    if use_mol_coords:
+        positions = {}
+        conformer = rdDepictor.Compute2DCoords(mol)
+        for i, atom in enumerate(mol.GetAtoms()):
+            aam = atom.GetAtomMapNum()
+            apos = mol.GetConformer(conformer).GetAtomPosition(i)
+            positions[aam] = [apos.x, apos.y]
+    else:
+        positions = nx.spring_layout(its)
+
+    ax.axis("equal")
+    ax.axis("off")
+
+    nx.draw_networkx_edges(its, positions, edge_color="#000000", ax=ax)
+    nx.draw_networkx_nodes(its, positions, node_color="#FFFFFF", node_size=500, ax=ax)
+
+    labels = {n: "{}:{}".format(d[symbol_key], n) for n, d in its.nodes(data=True)}
+    edge_labels = {}
+    for u, v, d in its.edges(data=True):
+        bc1 = d[bond_key][0]
+        bc2 = d[bond_key][1]
+        if bc1 == bc2:
+            continue
+        if bc1 in bond_char.keys():
+            bc1 = bond_char[bc1]
+        if bc2 in bond_char.keys():
+            bc2 = bond_char[bc2]
+        edge_labels[(u, v)] = "({},{})".format(bc1, bc2)
+
+    nx.draw_networkx_labels(its, positions, labels=labels, ax=ax)
+    nx.draw_networkx_edge_labels(its, positions, edge_labels=edge_labels, ax=ax)

{aamutils-0.0.3 → aamutils-0.0.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "aamutils"
-version = "0.0.3"
+version = "0.0.5"
 authors = [
 	{name="Klaus Weinbauer", email="klaus@bioinf.uni-leipzig.de"}
 	]

{aamutils-0.0.3 → aamutils-0.0.5}/test/algorithm/test_ilp.py

@@ -34,26 +34,6 @@ def test_example1():
     np.testing.assert_array_equal(X, exp_X)
 
 
-def test_example1_without_aam():
-    # The tested mapping is not correct. This is to show equal solutions based
-    # on the implemented optimization criterion. The correct mapping is in
-    # test_example1()
-    mol_G = rdmolfiles.MolFromSmiles("CCC[Cl].[N]")
-    mol_H = rdmolfiles.MolFromSmiles("CCC[N].[Cl]")
-    exp_X = np.zeros((5, 5))
-    exp_X[0, 2] = 1
-    exp_X[1, 1] = 1
-    exp_X[2, 0] = 1
-    exp_X[3, 4] = 1
-    exp_X[4, 3] = 1
-    G = mol_to_graph(mol_G)
-    H = mol_to_graph(mol_H)
-    X, status, v = expand_partial_aam_balanced(G, H)
-    assert 4 == v
-    assert "Optimal" == status
-    np.testing.assert_array_equal(X, exp_X)
-
-
 def test_example2_m1():
     mol_G = rdmolfiles.MolFromSmiles("[C:1][C:2]=[C:3][C:4]")
     mol_H = rdmolfiles.MolFromSmiles("[C:1].[C:2]=[C:4][C:3]")
@@ -73,11 +53,7 @@ def test_example2_m1():
 def test_example2_m2():
     mol_G = rdmolfiles.MolFromSmiles("CC=CC")
     mol_H = rdmolfiles.MolFromSmiles("C.C=CC")
-    exp_X = np.zeros((4, 4))
-    exp_X[0, 3] = 1
-    exp_X[1, 2] = 1
-    exp_X[2, 1] = 1
-    exp_X[3, 0] = 1
+    exp_X = np.eye(4)
     G = mol_to_graph(mol_G)
     H = mol_to_graph(mol_H)
     X, status, v = expand_partial_aam_balanced(G, H)

aamutils-0.0.5/test/test_mapping.py

@@ -0,0 +1,16 @@
+from aamutils.mapping import Mapper
+from aamutils.algorithm.aaming import get_its, get_rc
+from aamutils.utils import smiles_to_graph
+
+
+def test_mapper_with_expected_rc():
+    # Diels-Alder reaction example
+    smiles = "C1=CC=CC1.C1=CC=CC1>>C1=CC2CC1C3C2C=CC3"
+    mapper = Mapper()
+    aam_smiles = mapper.get_aam(smiles, expected_rc=(6, 6))
+    assert isinstance(aam_smiles, str)
+    g, h = smiles_to_graph(aam_smiles)
+    its = get_its(g, h)
+    rc = get_rc(its)
+    assert len(rc.nodes) == 6
+    assert len(rc.edges) == 6