aamutils 0.0.4__tar.gz → 0.0.6__tar.gz

{aamutils-0.0.4 → aamutils-0.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: aamutils
-Version: 0.0.4
+Version: 0.0.6
 Summary: Collection of atom-atom-mapping utility functions.
 Project-URL: homepage, https://github.com/klausweinbauer/AAMUtils
 Project-URL: source, https://github.com/klausweinbauer/AAMUtils

aamutils-0.0.6/aamutils/__init__.py

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

{aamutils-0.0.4 → aamutils-0.0.6}/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.6/aamutils/mapping.py

@@ -0,0 +1,56 @@
+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)
+        if status != "Optimal":
+            return None
+
+        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=None) -> 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 = []
+        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.4 → aamutils-0.0.6}/aamutils/utils.py

@@ -148,16 +148,21 @@ def its2mol(its: nx.Graph, aam_key="aam", bond_key="bond") -> Chem.rdchem.Mol:
     return graph_to_mol(_its)
 
 
-def plot_its(its, ax, bond_key="bond", aam_key="aam", symbol_key="symbol"):
+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)
 
-    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]
+    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")

{aamutils-0.0.4 → aamutils-0.0.6}/pyproject.toml

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

{aamutils-0.0.4 → aamutils-0.0.6}/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.6/test/test_mapping.py

@@ -0,0 +1,23 @@
+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
+
+
+def test_mapper_infeasable():
+    smiles = "C>>C"
+    mapper = Mapper()
+    aam_smiles = mapper.get_aam(smiles, expected_rc=(2, 2))
+    assert aam_smiles is None