synkit 0.0.1__tar.gz → 0.0.2__tar.gz

{synkit-0.0.1 → synkit-0.0.2}/.gitignore

@@ -8,3 +8,4 @@ test_mod.py
 test_format.py
 *dev_zone
 *.pkl.gz
+dev_scripts/*

synkit-0.0.2/Data/Testcase/Compose/SingleRule/R0/0.gml

@@ -0,0 +1,17 @@
+rule [
+   ruleID "0"
+   left [
+      edge [ source 1 target 2 label "-" ]
+      edge [ source 3 target 4 label "-" ]
+   ]
+   context [
+      node [ id 1 label "H" ]
+      node [ id 2 label "N" ]
+      node [ id 3 label "C" ]
+      node [ id 4 label "Br" ]
+   ]
+   right [
+      edge [ source 1 target 4 label "-" ]
+      edge [ source 2 target 3 label "-" ]
+   ]
+]

synkit-0.0.2/Data/Testcase/Compose/SingleRule/R0/1.gml

@@ -0,0 +1,17 @@
+rule [
+   ruleID "1"
+   left [
+      edge [ source 1 target 2 label "-" ]
+      edge [ source 3 target 4 label "-" ]
+   ]
+   context [
+      node [ id 1 label "Br" ]
+      node [ id 2 label "C" ]
+      node [ id 3 label "O" ]
+      node [ id 4 label "H" ]
+   ]
+   right [
+      edge [ source 1 target 4 label "-" ]
+      edge [ source 2 target 3 label "-" ]
+   ]
+]

synkit-0.0.2/Data/Testcase/Compose/SingleRule/R0/2.gml

@@ -0,0 +1,17 @@
+rule [
+   ruleID "2"
+   left [
+      edge [ source 1 target 2 label "-" ]
+      edge [ source 3 target 4 label "-" ]
+   ]
+   context [
+      node [ id 1 label "C" ]
+      node [ id 2 label "Cl" ]
+      node [ id 3 label "N" ]
+      node [ id 4 label "H" ]
+   ]
+   right [
+      edge [ source 1 target 3 label "-" ]
+      edge [ source 2 target 4 label "-" ]
+   ]
+]

{synkit-0.0.1 → synkit-0.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synkit
-Version: 0.0.1
+Version: 0.0.2
 Summary: Utility for reaction modeling using graph grammar
 Project-URL: homepage, https://github.com/TieuLongPhan/SynKit
 Project-URL: source, https://github.com/TieuLongPhan/SynKit

synkit-0.0.2/Test/Chem/Reaction/test_rsmi_utils.py

@@ -0,0 +1,82 @@
+import unittest
+from synkit.Chem.Reaction.rsmi_utils import (
+    remove_common_reagents,
+    reverse_reaction,
+    remove_duplicates,
+    merge_reaction,
+    find_longest_fragment,
+)
+
+
+class TestChemicalReactions(unittest.TestCase):
+
+    def test_remove_common_reagents_no_common(self):
+        reaction = "A.B.C>>D.E.F"
+        expected_result = "A.B.C>>D.E.F"
+        result = remove_common_reagents(reaction)
+        self.assertEqual(result, expected_result)
+
+    def test_remove_common_reagents_with_common(self):
+        reaction = "A.B.C>>A.D.E"
+        expected_result = "B.C>>D.E"
+        result = remove_common_reagents(reaction)
+        self.assertEqual(result, expected_result)
+
+    def test_remove_common_reagents_all_common(self):
+        reaction = "A.B.C>>A.B.C"
+        expected_result = ">>"
+        result = remove_common_reagents(reaction)
+        self.assertEqual(result, expected_result)
+
+    def test_remove_duplicates(self):
+        input_list = ["CC", "C", "CC", "CCO", "C"]
+        expected_result = ["CC", "C", "CCO"]
+        result = remove_duplicates(input_list)
+        self.assertEqual(result, expected_result)
+
+    def test_reverse_reaction(self):
+        reaction_smiles = "C=C.O>>CCO"
+        expected_result = "CCO>>C=C.O"
+        result = reverse_reaction(reaction_smiles)
+        self.assertEqual(result, expected_result)
+
+    def test_merge_reaction(self):
+        rsmi_1 = "CCC(=O)OC.O>>CO.CCOC(=O)O"
+        rsmi_2 = "CCC(=O)O.CCO>>O.CCOC(=O)CC"
+        expected_result = "CCC(=O)OC.O.CCC(=O)O.CCO>>CO.CCOC(=O)O.O.CCOC(=O)CC"
+        result = merge_reaction(rsmi_1, rsmi_2)
+        self.assertEqual(result, expected_result)
+
+    def test_find_longest_fragment(self):
+        input_list = ["CCOC(=O)O", "O"]
+        expected_result = "CCOC(=O)O"
+        result = find_longest_fragment(input_list)
+        self.assertEqual(result, expected_result)
+
+    # Additional robustness for empty inputs or specific edge cases.
+    def test_remove_duplicates_empty(self):
+        input_list = []
+        expected_result = []
+        result = remove_duplicates(input_list)
+        self.assertEqual(result, expected_result)
+
+    def test_reverse_reaction_empty(self):
+        reaction_smiles = ">>"
+        expected_result = ">>"
+        result = reverse_reaction(reaction_smiles)
+        self.assertEqual(result, expected_result)
+
+    def test_merge_reaction_empty(self):
+        rsmi_1 = ">>"
+        rsmi_2 = ">>"
+        result = merge_reaction(rsmi_1, rsmi_2)
+        self.assertIsNone(result)
+
+    def test_find_longest_fragment_empty(self):
+        input_list = []
+        result = find_longest_fragment(input_list)
+        self.assertIsNone(result)
+
+
+if __name__ == "__main__":
+    unittest.main()

synkit-0.0.2/Test/Graph/Cluster/test_batch_cluster.py

@@ -0,0 +1,109 @@
+import time
+import unittest
+from synkit.IO.data_io import load_from_pickle
+from synkit.Graph.Feature.graph_signature import GraphSignature
+from synkit.Graph.Cluster.batch_cluster import BatchCluster
+
+
+class TestBatchCluster(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.graphs = load_from_pickle("Data/Testcase/graph.pkl.gz")
+        cls.templates = None
+        for value in cls.graphs:
+            value["rc_sig"] = GraphSignature(value["RC"]).create_graph_signature()
+            value["its_sig"] = GraphSignature(value["ITS"]).create_graph_signature()
+
+    def test_initialization(self):
+        """Test initialization and verify if the attributes are set correctly."""
+        cluster = BatchCluster(["element", "charge"], ["*", 0], "bond_order")
+        self.assertEqual(cluster.nodeLabelNames, ["element", "charge"])
+        self.assertEqual(cluster.nodeLabelDefault, ["*", 0])
+        self.assertEqual(cluster.edgeAttribute, "bond_order")
+
+    def test_initialization_failure(self):
+        """Test initialization failure when lengths of node labels and defaults do not match."""
+        with self.assertRaises(ValueError):
+            BatchCluster(["element"], ["*", 0, 1], "bond_order")
+
+    def test_batch_dicts(self):
+        """Test the batching function to split data correctly."""
+        batch_cluster = BatchCluster(["element", "charge"], ["*", 0], "bond_order")
+        input_list = [{"id": i} for i in range(10)]
+        batches = batch_cluster.batch_dicts(input_list, 3)
+        self.assertEqual(len(batches), 4)
+        self.assertEqual(len(batches[0]), 3)
+        self.assertEqual(len(batches[-1]), 1)
+
+    def test_lib_check_functionality(self):
+        """Test the lib_check method using directly comparable results."""
+        cluster = BatchCluster()
+        batch_1 = self.graphs[:50]
+        batch_2 = self.graphs[50:]
+        _, templates = cluster.fit(batch_1, None, "RC", "rc_sig")
+        for entry in batch_2:
+            _, templates = cluster.lib_check(entry, templates, "RC", "rc_sig")
+        self.assertEqual(len(templates), 30)
+
+    def test_cluster_integration(self):
+        """Test the cluster method to ensure it processes data entries correctly."""
+        cluster = BatchCluster()
+        expected_template_count = 30
+        _, updated_templates = cluster.cluster(self.graphs, [], "RC", "rc_sig")
+
+        self.assertEqual(
+            len(updated_templates),
+            expected_template_count,
+            f"Failed: expected {expected_template_count} templates, got {len(updated_templates)}",
+        )
+
+    def test_fit(self):
+        cluster = BatchCluster()
+        batch_sizes = [None, 10]
+        expected_template_count = 30
+
+        for batch_size in batch_sizes:
+            start_time = time.time()
+            _, updated_templates = cluster.fit(
+                self.graphs, self.templates, "RC", "rc_sig", batch_size=batch_size
+            )
+            elapsed_time = time.time() - start_time
+
+            self.assertEqual(
+                len(updated_templates),
+                expected_template_count,
+                f"Failed for batch_size={batch_size}: expected "
+                + f"{expected_template_count} templates, got {len(updated_templates)}",
+            )
+            print(
+                f"Test for batch_size={batch_size} completed in {elapsed_time:.2f} seconds."
+            )
+
+    def test_fit_gml(self):
+        cluster = BatchCluster()
+        batch_sizes = [None, 10]
+        expected_template_count = (
+            30  # Assuming this is the expected number of templates after processing
+        )
+
+        for batch_size in batch_sizes:
+            start_time = time.time()
+            _, updated_templates = cluster.fit(
+                self.graphs, self.templates, "RC", "rc_sig", batch_size=batch_size
+            )
+            elapsed_time = time.time() - start_time
+
+            self.assertEqual(
+                len(updated_templates),
+                expected_template_count,
+                f"Failed for batch_size={batch_size}: expected"
+                + f" {expected_template_count} templates, got {len(updated_templates)}",
+            )
+            print(
+                f"Test for batch_size={batch_size} completed in {elapsed_time:.2f} seconds."
+            )
+
+
+# To run the tests
+if __name__ == "__main__":
+    unittest.main()

synkit-0.0.2/Test/Graph/Cluster/test_graph_cluster.py

@@ -0,0 +1,136 @@
+import time
+import unittest
+from synkit.IO.data_io import load_from_pickle
+from synkit.Graph.Cluster.graph_cluster import GraphCluster
+from synkit.Graph.Feature.graph_descriptors import GraphDescriptor
+
+
+class TestRCCluster(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        # Load data once for all tests
+        cls.graphs = load_from_pickle("Data/Testcase/graph.pkl.gz")
+        for value in cls.graphs:
+            value = GraphDescriptor.get_descriptors(value)
+        cls.clusterer = GraphCluster()
+
+    def test_initialization(self):
+        """Test the initialization and configuration of the RCCluster."""
+        self.assertIsInstance(self.clusterer.nodeLabelNames, list)
+        self.assertEqual(self.clusterer.edgeAttribute, "order")
+        self.assertEqual(
+            len(self.clusterer.nodeLabelNames), len(self.clusterer.nodeLabelDefault)
+        )
+
+    def test_auto_cluster(self):
+        """Test the auto_cluster method functionality."""
+        rc = [value["RC"] for value in self.graphs]
+        cycles = [value["cycle"] for value in self.graphs]
+        signature = [value["signature_rc"] for value in self.graphs]
+        atom_count = [value["atom_count"] for value in self.graphs]
+        for att in [None, cycles, signature, atom_count]:
+            clusters, graph_to_cluster = self.clusterer.iterative_cluster(
+                rc,
+                att,
+                nodeMatch=self.clusterer.nodeMatch,
+                edgeMatch=self.clusterer.edgeMatch,
+            )
+            self.assertIsInstance(clusters, list)
+            self.assertIsInstance(graph_to_cluster, dict)
+            self.assertEqual(len(clusters), 30)
+
+    def test_auto_cluster_wrong_isomorphism(self):
+        rc = [value["RC"] for value in self.graphs]
+        cycles = [value["cycle"] for value in self.graphs]
+        signature = [value["signature_rc"] for value in self.graphs]
+        atom_count = [value["atom_count"] for value in self.graphs]
+
+        # cluster all
+        clusters, _ = self.clusterer.iterative_cluster(
+            rc, None, nodeMatch=None, edgeMatch=None
+        )
+        self.assertEqual(len(clusters), 8)  # wrong value
+
+        # cluster with cycle
+        clusters, _ = self.clusterer.iterative_cluster(
+            rc, cycles, nodeMatch=None, edgeMatch=None
+        )
+        self.assertEqual(len(clusters), 8)  # wrong value
+
+        # cluster with atom_count
+        clusters, _ = self.clusterer.iterative_cluster(
+            rc, atom_count, nodeMatch=None, edgeMatch=None
+        )
+        self.assertEqual(len(clusters), 27)  # wrong value but almost correct
+
+        # cluster with signature
+        clusters, _ = self.clusterer.iterative_cluster(
+            rc, signature, nodeMatch=None, edgeMatch=None
+        )
+        self.assertEqual(len(clusters), 30)  # correct by some magic. No proof for this
+
+    def test_fit(self):
+        """Test the fit method to ensure it correctly updates data entries with cluster indices."""
+
+        clustered_data = self.clusterer.fit(
+            self.graphs, rule_key="RC", attribute_key="atom_count"
+        )
+        max_class = 0
+        for item in clustered_data:
+            print(item["class"])
+            max_class = item["class"] if item["class"] >= max_class else max_class
+            # print(max_class)
+            self.assertIn("class", item)
+        self.assertEqual(max_class, 29)  # 30 classes start from 0 so max is 29
+
+    def test_fit_gml(self):
+        """Test the fit method to ensure it correctly updates data entries with cluster indices."""
+
+        clustered_data = self.clusterer.fit(
+            self.graphs, rule_key="rc", attribute_key="atom_count"
+        )
+        max_class = 0
+        for item in clustered_data:
+            print(item["class"])
+            max_class = item["class"] if item["class"] >= max_class else max_class
+            # print(max_class)
+            self.assertIn("class", item)
+        self.assertEqual(max_class, 29)  # 30 classes start from 0 so max is 29
+
+    def test_fit_time_compare(self):
+        attributes = {
+            "None": None,
+            "Cycles": "cycle",
+            "Signature": "signature_rc",
+            "Atom_count": "atom_count",
+        }
+
+        results = {}
+        for name, attr in attributes.items():
+            start_time = time.time()
+            clustered_data = self.clusterer.fit(
+                self.graphs, rule_key="RC", attribute_key=attr
+            )
+            elapsed_time = time.time() - start_time
+
+            # Optionally print out class information or verify correctness
+            max_class = max(item["class"] for item in clustered_data if "class" in item)
+
+            results[name] = elapsed_time
+
+            # Basic verification that 'class' is assigned and max class is as expected
+            self.assertTrue(all("class" in item for item in clustered_data))
+            self.assertEqual(
+                max_class, 29
+            )  # Ensure the maximum class index is as expected
+
+        # Compare results to check which attribute took the least/most time
+        min_time_attr = min(results, key=results.get)
+        max_time_attr = max(results, key=results.get)
+        self.assertIn(min_time_attr, ["Atom_count", "Signature"])
+        self.assertIn(max_time_attr, ["None", "Cycles"])
+
+
+if __name__ == "__main__":
+    unittest.main()

synkit-0.0.2/Test/Graph/Cluster/test_morphism.py

@@ -0,0 +1,117 @@
+import unittest
+from synkit.IO.data_io import load_from_pickle
+from synkit.Graph.Cluster.morphism import graph_isomorphism, rule_isomorphism
+
+
+class TestRule(unittest.TestCase):
+
+    def setUp(self):
+        self.graphs = load_from_pickle("Data/Testcase/graph.pkl.gz")
+
+        self.small = """rule [
+            ruleID "Small"
+            left [
+                node [ id 1 label "H" ]
+                node [ id 2 label "O" ]
+                edge [ source 1 target 2 label "-" ]
+            ]
+            right [
+                node [ id 1 label "H+" ]
+                node [ id 2 label "O-" ]
+            ]
+        ]"""
+        self.large = """rule [
+            ruleID "Large"
+            left [
+                node [ id 1 label "H" ]
+                node [ id 2 label "O" ]
+                edge [ source 1 target 2 label "-" ]
+            ]
+            context [
+                node [ id 3 label "C" ]
+                edge [ source 2 target 3 label "-" ]
+            ]
+            right [
+                node [ id 1 label "H+" ]
+                node [ id 2 label "O-" ]
+            ]
+        ]"""
+
+        self.gml = (
+            "rule [\n"
+            '   ruleID "rule"\n'
+            "   left [\n"
+            '      edge [ source 1 target 4 label "-" ]\n'
+            '      edge [ source 1 target 2 label "-" ]\n'
+            '      edge [ source 2 target 3 label "-" ]\n'
+            "   ]\n"
+            "   context [\n"
+            '      node [ id 1 label "C" ]\n'
+            '      node [ id 4 label "H" ]\n'
+            '      node [ id 2 label "C" ]\n'
+            '      node [ id 3 label "O" ]\n'
+            "   ]\n"
+            "   right [\n"
+            '      edge [ source 1 target 2 label "=" ]\n'
+            '      edge [ source 4 target 3 label "-" ]\n'
+            "   ]\n"
+            "]"
+        )
+
+        self.gml_h = (
+            "rule [\n"
+            '   ruleID "rule"\n'
+            "   left [\n"
+            '      edge [ source 1 target 2 label "-" ]\n'
+            '      edge [ source 1 target 3 label "-" ]\n'
+            '      edge [ source 3 target 4 label "-" ]\n'
+            "   ]\n"
+            "   context [\n"
+            '      node [ id 1 label "C" ]\n'
+            '      node [ id 2 label "H" ]\n'
+            '      node [ id 3 label "C" ]\n'
+            '      node [ id 4 label "O" ]\n'
+            '      node [ id 5 label "H" ]\n'
+            '      node [ id 6 label "H" ]\n'
+            '      node [ id 7 label "H" ]\n'
+            '      node [ id 8 label "H" ]\n'
+            '      node [ id 9 label "H" ]\n'
+            '      edge [ source 1 target 5 label "-" ]\n'
+            '      edge [ source 1 target 6 label "-" ]\n'
+            '      edge [ source 3 target 7 label "-" ]\n'
+            '      edge [ source 3 target 8 label "-" ]\n'
+            '      edge [ source 4 target 9 label "-" ]\n'
+            "   ]\n"
+            "   right [\n"
+            '      edge [ source 1 target 3 label "=" ]\n'
+            '      edge [ source 2 target 4 label "-" ]\n'
+            "   ]\n"
+            "]"
+        )
+
+    def test_graph_isomorphism_true(self):
+        result = graph_isomorphism(
+            self.graphs[0]["RC"], self.graphs[3]["RC"], use_defaults=True
+        )
+        self.assertTrue(result)
+
+    def test_graph_isomorphism_false(self):
+        result = graph_isomorphism(
+            self.graphs[0]["RC"], self.graphs[1]["RC"], use_defaults=True
+        )
+        self.assertFalse(result)
+
+    def test_rule_isomorphism_isomorphism(self):
+        self.assertTrue(rule_isomorphism(self.small, self.small))
+        self.assertTrue(rule_isomorphism(self.large, self.large))
+        self.assertFalse(rule_isomorphism(self.small, self.large))
+
+    def test_rule_isomorphism_monomorphism(self):
+        # small is a subgraph of large
+        self.assertTrue(rule_isomorphism(self.small, self.large, "monomorphism"))
+        # large is not a subgraph of small
+        self.assertFalse(rule_isomorphism(self.large, self.small, "monomorphism"))
+
+
+if __name__ == "__main__":
+    unittest.main()

synkit-0.0.2/Test/ITS/test_its_expand.py

@@ -0,0 +1,19 @@
+import unittest
+from synkit.ITS.aam_validator import AAMValidator
+from synkit.ITS.its_expand import ITSExpand
+
+
+class TestPartialExpand(unittest.TestCase):
+
+    def test_expand_aam_with_its(self):
+        input_rsmi = "CC[CH2:3][Cl:1].[NH2:2][H:4]>>CC[CH2:3][NH2:2].[Cl:1][H:4]"
+        output_rsmi = ITSExpand.expand_aam_with_its(input_rsmi, use_G=True)
+        expected_rsmi = (
+            "[CH3:1][CH2:2][CH2:3][Cl:4].[NH2:5][H:6]"
+            + ">>[CH3:1][CH2:2][CH2:3][NH2:5].[Cl:4][H:6]"
+        )
+        self.assertTrue(AAMValidator.smiles_check(output_rsmi, expected_rsmi, "ITS"))
+
+
+if __name__ == "__main__":
+    unittest.main()

{synkit-0.0.1 → synkit-0.0.2}/Test/ITS/test_normalize_aam.py

@@ -1,6 +1,7 @@
 import unittest
 import networkx as nx
 from synkit.ITS.normalize_aam import NormalizeAAM
+from synkit.ITS.aam_validator import AAMValidator
 
 
 class TestNormalizeAAM(unittest.TestCase):
@@ -55,7 +56,8 @@ class TestNormalizeAAM(unittest.TestCase):
             + "([CH3:4])[H:6])[H:5]"
         )
         result = self.normalizer.fit(input_rsmi)
-        self.assertEqual(result, expected_output)
+        print(result)
+        self.assertTrue(AAMValidator().smiles_check(result, expected_output))
 
 
 # Run the unittest

synkit-0.0.2/Test/Reactor/test_multi_steps.py

@@ -0,0 +1,73 @@
+import unittest
+from synkit.IO.data_io import load_database
+from synkit.Chem.Reaction.standardize import Standardize
+from synkit.IO.chem_converter import smart_to_gml
+from synkit.Reactor.reactor_utils import _add_reagent, _find_all_paths
+from synkit.Reactor.multi_steps import MultiSteps
+
+
+class TestMultiStep(unittest.TestCase):
+    def setUp(self) -> None:
+        smarts = [
+            "[CH2:4]([CH:5]=[O:6])[H:7]>>[CH2:4]=[CH:5][O:6][H:7]",
+            (
+                "[CH2:2]=[O:3].[CH2:4]=[CH:5][O:6][H:7]>>[CH2:2]([O:3][H:7])[CH2:4]"
+                + "[CH:5]=[O:6]"
+            ),
+            "[CH2:4]([CH:5]=[O:6])[H:8]>>[CH2:4]=[CH:5][O:6][H:8]",
+            (
+                "[CH2:2]([OH:3])[CH:4]=[CH:5][O:6][H:8]>>[CH2:2]=[CH:4][CH:5]=[O:6]"
+                + ".[OH:3][H:8]"
+            ),
+        ]
+        self.gml = [smart_to_gml(value) for value in smarts]
+        self.order = [0, 1, 0, -1]
+        self.rsmi = "CC=O.CC=O.CCC=O>>CC=O.CC=C(C)C=O.O"
+        self.data = load_database("Data/Testcase/mech.json.gz")
+        self.rsmi_2 = Standardize().fit(self.data[0]["reaction"])
+
+    def test_perform_multi_step_reaction(self):
+        results, _ = MultiSteps._process(self.gml, self.order, self.rsmi)
+        self.assertEqual(len(results), 4)
+
+    def test_get_aam(self):
+        test = self.data[0]["mechanisms"][2]
+        rule = [
+            smart_to_gml(value["smart_string"], core=True, explicit_hydrogen=True)
+            for value in test["steps"]
+        ]
+        order = list(range(len(rule)))
+        rsmi = _add_reagent(self.rsmi, [test["cat"]])
+
+        results, reaction_tree = MultiSteps._process(rule, order, rsmi)
+        target_products = sorted(rsmi.split(">>")[1].split("."))
+        max_depth = len(results)
+        all_paths = _find_all_paths(reaction_tree, target_products, rsmi, max_depth)
+        real_path = all_paths[0][1:]  # remove the original
+        all_steps = MultiSteps._get_aam(real_path, rule, order)
+        self.assertTrue(
+            all(m is not None for m in all_steps),
+            "All mechanism steps should have valid mappings",
+        )
+
+        self.assertEqual(len(all_steps), len(test["steps"]))
+
+    def test_multi_steps(self):
+        test = self.data[0]["mechanisms"][2]
+        rule = [
+            smart_to_gml(value["smart_string"], core=True, explicit_hydrogen=True)
+            for value in test["steps"]
+        ]
+        order = list(range(len(rule)))
+        all_steps = MultiSteps().multi_step(self.rsmi, rule, order, test["cat"])
+        print(all_steps)
+        self.assertTrue(
+            all(m is not None for m in all_steps),
+            "All mechanism steps should have valid mappings",
+        )
+
+        self.assertEqual(len(all_steps), len(test["steps"]))
+
+
+if __name__ == "__main__":
+    unittest.main()