synkit 0.0.6__tar.gz → 0.0.8__tar.gz

{synkit-0.0.6 → synkit-0.0.8}/.github/workflows/build-doc.yml

@@ -23,6 +23,7 @@ jobs:
           cache: 'pip' # caching pip dependencies
       - run: pip install -r requirements.txt
       - run: pip install sphinx sphinx-rtd-theme
+      - run: pip install sphinxcontrib-bibtex
       - run: python3 -m sphinx ./doc docs
       - name: publish doc
         shell: bash

synkit-0.0.8/.github/workflows/test-and-lint.yml

@@ -0,0 +1,68 @@
+name: Test & Lint
+
+on:
+  push:
+    branches: [ "main", "dev", "maintain", "refractor" ]
+  pull_request:
+    branches: [ "main" ]
+
+permissions:
+  contents: read
+
+jobs:
+  test-lint:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      # 0) Check out the code
+      - uses: actions/checkout@v3
+
+      # 1) Install Miniconda (downloaded — the “bundled” version was removed)
+      - name: Set up Miniconda
+        uses: conda-incubator/setup-miniconda@v2
+        with:
+          miniconda-version: "latest"      # <<–‑‑ mandatory or the action fails
+          python-version: "3.11"
+          auto-update-conda: true
+          environment-file: environment.yml
+          activate-environment: synkit-env
+          use-mamba: true                  # optional, just faster
+
+      # 2) Extra Linux‑only dependency: mod ≥ 0.17
+      - name: Install mod (Linux only)
+        if: matrix.os == 'ubuntu-latest'
+        run: conda run -n synkit-env conda install -c jakobandersen -c conda-forge "mod>=0.17" -y
+
+      # 3) Optional extra project deps via pip (requirements.txt)
+      - name: Install project requirements
+        if: hashFiles('requirements.txt') != ''
+        run: conda run -n synkit-env pip install -r requirements.txt
+
+      # 4a) Lint on Linux/macOS
+      - name: Lint (Unix)
+        if: matrix.os != 'windows-latest'
+        shell: bash -l {0}
+        run: |
+          conda activate synkit-env
+          bash lint.sh
+
+      # 4b) Lint on Windows
+      - name: Lint (Windows)
+        if: matrix.os == 'windows-latest'
+        shell: bash -l {0}
+        run: |
+          conda activate synkit-env
+          bash lint.sh
+
+
+      # 5) Test
+      - name: Test
+        shell: bash -l {0}
+        run: |
+          conda activate synkit-env
+          bash pytest.sh

{synkit-0.0.6 → synkit-0.0.8}/.gitignore

@@ -4,19 +4,19 @@
 */catboost_info/*
 *.ipynb
 *.json
-test_mod.py
-test_format.py
-*dev_zone
 *.pkl.gz
-dev_scripts/*
 *.pdf
 out
 summary
-Data/Benchmark/its.json.gz
-Data/Benchmark/rc.json.gz
 *.log
 .coverage
 dev/*
 *.rdf
 Data/Testcase/hydro/aam.json.gz
 synkit/Chem/FG/*
+test_syn_reactor.py
+Data/Benchmark/*
+# *.png
+*.json.gz
+run.sh
+docs/*

{synkit-0.0.6 → synkit-0.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synkit
-Version: 0.0.6
+Version: 0.0.8
 Summary: Utility for reaction modeling using graph grammar
 Project-URL: homepage, https://github.com/TieuLongPhan/SynKit
 Project-URL: source, https://github.com/TieuLongPhan/SynKit
@@ -14,7 +14,7 @@ Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.11
 Requires-Dist: networkx>=3.3
 Requires-Dist: pandas>=1.5.3
-Requires-Dist: rdkit>=2024.3.3
+Requires-Dist: rdkit>=2025.3.1
 Requires-Dist: regex>=2024.11.6
 Requires-Dist: requests>=2.32.3
 Requires-Dist: scikit-learn>=1.4.0

{synkit-0.0.6 → synkit-0.0.8}/Test/Chem/Molecule/test_standardize.py

@@ -17,7 +17,7 @@ class TestMoleculeFunctions(unittest.TestCase):
 
     def test_normalize_molecule(self):
         smi = "[Na]OC(=O)c1ccc(C[S+2]([O-])([O-]))cc1"
-        expect = "O=C(O[Na])c1ccc(C[S](=O)=O)cc1"
+        expect = "O=C([O][Na])c1ccc(C[S](=O)=O)cc1"
         mol = Chem.MolFromSmiles(smi)
         normalized_mol = normalize_molecule(mol)
         self.assertIsInstance(normalized_mol, Chem.Mol)

synkit-0.0.8/Test/Chem/Reaction/test_aam_utils.py

@@ -0,0 +1,52 @@
+import unittest
+from rdkit import Chem
+from synkit.Chem.Reaction.aam_utils import enumerate_tautomers, mapping_success_rate
+
+
+class TestChemUtils(unittest.TestCase):
+    def test_enumerate_tautomers_simple(self):
+        # A simple keto-enol tautomerism: acetylacetone (CC(=O)CC=O) -> same product
+        reaction = "CC(=O)CC=O>>O"
+        tautomers = enumerate_tautomers(reaction)
+        # Should return a list with at least the original reaction
+        self.assertIsInstance(tautomers, list)
+        self.assertIn(reaction, tautomers)
+        # Each entry should be a valid reaction SMILES
+        for rsmi in tautomers:
+            self.assertIsInstance(rsmi, str)
+            parts = rsmi.split(">>")
+            self.assertEqual(len(parts), 2)
+            # Reactant and product part parseable by RDKit
+            self.assertIsNotNone(Chem.MolFromSmiles(parts[0]))
+            self.assertIsNotNone(Chem.MolFromSmiles(parts[1]))
+
+    def test_enumerate_tautomers_invalid(self):
+        # Invalid SMILES input
+        bad = "INVALID>>SMILES"
+        result = enumerate_tautomers(bad)
+        # Should return list with original
+        self.assertEqual(result, [bad])
+
+    def test_mapping_success_rate_normal(self):
+        data = ["C:1CC", "CCC", "O:3=O", ":5", "N"]
+        rate = mapping_success_rate(data)
+        # Entries with mapping: 'C:1CC', 'O:3=O', ':5' => 3/5 = 60.0%
+        self.assertEqual(rate, 60.0)
+
+    def test_mapping_success_rate_empty(self):
+        with self.assertRaises(ValueError):
+            mapping_success_rate([])
+
+    def test_mapping_success_rate_all(self):
+        data = [":1C", ":2", "N:3"]
+        rate = mapping_success_rate(data)
+        self.assertEqual(rate, 100.0)
+
+    def test_mapping_success_rate_none(self):
+        data = ["C", "O", "N"]
+        rate = mapping_success_rate(data)
+        self.assertEqual(rate, 0.0)
+
+
+if __name__ == "__main__":
+    unittest.main()

{synkit-0.0.6/Test/Graph/ITS → synkit-0.0.8/Test/Chem/Reaction}/test_aam_validator.py

@@ -1,5 +1,5 @@
 import unittest
-from synkit.Graph.ITS.aam_validator import AAMValidator
+from synkit.Chem.Reaction.aam_validator import AAMValidator
 
 
 class TestAMMValidator(unittest.TestCase):

synkit-0.0.8/Test/Chem/Reaction/test_canon_rsmi.py

@@ -0,0 +1,52 @@
+import unittest
+import networkx as nx
+from synkit.Chem.Reaction.canon_rsmi import CanonRSMI
+from synkit.IO.chem_converter import rsmi_to_graph
+
+
+class TestCanonRSMI(unittest.TestCase):
+    def setUp(self):
+        # Use generic backend for deterministic behavior
+        self.canon = CanonRSMI(backend="wl", wl_iterations=5)
+        # Example reaction SMILES with atom-map labels
+        self.input_rsmi = "[CH3:3][CH2:5][OH:10]>>[CH2:3]=[CH2:5].[OH2:10]"
+        # After expand_aam and canonicalisation, since backend is generic,
+        # we expect the SMILES to remain unchanged (identity)
+        self.expected_canonical = "[CH2:1]([CH3:2])[OH:3]>>[CH2:1]=[CH2:2].[OH2:3]"
+
+    def test_raw_and_canonical_rsmi(self):
+        result = self.canon.canonicalise(self.input_rsmi)
+        self.assertEqual(result.raw_rsmi, self.input_rsmi)
+        self.assertEqual(result.canonical_rsmi, self.expected_canonical)
+
+    def test_mapping_pairs(self):
+        result = self.canon(self.input_rsmi)
+        # Mapping pairs should preserve identity mapping
+        # mapping_pairs will be matching (map_new, map_old)
+        self.assertEqual(sorted(result.mapping_pairs), [(1, 5), (2, 3), (3, 10)])
+
+    def test_graphs_and_hashes(self):
+        result = self.canon(self.input_rsmi)
+        # raw graphs should parse correctly
+        r_raw, p_raw = rsmi_to_graph(self.input_rsmi)
+        self.assertIsInstance(result.raw_reactant_graph, nx.Graph)
+        self.assertIsInstance(result.raw_product_graph, nx.Graph)
+        # canonical graphs should also be Graph
+        self.assertIsInstance(result.canonical_reactant_graph, nx.Graph)
+        self.assertIsInstance(result.canonical_product_graph, nx.Graph)
+        # reactant_hash and product_hash should match underlying canonicaliser
+        h_reac = self.canon._canon.canonical_signature(result.canonical_reactant_graph)
+        h_prod = self.canon._canon.canonical_signature(result.canonical_product_graph)
+        # canonical_hash is combined
+        self.assertEqual(result.canonical_hash, f"{h_reac}>>{h_prod}")
+
+    def test_idempotence(self):
+        # Applying canonicalise twice yields same result
+        result1 = self.canon(self.input_rsmi)
+        result2 = self.canon(result1.canonical_rsmi)
+        self.assertEqual(result1.canonical_rsmi, result2.canonical_rsmi)
+        self.assertEqual(result1.mapping_pairs, result2.mapping_pairs)
+
+
+if __name__ == "__main__":
+    unittest.main()

{synkit-0.0.6 → synkit-0.0.8}/Test/Chem/Reaction/test_deionize.py

@@ -34,7 +34,7 @@ class TestDeionize(unittest.TestCase):
     def test_uncharge_smiles(self):
         charge_smiles = "[Na+].[OH-]"
         uncharged_smiles = Deionize.uncharge_smiles(charge_smiles)
-        self.assertEqual(uncharged_smiles, "O[Na]")  # can not uncharge amonium
+        self.assertEqual(uncharged_smiles, "[OH][Na]")
 
     def test_apply_uncharge_smiles_to_reactions(self):
         reactions = [{"reactants": "[NH4+].[OH-]", "products": "N.O"}]

{synkit-0.0.6 → synkit-0.0.8}/Test/Graph/Context/test_radius_expand.py

@@ -3,7 +3,7 @@ import networkx as nx
 from synkit.IO.data_io import load_from_pickle
 from synkit.Graph.ITS.its_decompose import get_rc
 from synkit.Graph.Context.radius_expand import RadiusExpand
-from synkit.Graph.Cluster.graph_morphism import graph_isomorphism, subgraph_isomorphism
+from synkit.Graph.Matcher.graph_morphism import graph_isomorphism, subgraph_isomorphism
 
 
 class TestRadiusExpand(unittest.TestCase):

{synkit-0.0.6 → synkit-0.0.8}/Test/Graph/Feature/test_graph_descriptors.py

@@ -183,7 +183,7 @@ class TestGraphDescriptor(unittest.TestCase):
 
         # Run the descriptor function
         results = GraphDescriptor.process_entries_in_parallel(
-            self.data_parallel, "GraphRules", "ITSGraph", n_jobs=4
+            self.data_parallel, "GraphRules", "ITSGraph", n_jobs=1
         )
         self.assertEqual(results[0]["topo"], expected_output["topo"])
         self.assertEqual(results[0]["cycle"], expected_output["cycle"])

{synkit-0.0.6 → synkit-0.0.8}/Test/Graph/Hydrogen/test_graph_hydrogen.py

@@ -1,8 +1,8 @@
 import unittest
-from synkit.Graph.ITS.aam_validator import AAMValidator
-from synkit.Graph.Cluster.graph_morphism import graph_isomorphism
+from synkit.Chem.Reaction.aam_validator import AAMValidator
+from synkit.Graph.Matcher.graph_morphism import graph_isomorphism
 from synkit.IO.chem_converter import rsmi_to_graph, graph_to_rsmi
-from synkit.Graph.Hyrogen._misc import implicit_hydrogen, explicit_hydrogen
+from synkit.Graph.Hyrogen._misc import implicit_hydrogen, h_to_explicit
 
 
 class TestGraphH(unittest.TestCase):
@@ -53,7 +53,7 @@ class TestGraphH(unittest.TestCase):
 
     def test_explicit_hydrogen(self):
         r_imp, p_imp = rsmi_to_graph(self.implicit_rsmi)
-        r_ex, p_ex = explicit_hydrogen(r_imp), explicit_hydrogen(p_imp)
+        r_ex, p_ex = h_to_explicit(r_imp), h_to_explicit(p_imp)
         r, p = rsmi_to_graph(self.rsmi)
         self.assertTrue(graph_isomorphism(r, r_ex))
         self.assertTrue(graph_isomorphism(p, p_ex))

synkit-0.0.8/Test/Graph/Hydrogen/test_misc.py

@@ -0,0 +1,92 @@
+import unittest
+
+from synkit.Graph.Hyrogen._misc import (
+    has_XH,
+    h_to_implicit,
+    h_to_explicit,
+    check_explicit_hydrogen,
+    check_hcount_change,
+)
+from synkit.IO.chem_converter import rsmi_to_its
+from synkit.Graph.ITS.its_decompose import its_decompose
+
+
+class TestHydrogenUtilities(unittest.TestCase):
+
+    def setUp(self):
+        # Explicit hydrogen example
+        self.rsmi_explicit = "[C:1]=[C:2].[H:3][H:4]>>[C:1]([H:3])[C:2][H:4]"
+        self.its_explicit = rsmi_to_its(self.rsmi_explicit)
+        self.rc_explicit = self.its_explicit
+        self.r_explicit, self.p_explicit = its_decompose(self.rc_explicit)
+
+        # Implicit hydrogen example
+        self.rsmi_implicit = "[C:1]=[C:2].[H:3][H:4]>>[CH:1][CH:2]"
+        self.its_implicit = rsmi_to_its(self.rsmi_implicit)
+        self.rc_implicit = self.its_implicit
+        self.r_implicit, self.p_implicit = its_decompose(self.rc_implicit)
+
+    def test_has_XH_explicit(self):
+        self.assertTrue(
+            has_XH(self.rc_explicit), "Explicit hydrogen bonds should be detected."
+        )
+
+    def test_has_XH_implicit(self):
+        self.assertFalse(
+            has_XH(self.rc_implicit),
+            "Implicit hydrogen representation should have no explicit X-H bonds.",
+        )
+
+    def test_h_to_implicit_removes_H_nodes(self):
+        G = self.rc_explicit
+        heavy_atoms = [n for n, d in G.nodes(data=True) if d.get("element") != "H"]
+        G_implicit = h_to_implicit(G)
+        h_nodes = [n for n, d in G_implicit.nodes(data=True) if d.get("element") == "H"]
+        self.assertEqual(len(h_nodes), 0, "All hydrogen nodes should be removed.")
+        for n in heavy_atoms:
+            self.assertGreaterEqual(
+                G_implicit.nodes[n].get("hcount", 0),
+                1,
+                "Heavy atoms should have hcount ≥ 1.",
+            )
+
+    def test_h_to_explicit_adds_H_nodes(self):
+        G = self.rc_explicit
+        G_implicit = h_to_implicit(G)
+        heavy_atoms = [
+            n for n, d in G_implicit.nodes(data=True) if d.get("element") != "H"
+        ]
+        G_expanded = h_to_explicit(G_implicit, heavy_atoms)
+        h_nodes = [n for n, d in G_expanded.nodes(data=True) if d.get("element") == "H"]
+        self.assertGreaterEqual(len(h_nodes), 2, "Hydrogen nodes should be added back.")
+
+    def test_roundtrip_hydrogen_conversion(self):
+        G = self.rc_explicit
+        heavy_atoms = [n for n, d in G.nodes(data=True) if d.get("element") != "H"]
+        G1 = h_to_implicit(G)
+        G2 = h_to_explicit(G1, heavy_atoms)
+        h_nodes = [n for n, d in G2.nodes(data=True) if d.get("element") == "H"]
+        self.assertGreaterEqual(
+            len(h_nodes),
+            2,
+            "Hydrogens should be recoverable after roundtrip conversion.",
+        )
+
+    def test_check_explicit_hydrogen(self):
+        count, ids = check_explicit_hydrogen(self.rc_explicit)
+        self.assertEqual(count, 2, "Should detect 2 explicit hydrogens.")
+        self.assertEqual(len(ids), 2)
+        for node_id in ids:
+            self.assertEqual(self.rc_explicit.nodes[node_id]["element"], "H")
+
+    def test_check_hcount_change_explicit(self):
+        delta = check_hcount_change(self.r_explicit, self.p_explicit)
+        self.assertEqual(delta, 2, "Expected hydrogen movement in explicit graph.")
+
+    def test_check_hcount_change_implicit(self):
+        delta = check_hcount_change(self.r_implicit, self.p_implicit)
+        self.assertEqual(delta, 2, "Expected hydrogen movement in implicit graph.")
+
+
+if __name__ == "__main__":
+    unittest.main()

{synkit-0.0.6 → synkit-0.0.8}/Test/Graph/ITS/test_its_construction.py

@@ -21,21 +21,21 @@ class TestITSConstruction(unittest.TestCase):
         self.H.add_edge(1, 2, order=1)  # Different order
 
     def test_ITSGraph(self):
-        ITS = ITSConstruction.ITSGraph(self.G, self.H)
+        ITS = ITSConstruction().ITSGraph(self.G, self.H)
         self.assertTrue(isinstance(ITS, nx.Graph))
         self.assertEqual(len(ITS.nodes()), 2)
         self.assertEqual(len(ITS.edges()), 1)
         self.assertEqual(ITS[1][2]["order"], (2, 1))
 
     def test_get_node_attributes_with_defaults(self):
-        attributes = ITSConstruction.get_node_attributes_with_defaults(self.G, 1)
+        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)
+        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))
@@ -43,7 +43,7 @@ class TestITSConstruction(unittest.TestCase):
     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)
+        updated_graph = ITSConstruction().add_standard_order_attribute(graph)
         self.assertEqual(updated_graph[1][2]["standard_order"], -1)
 
 

{synkit-0.0.6 → synkit-0.0.8}/Test/Graph/ITS/test_its_expand.py

@@ -1,5 +1,5 @@
 import unittest
-from synkit.Graph.ITS.aam_validator import AAMValidator
+from synkit.Chem.Reaction.aam_validator import AAMValidator
 from synkit.Graph.ITS.its_expand import ITSExpand
 
 
@@ -12,6 +12,7 @@ class TestPartialExpand(unittest.TestCase):
             "[CH3:1][CH2:2][CH2:3][Cl:4].[NH2:5][H:6]"
             + ">>[CH3:1][CH2:2][CH2:3][NH2:5].[Cl:4][H:6]"
         )
+        print(output_rsmi)
         self.assertTrue(AAMValidator.smiles_check(output_rsmi, expected_rsmi, "ITS"))
 
 

{synkit-0.0.6 → synkit-0.0.8}/Test/Graph/ITS/test_normalize_aam.py

@@ -1,7 +1,7 @@
 import unittest
 import networkx as nx
 from synkit.Graph.ITS.normalize_aam import NormalizeAAM
-from synkit.Graph.ITS.aam_validator import AAMValidator
+from synkit.Chem.Reaction.aam_validator import AAMValidator
 
 
 class TestNormalizeAAM(unittest.TestCase):

synkit-0.0.8/Test/Graph/MTG/test_group_comp.py

@@ -0,0 +1,52 @@
+import unittest
+from synkit.IO.chem_converter import rsmi_to_its
+from synkit.Graph.MTG.groupoid import node_constraint
+from synkit.Graph.MTG.group_comp import GroupComp
+
+
+class TestGroupComp(unittest.TestCase):
+
+    def setUp(self) -> None:
+        test_1 = [
+            "[CH:4]([H:7])([H:8])[CH:5]=[O:6]>>[CH:4]([H:8])=[CH:5][O:6]([H:7])",
+            "[CH3:1][CH:2]=[O:3].[CH:4]([H:8])=[CH:5][O:6]([H:7])>>[CH3:1][CH:2]([O:3][H:7])[CH:4]([H:8])[CH:5]=[O:6]",
+        ]
+        self.test_graph_1 = [rsmi_to_its(var) for var in test_1]
+        test_2 = [
+            "[CH2:1]=[CH:2]-[CH2+:3]>>[CH2+:1]-[CH:2]=[CH2:3]",
+            "[H:1]-[CH2:2]-[CH2+:3]>>[CH2:2]=[CH2:3].[H+:1]",
+        ]
+        self.test_graph_2 = [rsmi_to_its(var) for var in test_2]
+
+    def test_get_mapping(self):
+        g = GroupComp(self.test_graph_1[0], self.test_graph_1[1])
+        m = g.get_mapping(include_singleton=False)
+        self.assertEqual(len(m), 4)
+
+    def test_get_mapping_singleton(self):
+        g = GroupComp(self.test_graph_1[0], self.test_graph_1[1])
+        m = g.get_mapping(include_singleton=True)
+        self.assertEqual(len(m), 10)
+
+    def test_get_mapping_from_nodes(self):
+        m0 = node_constraint(
+            self.test_graph_2[0].nodes(data=True), self.test_graph_2[1].nodes(data=True)
+        )
+        g = GroupComp(self.test_graph_2[0], self.test_graph_2[1])
+        m = g.get_mapping_from_nodes(
+            m0,
+            self.test_graph_2[0].edges(data=True),
+            self.test_graph_2[1].edges(data=True),
+        )
+        self.assertEqual(len(m), 1)
+
+    def test_get_mapping_fallback(self):
+        g = GroupComp(self.test_graph_2[0], self.test_graph_2[1])
+        m = g.get_mapping(
+            include_singleton=False
+        )  # even False if cannot find candidate will fall back
+        self.assertEqual(len(m), 1)
+
+
+if __name__ == "__main__":
+    unittest.main()