synkit 0.0.5__tar.gz → 0.0.7__tar.gz

{synkit-0.0.5 → synkit-0.0.7}/.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.7/.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.5 → synkit-0.0.7}/.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.5 → synkit-0.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synkit
-Version: 0.0.5
+Version: 0.0.7
 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.5 → synkit-0.0.7}/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.7/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.5/Test/Graph/ITS → synkit-0.0.7/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.7/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.5 → synkit-0.0.7}/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.5 → synkit-0.0.7}/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.5 → synkit-0.0.7}/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.5 → synkit-0.0.7}/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.7/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.5 → synkit-0.0.7}/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
 
 

{synkit-0.0.5 → synkit-0.0.7}/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.7/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()

synkit-0.0.7/Test/Graph/MTG/test_groupoid.py

@@ -0,0 +1,181 @@
+import unittest
+from synkit.IO.chem_converter import rsmi_to_its
+from synkit.Graph.MTG.groupoid import charge_tuple, node_constraint, edge_constraint
+
+
+class TestGroupoid(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_direct_charges(self):
+        attrs = {"charges": (0, 1)}
+        self.assertEqual(charge_tuple(attrs), (0, 1))
+
+    def test_both_fields_prioritize_charges(self):
+        attrs = {
+            "charges": (1, 2),
+            "typesGH": ((None, None, None, 3, None), (None, None, None, 4, None)),
+        }
+        # 'charges' should take precedence over 'typesGH'
+        self.assertEqual(charge_tuple(attrs), (1, 2))
+
+    def test_charges_not_tuple(self):
+        attrs = {
+            "charges": [0, 1],  # not a tuple
+            "typesGH": ((None, None, None, 2, None), (None, None, None, 3, None)),
+        }
+        # Non-tuple 'charges' should be ignored in favor of typesGH
+        self.assertEqual(charge_tuple(attrs), (2, 3))
+
+    def test_charges_wrong_length(self):
+        attrs = {
+            "charges": (0,),  # length != 2
+            "typesGH": ((None, None, None, 5, None), (None, None, None, 6, None)),
+        }
+        # Invalid 'charges' length => fallback to typesGH
+        self.assertEqual(charge_tuple(attrs), (5, 6))
+
+    def test_typesGH_valid(self):
+        attrs = {"typesGH": ((None, None, None, 7, None), (None, None, None, 8, None))}
+        self.assertEqual(charge_tuple(attrs), (7, 8))
+
+    def test_typesGH_too_short(self):
+        attrs = {"typesGH": ((None, None, None, 9, None),)}  # only one tuple
+        # Not enough entries => (None, None)
+        self.assertEqual(charge_tuple(attrs), (None, None))
+
+    def test_typesGH_inner_exception(self):
+        attrs = {"typesGH": ((None, None), (None,))}  # inner tuples too short
+        # Should catch exception and return (None, None)
+        self.assertEqual(charge_tuple(attrs), (None, None))
+
+    def test_no_fields(self):
+        # No relevant keys => (None, None)
+        self.assertEqual(charge_tuple({}), (None, None))
+
+    def test_node_constraint(self):
+        m1 = node_constraint(
+            self.test_graph_1[0].nodes(data=True), self.test_graph_1[1].nodes(data=True)
+        )
+        self.assertEqual(len(m1.keys()), 5)
+
+        m2 = node_constraint(
+            self.test_graph_2[0].nodes(data=True), self.test_graph_2[1].nodes(data=True)
+        )
+        self.assertEqual(len(m2.keys()), 3)
+
+    def test_edge_constraint_no_map(self):
+        m1 = edge_constraint(
+            self.test_graph_1[0].edges(data=True),
+            self.test_graph_1[1].edges(data=True),
+            algorithm="bt",
+        )
+        self.assertEqual(len(m1), 46)  # backtracking
+
+        self.assertEqual(
+            len(
+                edge_constraint(
+                    self.test_graph_1[0].edges(data=True),
+                    self.test_graph_1[1].edges(data=True),
+                    algorithm="vf2",
+                )
+            ),
+            30,
+        )  # vf2
+
+        self.assertEqual(
+            len(
+                edge_constraint(
+                    self.test_graph_1[0].edges(data=True),
+                    self.test_graph_1[1].edges(data=True),
+                    algorithm="vf3",
+                )
+            ),
+            30,
+        )  # vf3
+
+        m2 = edge_constraint(
+            self.test_graph_2[0].edges(data=True), self.test_graph_2[1].edges(data=True)
+        )
+        self.assertEqual(len(m2), 2)  # backtracking
+
+        self.assertEqual(
+            len(
+                edge_constraint(
+                    self.test_graph_2[0].edges(data=True),
+                    self.test_graph_2[1].edges(data=True),
+                    algorithm="vf2",
+                )
+            ),
+            2,
+        )
+
+        self.assertEqual(
+            len(
+                edge_constraint(
+                    self.test_graph_2[0].edges(data=True),
+                    self.test_graph_2[1].edges(data=True),
+                    algorithm="vf3",
+                )
+            ),
+            2,
+        )
+
+    def test_edge_constraint_map(self):
+        m0 = node_constraint(
+            self.test_graph_1[0].nodes(data=True), self.test_graph_1[1].nodes(data=True)
+        )
+        m1 = edge_constraint(
+            self.test_graph_1[0].edges(data=True),
+            self.test_graph_1[1].edges(data=True),
+            m0,
+        )
+        self.assertEqual(len(m1), 4)
+
+        self.assertEqual(
+            len(
+                edge_constraint(
+                    self.test_graph_1[0].edges(data=True),
+                    self.test_graph_1[1].edges(data=True),
+                    m0,
+                    algorithm="vf2",
+                )
+            ),
+            1,
+        )
+
+        self.assertEqual(
+            len(
+                edge_constraint(
+                    self.test_graph_1[0].edges(data=True),
+                    self.test_graph_1[1].edges(data=True),
+                    m0,
+                    algorithm="vf3",
+                )
+            ),
+            1,
+        )
+
+        m0 = node_constraint(
+            self.test_graph_2[0].nodes(data=True), self.test_graph_2[1].nodes(data=True)
+        )
+        m2 = edge_constraint(
+            self.test_graph_2[0].edges(data=True),
+            self.test_graph_2[1].edges(data=True),
+            m0,
+        )
+        self.assertEqual(len(m2), 0)
+
+
+if __name__ == "__main__":
+    unittest.main()

synkit-0.0.7/Test/Graph/MTG/test_mtg.py

@@ -0,0 +1,39 @@
+import unittest
+from synkit.IO.chem_converter import rsmi_to_its
+from synkit.Graph.ITS.its_decompose import get_rc
+from synkit.Graph.MTG.group_comp import GroupComp
+from synkit.Graph.MTG.mtg import MTG
+
+
+class TestMTG(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 = [get_rc(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 = [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)
+
+    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)
+
+
+if __name__ == "__main__":
+    unittest.main()