synkit 0.0.13__tar.gz → 0.0.15__tar.gz

{synkit-0.0.13 → synkit-0.0.15}/.github/workflows/test-and-lint.yml

@@ -2,7 +2,7 @@ name: Test & Lint
 
 on:
   push:
-    branches: [ "main", "dev", "staging", "refractor" ]
+    branches: [ "main", "partialits", "staging", "refractor" ]
   pull_request:
     branches: [ "main" ]
 

{synkit-0.0.13 → synkit-0.0.15}/.gitignore

@@ -6,14 +6,10 @@
 *.json
 *.pkl.gz
 *.pdf
-out
-summary
 *.log
 .coverage
 dev/*
 *.rdf
-Data/Testcase/hydro/aam.json.gz
-synkit/Chem/FG/*
 test_syn_reactor.py
 Data/Benchmark/*
 # *.png
@@ -22,3 +18,6 @@ run.sh
 docs/*
 run_rdcanon.py
 Data/Fragment/*
+test_partial.py
+Data/Benchmark/synthesis/*
+Data/USPTO/*

{synkit-0.0.13 → synkit-0.0.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synkit
-Version: 0.0.13
+Version: 0.0.15
 Summary: Utility for reaction modeling using graph grammar
 Project-URL: homepage, https://github.com/TieuLongPhan/SynKit
 Project-URL: source, https://github.com/TieuLongPhan/SynKit
@@ -30,6 +30,17 @@ Requires-Dist: sphinxcontrib-bibtex; extra == 'docs'
 Description-Content-Type: text/markdown
 
 # SynKit
+[![PyPI version](https://img.shields.io/pypi/v/synkit.svg)](https://pypi.org/project/synkit/)
+[![Conda version](https://img.shields.io/conda/vn/tieulongphan/synkit.svg)](https://anaconda.org/tieulongphan/synkit)
+[![Docker Pulls](https://img.shields.io/docker/pulls/tieulongphan/synkit.svg)](https://hub.docker.com/r/tieulongphan/synkit)
+[![Docker Image Version](https://img.shields.io/docker/v/tieulongphan/synkit/latest?label=container)](https://hub.docker.com/r/tieulongphan/synkit)
+[![License](https://img.shields.io/github/license/tieulongphan/synkit.svg)](https://github.com/tieulongphan/synkit/blob/main/LICENSE)
+[![Release](https://img.shields.io/github/v/release/tieulongphan/synkit.svg)](https://github.com/tieulongphan/synkit/releases)
+[![Last Commit](https://img.shields.io/github/last-commit/tieulongphan/synkit.svg)](https://github.com/tieulongphan/synkit/commits)
+[![Zenodo](https://zenodo.org/badge/DOI/10.5281/zenodo.15269901.svg)](https://doi.org/10.5281/zenodo.15269901)
+[![CI](https://github.com/tieulongphan/synkit/actions/workflows/test-and-lint.yml/badge.svg?branch=main)](https://github.com/tieulongphan/synkit/actions/workflows/test-and-lint.yml)
+[![Dependency PRs](https://img.shields.io/github/issues-pr-raw/tieulongphan/synkit?label=dependency%20PRs)](https://github.com/tieulongphan/synkit/pulls?q=is%3Apr+label%3Adependencies)
+[![Stars](https://img.shields.io/github/stars/tieulongphan/synkit.svg?style=social&label=Star)](https://github.com/tieulongphan/synkit/stargazers)
 
 **Toolkit for Synthesis Planning**
 

{synkit-0.0.13 → synkit-0.0.15}/README.md

@@ -1,4 +1,15 @@
 # SynKit
+[![PyPI version](https://img.shields.io/pypi/v/synkit.svg)](https://pypi.org/project/synkit/)
+[![Conda version](https://img.shields.io/conda/vn/tieulongphan/synkit.svg)](https://anaconda.org/tieulongphan/synkit)
+[![Docker Pulls](https://img.shields.io/docker/pulls/tieulongphan/synkit.svg)](https://hub.docker.com/r/tieulongphan/synkit)
+[![Docker Image Version](https://img.shields.io/docker/v/tieulongphan/synkit/latest?label=container)](https://hub.docker.com/r/tieulongphan/synkit)
+[![License](https://img.shields.io/github/license/tieulongphan/synkit.svg)](https://github.com/tieulongphan/synkit/blob/main/LICENSE)
+[![Release](https://img.shields.io/github/v/release/tieulongphan/synkit.svg)](https://github.com/tieulongphan/synkit/releases)
+[![Last Commit](https://img.shields.io/github/last-commit/tieulongphan/synkit.svg)](https://github.com/tieulongphan/synkit/commits)
+[![Zenodo](https://zenodo.org/badge/DOI/10.5281/zenodo.15269901.svg)](https://doi.org/10.5281/zenodo.15269901)
+[![CI](https://github.com/tieulongphan/synkit/actions/workflows/test-and-lint.yml/badge.svg?branch=main)](https://github.com/tieulongphan/synkit/actions/workflows/test-and-lint.yml)
+[![Dependency PRs](https://img.shields.io/github/issues-pr-raw/tieulongphan/synkit?label=dependency%20PRs)](https://github.com/tieulongphan/synkit/pulls?q=is%3Apr+label%3Adependencies)
+[![Stars](https://img.shields.io/github/stars/tieulongphan/synkit.svg?style=social&label=Star)](https://github.com/tieulongphan/synkit/stargazers)
 
 **Toolkit for Synthesis Planning**
 

{synkit-0.0.13 → synkit-0.0.15}/Test/Graph/ITS/test_its_construction.py

@@ -31,20 +31,20 @@ class TestITSConstruction(unittest.TestCase):
         attributes = ITSConstruction().get_node_attributes_with_defaults(self.G, 1)
         self.assertEqual(attributes, ("C", False, 2, 0, ["", ""]))
 
-    def test_add_edges_to_ITS(self):
-        ITS = nx.Graph()
-        ITS.add_node(1, element="C", aromatic=False, hcount=3, charge=0)
-        ITS.add_node(2, element="C", aromatic=False, hcount=3, charge=0)
-        new_ITS = ITSConstruction().add_edges_to_ITS(ITS, self.G, self.H)
-        self.assertTrue(isinstance(new_ITS, nx.Graph))
-        self.assertEqual(len(new_ITS.edges()), 1)
-        self.assertEqual(new_ITS[1][2]["order"], (2, 1))
-
-    def test_add_standard_order_attribute(self):
-        graph = nx.Graph()
-        graph.add_edge(1, 2, order=(1, 2))
-        updated_graph = ITSConstruction().add_standard_order_attribute(graph)
-        self.assertEqual(updated_graph[1][2]["standard_order"], -1)
+    # def test_add_edges_to_ITS(self):
+    #     ITS = nx.Graph()
+    #     ITS.add_node(1, element="C", aromatic=False, hcount=3, charge=0)
+    #     ITS.add_node(2, element="C", aromatic=False, hcount=3, charge=0)
+    #     new_ITS = ITSConstruction().add_edges_to_ITS(ITS, self.G, self.H)
+    #     self.assertTrue(isinstance(new_ITS, nx.Graph))
+    #     self.assertEqual(len(new_ITS.edges()), 1)
+    #     self.assertEqual(new_ITS[1][2]["order"], (2, 1))
+
+    # def test_add_standard_order_attribute(self):
+    #     graph = nx.Graph()
+    #     graph.add_edge(1, 2, order=(1, 2))
+    #     updated_graph = ITSConstruction().add_standard_order_attribute(graph)
+    #     self.assertEqual(updated_graph[1][2]["standard_order"], -1)
 
 
 if __name__ == "__main__":

{synkit-0.0.13 → synkit-0.0.15}/Test/Graph/MTG/test_mtg.py

@@ -20,19 +20,17 @@ class TestMTG(unittest.TestCase):
         self.test_graph_2 = [get_rc(rsmi_to_its(var)) for var in test_2]
 
     def test_MTG_1(self):
-        grp = GroupComp(self.test_graph_1[0], self.test_graph_1[1])
-        candidates = grp.get_mapping()
-        print(candidates)
-        mtg = MTG(self.test_graph_1[0], self.test_graph_1[1], candidates[0])
-        self.assertEqual(len(mtg.get_nodes()), 6)
-        self.assertEqual(len(mtg.get_edges()), 7)
+        mtg = MTG(self.test_graph_1[0:2], mcs_mol=True)
+        self.assertEqual(mtg._graph.number_of_nodes(), 6)
+        self.assertEqual(mtg._graph.number_of_edges(), 7)
 
     def test_MTG_2(self):
         grp = GroupComp(self.test_graph_2[0], self.test_graph_2[1])
         candidates = grp.get_mapping()
-        mtg = MTG(self.test_graph_2[0], self.test_graph_2[1], candidates[0])
-        self.assertEqual(len(mtg.get_nodes()), 5)
-        self.assertEqual(len(mtg.get_edges()), 4)
+        # print(candidates)
+        mtg = MTG(self.test_graph_2[0:], candidates)
+        self.assertEqual(mtg._graph.number_of_nodes(), 5)
+        self.assertEqual(mtg._graph.number_of_edges(), 4)
 
 
 if __name__ == "__main__":

synkit-0.0.15/Test/Graph/Wildcard/test_radwc.py

@@ -0,0 +1,55 @@
+import unittest
+from synkit.Graph.Wildcard.radwc import RadWC
+
+
+class TestRadWC(unittest.TestCase):
+    def test_no_product_radicals(self):
+        """If product has no radicals, output should be unchanged."""
+        rxn = "[CH3:1][OH:2]>>[CH3:1][OH:2]"
+        self.assertEqual(RadWC.transform(rxn), rxn)
+
+    def test_single_radical_in_product(self):
+        """A single radical in product gets a wildcard."""
+        rxn = "[CH3:1][OH:2]>>[CH2:1].[OH:2]"
+        out = RadWC.transform(rxn)
+        # Check [*:3] is attached to [CH2:1]
+        self.assertIn("[CH2:1]([*:3])", out)  # Atom-maps: 1,2 exist, so 3 is next
+
+    def test_multiple_radicals_in_product(self):
+        """Multiple radicals in product get multiple wildcards."""
+        rxn = "[CH3:1][OH:2]>>[CH2:1].[O:2]"
+        out = RadWC.transform(rxn)
+        # [CH2:1] has *:3 and *:4, [O:2] has *:5
+        self.assertIn("[CH2:1]([*:3])", out)
+        self.assertIn("[O:2]([*:5])", out)
+
+    def test_radical_and_nonradical_mixture(self):
+        """Mixed radical/non-radical product fragments, only radicals get wildcard."""
+        rxn = "[CH3:1][OH:2]>>[CH2:1].[OH:2]"
+        out = RadWC.transform(rxn)
+        # [CH2:1] gets *:3, [OH:2] is unchanged
+        self.assertIn("[CH2:1]([*:3])", out)
+        self.assertIn("[OH:2]", out)
+
+    def test_user_start_map(self):
+        """User-supplied map index is used for wildcards."""
+        rxn = "[CH3:7][OH:8]>>[CH2:7].[OH:8]"
+        out = RadWC.transform(rxn, start_map=50)
+        self.assertIn("[CH2:7]([*:50])", out)
+
+    def test_empty_reaction(self):
+        """Empty input should raise ValueError."""
+        with self.assertRaises(ValueError):
+            RadWC.transform("")
+
+    def test_three_component(self):
+        """Agent block is preserved."""
+        rxn = "[CH3:1][OH:2]>[Na+]>[CH2:1].[OH:2]"
+        out = RadWC.transform(rxn)
+        self.assertTrue(out.startswith("[CH3:1][OH:2]>[Na+]>"))
+        self.assertIn("[CH2:1]([*:3])", out)
+        self.assertIn("[OH:2]", out)
+
+
+if __name__ == "__main__":
+    unittest.main()

synkit-0.0.15/Test/Graph/Wildcard/test_wildcard.py

@@ -0,0 +1,81 @@
+import unittest
+from synkit.IO import rsmi_to_graph
+from synkit.Graph.Wildcard.wildcard import WildCard
+
+
+class TestWildCard(unittest.TestCase):
+    def setUp(self):
+        # The main, complex test case with atom mapping
+        self.rsmi_main = (
+            "[cH:1]1[cH:14][c:10]2[c:23]([cH:11][n:25]1)[cH:17][cH:12][cH:4][c:31]2[NH2:28]."
+            "[cH:2]1[c:20]([C:22]([OH:7])=[O:21])[s:18][c:24]([S:6][c:29]2[c:15]([Cl:26])[cH:8]"
+            "[n:19][cH:9][c:16]2[Cl:27])[c:30]1[N+:5]([O-:3])=[O:13]>>"
+            "[cH:1]1[cH:14][c:10]2[c:23]([cH:11][n:25]1)[cH:17][cH:12][cH:4][c:31]2[NH:28]"
+            "[C:22]([c:20]1[cH:2][c:30]([N+:5]([O-:3])=[O:13])[c:24]([S:6][c:29]2[c:15]([Cl:26])"
+            "[cH:8][n:19][cH:9][c:16]2[Cl:27])[s:18]1)=[O:21]"
+        )
+        # No atoms lost: R == P, should not add wildcards
+        self.rsmi_no_loss = "CCO>>CCO"
+        # All atoms lost: RSMI that loses everything (nonsense, but good test)
+        self.rsmi_all_lost = "CCO>>"
+        # Empty
+        self.rsmi_empty = ""
+        # Wildcard already present
+        self.rsmi_existing_wildcard = "[CH3:1][CH2:2][OH:3]>>[CH2:1][CH2:2].[*:4][OH:3]"
+        # No atom map (should raise error)
+        self.rsmi_no_atom_map = "C(C)Cl>>CC"
+
+    def test_main_case_wildcard_added(self):
+        """Complex case: output product contains wildcard and roundtrip is valid."""
+        out_rsmi = WildCard.rsmi_with_wildcards(self.rsmi_main)
+        _, product = out_rsmi.split(">>")
+        self.assertIsInstance(out_rsmi, str)
+        self.assertIn(
+            "*", product, "Wildcard '*' should be present in the product side."
+        )
+        # Roundtrip: should parse back without error
+        r, p = rsmi_to_graph(out_rsmi)
+        self.assertTrue(r.number_of_nodes() > 0)
+        self.assertTrue(p.number_of_nodes() > 0)
+
+    def test_no_atoms_lost(self):
+        """No atoms lost: should raise ValueError if input is not atom-mapped."""
+        with self.assertRaises(ValueError):
+            WildCard.rsmi_with_wildcards(self.rsmi_no_loss)
+
+    def test_all_atoms_lost(self):
+        """All atoms lost: should raise ValueError if input is not atom-mapped."""
+        with self.assertRaises(ValueError):
+            WildCard.rsmi_with_wildcards(self.rsmi_all_lost)
+
+    def test_empty_input(self):
+        """Empty input: should raise ValueError."""
+        with self.assertRaises(ValueError):
+            WildCard.rsmi_with_wildcards(self.rsmi_empty)
+
+    def test_wildcard_not_duplicated(self):
+        """Existing wildcards: should not create duplicate wildcards for same lost bond."""
+        out_rsmi = WildCard.rsmi_with_wildcards(self.rsmi_existing_wildcard)
+        _, product = out_rsmi.split(">>")
+        # At least one '*' in the product SMILES string
+        self.assertIn("*", product)
+
+    def test_no_false_positive_wildcards(self):
+        """Wildcards are only added if there are truly lost subgraphs; non-atom-mapped input raises."""
+        rsmi = "C>>C"
+        with self.assertRaises(ValueError):
+            WildCard.rsmi_with_wildcards(rsmi)
+
+    def test_output_is_str_and_split(self):
+        """Should raise ValueError if input is not atom-mapped."""
+        with self.assertRaises(ValueError):
+            WildCard.rsmi_with_wildcards(self.rsmi_no_loss)
+
+    def test_missing_atom_map_raises(self):
+        """Should raise ValueError if atom_map attributes are missing."""
+        with self.assertRaises(ValueError):
+            WildCard.rsmi_with_wildcards(self.rsmi_no_atom_map)
+
+
+if __name__ == "__main__":
+    unittest.main()

synkit-0.0.15/Test/IO/combinatorial/test_smarts_expander.py

@@ -0,0 +1,38 @@
+import unittest
+from synkit.IO.combinatorial.smarts_expander import SMARTSExpander
+
+
+class TestSMARTSExpander(unittest.TestCase):
+
+    def test_no_placeholders(self):
+        s = "CCO"
+        self.assertEqual(list(SMARTSExpander.expand_iter(s)), ["CCO"])
+        self.assertEqual(SMARTSExpander.expand(s), ["CCO"])
+
+    def test_simple_expansion(self):
+        s = "[C,N:1][O,P:2]"
+        result = SMARTSExpander.expand(s)
+        self.assertEqual(
+            set(result), {"[C:1][O:2]", "[C:1][P:2]", "[N:1][O:2]", "[N:1][P:2]"}
+        )
+
+    def test_disjoint_constraint(self):
+        s = "[C,N:1][O:1]"
+        with self.assertRaises(ValueError):
+            list(SMARTSExpander.expand_iter(s))
+
+    def test_realistic_reaction(self):
+        rxn = (
+            "[H+:6].[C:7](-[O:8](-[H:12]))(-[C,N,O,P,S:9])(-[C,N,O,P,S:10])(-[H:11])."
+            "[C:2](-[S:4](-[C,N,O,P,S:5]))(-[C,N,O,P,S:1])(=[O:3])>>"
+            "[S:4](-[H:6])(-[C,N,O,P,S:5]).[H+:12]."
+            "[C:7](-[O:8](-[C:2](-[C,N,O,P,S:1])(=[O:3])))(-[C,N,O,P,S:9])(-[C,N,O,P,S:10])(-[H:11])"
+        )
+        ex_list = list(SMARTSExpander.expand_iter(rxn))
+        self.assertEqual(len(ex_list), 625)
+        # Optional: Just check format or count, not endswith
+        self.assertTrue(ex_list[0].startswith("[H+:6]"))
+
+
+if __name__ == "__main__":
+    unittest.main()

synkit-0.0.15/Test/IO/combinatorial/test_smarts_generalizer.py

@@ -0,0 +1,62 @@
+import unittest
+from rdkit import Chem
+from synkit.IO.combinatorial.smarts_generalizer import SMARTSGeneralizer
+
+
+class TestSMARTSGeneralizer(unittest.TestCase):
+
+    def setUp(self):
+        self.gen = SMARTSGeneralizer(sanity_check=True)
+
+    def test_basic_generalization(self):
+        inputs = [
+            "[C:1]-[N:2]>>[N:1]-[C:2]",
+            "[N:1]-[N:2]>>[N:1]-[N:2]",
+            "[O:1]-[N:2]>>[N:1]-[N:2]",
+        ]
+        output = self.gen.generalize(inputs)
+        # Instead of strict string match, check correct mapped elements
+        self.assertIn("[C,N,O:1]", output)
+        self.assertIn("[N:2]", output)
+        self.assertIn(">>", output)
+
+    def test_single_smarts(self):
+        inputs = ["[C:1]-[N:2]>>[N:1]-[C:2]"]
+        output = self.gen.generalize(inputs)
+        # Should match input exactly
+        self.assertEqual(output, "[C:1]-[N:2]>>[N:1]-[C:2]")
+
+    def test_different_topology_raises(self):
+        inputs = ["[C:1]-[N:2]>>[N:1]-[C:2]", "[N:1]-[N:2]-[C:3]>>[N:1]-[N:2]-[C:3]"]
+        with self.assertRaises(ValueError):
+            self.gen.generalize(inputs)
+
+    def test_empty_input_raises(self):
+        with self.assertRaises(ValueError):
+            self.gen.generalize([])
+
+    def test_molecule_smarts(self):
+        gen = SMARTSGeneralizer(sanity_check=True)
+        inputs = ["[C:1]-[N:2]", "[N:1]-[N:2]", "[O:1]-[N:2]"]
+        out = gen.generalize(inputs)
+        self.assertEqual(out, "[C,N,O:1]-[N:2]")
+
+        mol = Chem.MolFromSmarts(out)
+        self.assertIsNotNone(mol)
+
+    def test_invalid_sanity_check(self):
+        gen = SMARTSGeneralizer(sanity_check=True)
+        # Using an obviously broken SMARTS (bad bracket placement)
+        _ = [
+            "[C:1]-[N:2]>>[N:1]-[X:2]"
+        ]  # 'X' is a valid SMARTS wildcard! Use a real error
+        with self.assertRaises(ValueError):
+            gen.generalize(["[C:1][C:2]>>[N:1][C:2]["])  # broken SMARTS
+
+    def test_repr(self):
+        gen = SMARTSGeneralizer()
+        self.assertIn("sanity_check", repr(gen))
+
+
+if __name__ == "__main__":
+    unittest.main()

synkit-0.0.15/Test/IO/combinatorial/test_smarts_to_graph.py

@@ -0,0 +1,85 @@
+import unittest
+import networkx as nx
+
+from synkit.IO.combinatorial.smarts_to_graph import SMARTSToGraph
+
+
+class TestSMARTSToGraph(unittest.TestCase):
+
+    def setUp(self):
+        self.stg = SMARTSToGraph()
+
+    def test_smarts_to_graph_simple(self):
+        g = self.stg.smarts_to_graph("[C:1]-[O:2]")
+        self.assertIsInstance(g, nx.Graph)
+        self.assertEqual(set(g.nodes), {1, 2})
+        self.assertEqual(g.nodes[1]["element"], "C")
+        self.assertEqual(g.nodes[2]["element"], "O")
+        self.assertIsNone(g.nodes[1]["constraint"])
+
+    def test_smarts_to_graph_constraint(self):
+        g = self.stg.smarts_to_graph("[C,N,O:1]-[N:2]")
+        # Node 1 should be placeholder
+        self.assertEqual(g.nodes[1]["element"], "*")
+        self.assertIsInstance(g.nodes[1]["constraint"], list)
+        self.assertIn("C", g.nodes[1]["constraint"])
+        self.assertEqual(g.nodes[2]["element"], "N")
+        self.assertIsNone(g.nodes[2]["constraint"])
+
+    def test_smarts_to_graph_hcount(self):
+        g = self.stg.smarts_to_graph("[CH3:1]-[O:2]")
+        # For SMARTS as written, RDKit returns 0 hydrogens for both
+        self.assertEqual(g.nodes[1]["hcount"], 0)
+        self.assertEqual(g.nodes[2]["hcount"], 0)
+
+    def test_invalid_smarts(self):
+        with self.assertRaises(ValueError):
+            self.stg.smarts_to_graph("[C:1]-[N")
+
+    def test_missing_atom_map(self):
+        with self.assertRaises(ValueError):
+            self.stg.smarts_to_graph("[C]-[O:2]")
+
+    def test_rxn_smarts_to_graphs(self):
+        rxn = (
+            "[H+:6].[C:7](-[O:8](-[H:12]))(-[C,N,O,P,S:9])(-[C,N,O,P,S:10])(-[H:11])."
+            "[C:2](-[S:4](-[C,N,O,P,S:5]))(-[C,N,O,P,S:1])(=[O:3])>>"
+            "[S:4](-[H:6])(-[C,N,O,P,S:5]).[H+:12]."
+            "[C:7](-[O:8](-[C:2](-[C,N,O,P,S:1])(=[O:3])))(-[C,N,O,P,S:9])(-[C,N,O,P,S:10])(-[H:11])"
+        )
+        g_react, _ = self.stg.rxn_smarts_to_graphs(rxn)
+
+        # These are the atom_map indices that should have constraint (from SMARTS [C,N,O,P,S:idx])
+        expected_constraint_nodes = {1, 5, 9, 10}
+        for idx in expected_constraint_nodes:
+            self.assertIn(idx, g_react.nodes)
+            self.assertIsNotNone(
+                g_react.nodes[idx]["constraint"],
+                f"Node {idx} should have a constraint list but does not",
+            )
+            self.assertEqual(
+                set(g_react.nodes[idx]["constraint"]),
+                {"C", "N", "O", "P", "S"},
+                f"Node {idx} has incorrect constraint list",
+            )
+        # All other nodes should NOT have a constraint
+        for idx in set(g_react.nodes) - expected_constraint_nodes:
+            self.assertIsNone(
+                g_react.nodes[idx]["constraint"],
+                f"Node {idx} should NOT have a constraint list",
+            )
+
+    def test_rxn_separator(self):
+        with self.assertRaises(ValueError):
+            self.stg.rxn_smarts_to_graphs("[C:1]-[O:2]")  # no '>>'
+
+    def test_repr_and_describe(self):
+        r = repr(self.stg)
+        self.assertIn("placeholders", r)
+        desc = self.stg.describe()
+        self.assertIn("smarts_to_graph", desc)
+        self.assertIn("rxn_smarts_to_graphs", desc)
+
+
+if __name__ == "__main__":
+    unittest.main()

synkit-0.0.15/Test/Synthesis/Reactor/test_imba_engine.py

@@ -0,0 +1,94 @@
+import unittest
+from synkit.IO import rsmi_to_its
+from synkit.Graph.Wildcard.wildcard import WildCard
+from synkit.Chem.Reaction.standardize import Standardize
+from synkit.Synthesis.Reactor.imba_engine import ImbaEngine
+
+
+class TestImbaEngine(unittest.TestCase):
+    def setUp(self):
+        # A complex standardized RSMI from your example
+        self.smart = (
+            "[cH:1]1[cH:14][c:10]2[c:23]([cH:11][n:25]1)[cH:17][cH:12][cH:4][c:31]2[NH2:28]."
+            "[cH:2]1[c:20]([C:22]([OH:7])=[O:21])[s:18][c:24]([S:6][c:29]2[c:15]"
+            "([Cl:26])[cH:8][n:19][cH:9][c:16]2[Cl:27])[c:30]1[N+:5]([O-:3])=[O:13]>>"
+            "[cH:1]1[cH:14][c:10]2[c:23]([cH:11][n:25]1)[cH:17][cH:12][cH:4]"
+            "[c:31]2[NH:28][C:22]([c:20]1[cH:2][c:30]([N+:5]([O-:3])=[O:13])[c:24]([S:6]"
+            "[c:29]2[c:15]([Cl:26])[cH:8][n:19][cH:9][c:16]2[Cl:27])[s:18]1)=[O:21]"
+        )
+        # Standardize removes AAM
+        self.rsmi = Standardize().fit(self.smart, remove_aam=True)
+
+    def test_pipeline_forward(self):
+        """Test forward ImbaEngine pipeline end-to-end."""
+        # Apply wildcard insertion
+        wild_smart = WildCard().rsmi_with_wildcards(self.smart)
+        # Build ITS graphs
+        temp = rsmi_to_its(wild_smart, core=True)
+        # substrate split from standardized RSMI
+        substrate_r, _ = self.rsmi.split(">>")
+        # Run engine forward with template without cleaning fragments
+        engine = ImbaEngine(substrate_r, temp, add_wildcard=True, clean_fragments=False)
+        out = engine.smarts_list
+        self.assertEqual(len(out), 1)
+        out_rsmi = Standardize().fit(out[0], remove_aam=True)
+
+        self.assertIn("*", out_rsmi)
+        self.assertNotEqual(out_rsmi, self.rsmi)
+
+        # Run engine forward with template with cleaning fragments
+        engine = ImbaEngine(substrate_r, temp, add_wildcard=True, clean_fragments=True)
+        out = engine.smarts_list
+        outs = [Standardize().fit(o, remove_aam=True) for o in out]
+        self.assertIn(self.rsmi, outs)
+
+    def test_pipeline_backward(self):
+        """Test backward ImbaEngine pipeline end-to-end with and without fragment cleaning."""
+        # Prepare wildcard and ITS template
+        wild_rsmi = WildCard().rsmi_with_wildcards(self.smart)
+        its = rsmi_to_its(wild_rsmi, core=True)
+
+        _, substrate_p = self.rsmi.split(">>")
+
+        # 1. Without fragment cleaning
+        engine = ImbaEngine(
+            substrate_p,
+            its,
+            add_wildcard=True,
+            clean_fragments=False,
+            invert=True,
+            partial=True,
+        )
+        out = engine.smarts_list
+        self.assertEqual(len(out), 2)
+        out_rsmi = Standardize().fit(out[0], remove_aam=True)
+        self.assertIn("*", out_rsmi)
+        self.assertNotEqual(out_rsmi, self.rsmi)
+
+        # 2. With fragment cleaning
+        engine_clean = ImbaEngine(
+            substrate_p,
+            its,
+            add_wildcard=True,
+            clean_fragments=True,
+            invert=True,
+            partial=True,
+        )
+
+        out_clean = engine_clean.smarts_list
+        self.assertEqual(len(out_clean), 2)
+        outs = [Standardize().fit(o, remove_aam=True) for o in out_clean]
+        self.assertIn(self.rsmi, outs)
+
+    def test_invalid_rsmi(self):
+        """Invalid RSMI pipeline should raise an exception at Standardize or ITS step."""
+        # Standardize should fail for invalid RSMI
+        with self.assertRaises(Exception):
+            # Attempt full pipeline
+            rsmi = Standardize().fit("not_a_rsmi", remove_aam=True)
+            wild = WildCard().rsmi_with_wildcards(rsmi)
+            _ = rsmi_to_its(wild, core=True)
+
+
+if __name__ == "__main__":
+    unittest.main()