synkit 0.0.12__tar.gz → 0.0.14__tar.gz

{synkit-0.0.12 → synkit-0.0.14}/.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.12 → synkit-0.0.14}/.gitignore

@@ -22,3 +22,5 @@ run.sh
 docs/*
 run_rdcanon.py
 Data/Fragment/*
+test_partial.py
+Data/Benchmark/synthesis/*

{synkit-0.0.12 → synkit-0.0.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synkit
-Version: 0.0.12
+Version: 0.0.14
 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.12 → synkit-0.0.14}/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.12 → synkit-0.0.14}/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.14/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.14/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.14/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.14/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.14/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.14/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()

{synkit-0.0.12 → synkit-0.0.14}/doc/graph.rst

@@ -200,42 +200,77 @@ This example builds two reaction-center ITS graphs, computes their MCS mapping,
    :caption: Building and visualizing an MTG with composite ITS
    :linenos:
 
-   from synkit.IO.chem_converter import rsmi_to_its
-   from synkit.Graph.MTG.mcs_matcher import MCSMatcher
    from synkit.Graph.MTG.mtg import MTG
-   from synkit.Graph import clean_graph_keep_largest_component
-   from synkit.Vis import GraphVisualizer
+   from synkit.Graph.ITS.its_decompose import get_rc
+   from synkit.examples import list_examples, load_example
    import matplotlib.pyplot as plt
+   from synkit.Vis.graph_visualizer import GraphVisualizer
 
-   # 1) Define two related reaction SMILES and build their reaction-center ITS graphs
-   rsmi_list = [
-      '[CH:4]([H:7])([H:8])[CH:5]=[O:6]>>[CH:4]([H:8])=[CH:5][O:6]([H:7])',  # tautomerization
-      '[CH3:1][C:2]=[O:3].[CH:4]([H:8])=[CH:5][O:6]([H:7])>>'
-      '[CH3:1][C:2]([O:3][H:7])[CH:4]([H:8])[CH:5]=[O:6]'                     # nucleophilic addition
-   ]
-   rc_graphs = [rsmi_to_its(r, core=True) for r in rsmi_list]
 
-   # 2) Find MCS mapping between the two ITS graphs
-   mcs = MCSMatcher(node_label_names=['element', 'charge'], edge_attribute='order')
-   mcs.find_rc_mapping(rc_graphs[0], rc_graphs[1], mcs=True)
-   mapping = mcs.get_mappings()[0]
+   data = load_example("aldol")  
 
-   # 3) Build the Mechanistic Transition Graph (MTG)
-   mtg = MTG(rc_graphs[0], rc_graphs[1], mapping)
-   mtg_graph = mtg.get_graph()
+   mech_neutral = data[0]['mechanisms'][1]['steps']
+   smart_neutral = [i['smart_string'] for i in mech_neutral]
 
-   # 4) Also build the composite ITS by directly gluing the two RC graphs
-   its_composite = clean_graph_keep_largest_component(mtg_graph)
+   mech_acid = data[0]['mechanisms'][2]['steps']
+   smart_acid = [i['smart_string'] for i in mech_acid]
 
+   # neutral
+   mtg = MTG(smart_neutral, mcs_mol=True)
+   mtg_its_neutral = mtg.get_compose_its()
+   mtg_rc_neutral = get_rc(mtg_its_neutral, keep_mtg=True)
+   rc_neutral = get_rc(mtg_its_neutral, keep_mtg=False)
 
-   # 5) Visualize all four graphs: two RCs, the composite ITS, and the MTG
-   fig, axes = plt.subplots(2, 2, figsize=(14, 6))
+   # acid
+   mtg = MTG(smart_acid, mcs_mol=True)
+   mtg_its_acid = mtg.get_compose_its()
+   mtg_rc_acid = get_rc(mtg_its_acid, keep_mtg=True)
+   rc_acid = get_rc(mtg_its_acid, keep_mtg=False)
+
+   # Visualize
+   fig, ax = plt.subplots(2, 2, figsize=(16, 8))
    vis = GraphVisualizer()
 
-   vis.plot_its(rc_graphs[0], axes[0, 0], use_edge_color=True, title='A. Tautomerization RC')
-   vis.plot_its(rc_graphs[1], axes[0, 1], use_edge_color=True, title='B. Nucleophilic Addition RC')
-   vis.plot_its(its_composite, axes[1, 0], use_edge_color=True, title='C. Composite ITS')
-   vis.plot_its(mtg_graph, axes[1, 1], use_edge_color=True, title='D. Mechanistic TG', og=True)
+   vis.plot_its(
+      mtg_rc_neutral,
+      ax=ax[0, 0],
+      use_edge_color=True,
+      og=True,
+      title='A. MTG for aldol addition (neutral)',
+      title_font_size=20,
+      title_font_weight='medium',
+      title_font_style='normal'
+   )
+   vis.plot_its(
+      rc_neutral,
+      ax=ax[0, 1],
+      use_edge_color=True,
+      og=True,
+      title='B. Reaction center (neutral)',
+      title_font_size=20,
+      title_font_weight='medium',
+      title_font_style='normal'
+   )
+   vis.plot_its(
+      mtg_rc_acid,
+      ax=ax[1, 0],
+      use_edge_color=True,
+      og=True,
+      title='C. MTG for aldol addition (acid)',
+      title_font_size=20,
+      title_font_weight='medium',
+      title_font_style='normal'
+   )
+   vis.plot_its(
+      rc_acid,
+      ax=ax[1, 1],
+      use_edge_color=True,
+      og=True,
+      title='D. Reaction center (acid)',
+      title_font_size=20,
+      title_font_weight='medium',
+      title_font_style='normal'
+   )
 
    plt.tight_layout()
    plt.show()
@@ -243,16 +278,13 @@ This example builds two reaction-center ITS graphs, computes their MCS mapping,
 
 .. container:: figure
 
-   .. image:: ./figures/mtg.png
+   .. image:: ./figures/mtg_mechanism.png
       :alt: Composite ITS and MTG visualization
       :align: center
       :width: 1000px
 
    *Figure:*  
-   (A) Reaction‐center graph for the tautomerization step  
-   (B) Reaction‐center graph for the nucleophilic addition step  
-   (C) Composite ITS graph "gluing" both transformations  
-   (D) Mechanistic Transition Graph (MTG) showing step-wise mechanism  
+   Composition of the mechanistic sequences for aldol addition under neutral and acidic conditions, showing the composite MTG (left column) and the reaction center (right column).
 
 Context graph
 -------------

{synkit-0.0.12 → synkit-0.0.14}/lint.sh

@@ -18,7 +18,9 @@ benchmark_reactor.py:W292,C901,\
 syn_reactor.py:C901,\
 sing.py:C901,\
 turbo_iso.py:C901,\
-rule_vis.py:C901" \
+rule_vis.py:C901,
+gml_to_graph.py:C901,
+wildcard.py:C901" \
   --exclude=venv,\
 core_engine.py,\
 rule_apply.py,\

{synkit-0.0.12 → synkit-0.0.14}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "synkit"
-version = "0.0.12"
+version = "0.0.14"
 license = { text = "MIT" }
 license-files = ["LICENSE"]
 authors = [

{synkit-0.0.12 → synkit-0.0.14}/recipe/meta.yaml

@@ -1,6 +1,6 @@
 package:
   name: synkit
-  version: 0.0.12
+  version: 0.0.14
 
 source:
   path: ..