synkit 0.0.4__tar.gz → 0.0.5__tar.gz

synkit-0.0.5/.github/workflows/build-doc.yml

@@ -0,0 +1,34 @@
+name: Build documentation for GitHub Pages 
+
+on:
+  push:
+    branches: 
+      - main
+
+  workflow_dispatch: # Enable manual action trigger
+
+env:
+  PYTHONPATH: .
+
+jobs:
+  build_documentation_for_github_pages:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-python@v4
+        with:
+          python-version: '3.11'
+          cache: 'pip' # caching pip dependencies
+      - run: pip install -r requirements.txt
+      - run: pip install sphinx sphinx-rtd-theme
+      - run: python3 -m sphinx ./doc docs
+      - name: publish doc
+        shell: bash
+        run: |
+          git config user.name "GitHub Action"
+          git config user.email "no@mail.tmp"
+          git add -f docs/
+          git commit -m "Doc build"
+          git push --force "https://github.com/TieuLongPhan/SynKit.git" `git subtree split --prefix docs/ main`:gh-pages

{synkit-0.0.4 → synkit-0.0.5}/.gitignore

@@ -16,3 +16,7 @@ Data/Benchmark/its.json.gz
 Data/Benchmark/rc.json.gz
 *.log
 .coverage
+dev/*
+*.rdf
+Data/Testcase/hydro/aam.json.gz
+synkit/Chem/FG/*

synkit-0.0.5/Makefile

@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?=
+SPHINXBUILD   ?= sphinx-build
+SOURCEDIR     = source
+BUILDDIR      = build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

{synkit-0.0.4 → synkit-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synkit
-Version: 0.0.4
+Version: 0.0.5
 Summary: Utility for reaction modeling using graph grammar
 Project-URL: homepage, https://github.com/TieuLongPhan/SynKit
 Project-URL: source, https://github.com/TieuLongPhan/SynKit
@@ -19,9 +19,9 @@ Requires-Dist: regex>=2024.11.6
 Requires-Dist: requests>=2.32.3
 Requires-Dist: scikit-learn>=1.4.0
 Requires-Dist: seaborn>=0.13.2
-Requires-Dist: torch>=2.2.0
 Provides-Extra: all
 Requires-Dist: numpy>=2.2.0; extra == 'all'
+Requires-Dist: torch>=2.2.0; extra == 'all'
 Description-Content-Type: text/markdown
 
 # SynKit

{synkit-0.0.4 → synkit-0.0.5}/Test/Chem/Fingerprint/test_fp_calculator.py

@@ -1,13 +1,11 @@
 import unittest
-import pandas as pd
-
 from synkit.Chem.Fingerprint.fp_calculator import FPCalculator
 
 
 class TestFPCalculator(unittest.TestCase):
     def setUp(self):
         # Sample data setup
-        self.data = pd.DataFrame(
+        self.data = [
             {
                 "smiles": [
                     (
@@ -25,39 +23,36 @@ class TestFPCalculator(unittest.TestCase):
                 ],
                 "ID": [1, 2, 3],
             }
-        )
-        self.smiles_column = "smiles"
+        ]
+        self.smiles_key = "smiles"
         self.fp_type = "drfp"
         self.n_jobs = 2
         self.verbose = 0
-        self.save_path = None
 
         # Instantiate the FPCalculator
         self.fp_calculator = FPCalculator(
-            data=self.data,
-            smiles_column=self.smiles_column,
+            smiles_key=self.smiles_key,
             fp_type=self.fp_type,
             n_jobs=self.n_jobs,
             verbose=self.verbose,
-            save_path=self.save_path,
         )
 
     def test_init_invalid_fp_type(self):
         with self.assertRaises(ValueError):
-            FPCalculator(data=self.data, fp_type="invalid_type")
+            FPCalculator(smiles_key=self.smiles_key, fp_type="invalid_type")
 
     def test_fit_missing_column(self):
         with self.assertRaises(ValueError):
             fp_calculator = FPCalculator(
-                data=pd.DataFrame({"not_smiles": ["C"]}), smiles_column="smiles"
+                smiles_key=self.smiles_key,
+                fp_type=self.fp_type,
             )
-            fp_calculator.fit()
+            fp_calculator.dict_process({"not_smiles": ["C"]}, "smiles")
 
     def test_constructor_and_attribute_assignment(self):
-        self.assertEqual(self.fp_calculator.smiles_column, "smiles")
+        self.assertEqual(self.fp_calculator.smiles_key, "smiles")
         self.assertEqual(self.fp_calculator.fp_type, "drfp")
         self.assertEqual(self.fp_calculator.n_jobs, 2)
-        self.assertIsNone(self.fp_calculator.save_path)
 
 
 if __name__ == "__main__":

{synkit-0.0.4 → synkit-0.0.5}/Test/Graph/Cluster/test_graph_morphism.py

@@ -2,7 +2,12 @@ import unittest
 from synkit.IO.data_io import load_from_pickle
 from synkit.IO.chem_converter import rsmi_to_its
 from synkit.Graph.ITS.its_decompose import get_rc
-from synkit.Graph.Cluster.graph_morphism import graph_isomorphism, subgraph_isomorphism
+from synkit.Graph.Cluster.graph_morphism import (
+    graph_isomorphism,
+    subgraph_isomorphism,
+    maximum_connected_common_subgraph,
+    heuristics_MCCS,
+)
 
 
 class TestGraphMorphism(unittest.TestCase):
@@ -46,6 +51,21 @@ class TestGraphMorphism(unittest.TestCase):
         result = subgraph_isomorphism(self.rc, self.its, check_type="induced")
         self.assertFalse(result)
 
+    def test_maximum_connected_common_subgraph(self):
+        mcs = maximum_connected_common_subgraph(
+            self.graphs[0]["RC"], self.graphs[1]["RC"]
+        )
+        self.assertEqual(mcs.number_of_nodes(), 3)
+        self.assertGreater(
+            self.graphs[0]["RC"].number_of_nodes(), mcs.number_of_nodes()
+        )
+
+    def test_heuristics_MCCS(self):
+        graphs = [value["RC"] for value in self.graphs]
+        mcs = heuristics_MCCS(graphs[:3])
+        self.assertEqual(mcs.number_of_nodes(), 1)
+        self.assertGreater(graphs[0].number_of_nodes(), mcs.number_of_nodes())
+
 
 if __name__ == "__main__":
     unittest.main()

synkit-0.0.5/Test/Graph/Context/test_hier_context.py

@@ -0,0 +1,173 @@
+import unittest
+from copy import deepcopy
+from synkit.IO.data_io import load_from_pickle
+from synkit.Graph.Context.hier_context import HierContext
+
+
+class TestRuleCluster(unittest.TestCase):
+    def setUp(self) -> None:
+        # Create an instance of HierContext with max_radius=3.
+        self.cluster = HierContext(max_radius=3)
+        # Load test data from a pickle file.
+        # Ensure this file exists at the specified location: "Data/Testcase/graph.pkl.gz"
+        self.data = load_from_pickle("Data/Testcase/graph.pkl.gz")
+        # Verify that the loaded data is a non-empty list.
+        self.assertIsInstance(self.data, list)
+        self.assertGreater(len(self.data), 0, "Loaded test data should not be empty.")
+
+    def test_group_class(self):
+        """
+        Tests the _group_class function by grouping dictionaries based on a key.
+        """
+        data = [
+            {"a": 1, "value": "x"},
+            {"a": 2, "value": "y"},
+            {"a": 1, "value": "z"},
+            {"a": 3, "value": "w"},
+        ]
+        grouped = HierContext._group_class(data, "a")
+        expected = {
+            1: [{"a": 1, "value": "x"}, {"a": 1, "value": "z"}],
+            2: [{"a": 2, "value": "y"}],
+            3: [{"a": 3, "value": "w"}],
+        }
+        self.assertEqual(
+            grouped,
+            expected,
+            "The grouped output does not match the expected grouping.",
+        )
+
+    def test_update_child_idx(self):
+        """
+        Tests the _update_child_idx function to ensure that child IDs are correctly added
+        based on parent–cluster relationships.
+        """
+        # Create a two-layer hierarchy:
+        # Layer 0: One node with 'class' = 1.
+        # Layer 1: Two nodes with 'class' = 2 and 3, each having Parent set to 1.
+        layer0 = [{"class": 1}]
+        layer1 = [{"class": 2, "Parent": 1}, {"class": 3, "Parent": 1}]
+        data = [layer0, layer1]
+        updated = HierContext._update_child_idx(data, cls_id="class")
+
+        # The node from layer 0 should have its "Child" field updated with the class IDs from layer 1.
+        self.assertIn("Child", updated[0][0])
+        self.assertEqual(
+            set(updated[0][0]["Child"]),
+            {2, 3},
+            "The 'Child' list of the parent node does not contain the expected child class IDs.",
+        )
+
+    def test_process(self):
+        """
+        Tests the _process function which extracts a context, computes a hash,
+        and clusters the data.
+        """
+        # Use the loaded test data.
+        data = deepcopy(self.data)
+        cluster_results, templates = HierContext._process(
+            data,
+            k=1,
+            its_key="ITS",
+            context_key="K",
+            cls_func=self.cluster.cluster,
+        )
+
+        # Validate that the first processed data entry has updated keys.
+        self.assertIn(
+            "R_1", cluster_results[0], "Cluster result should include the key 'R_1'."
+        )
+        self.assertIn(
+            "K",
+            cluster_results[0],
+            "Cluster result should include the context key 'K'.",
+        )
+        self.assertIsInstance(
+            cluster_results[0]["R_1"],
+            int,
+            "Cluster identifier 'R_1' should be an integer.",
+        )
+
+        # Check that templates are processed correctly.
+        # Depending on your dummy clustering behavior, update these expected values.
+        self.assertGreater(len(templates), 0, "Templates list should not be empty.")
+        self.assertEqual(
+            templates[0]["class"],
+            0,
+            "Expected the first template's 'class' to be 0 after processing.",
+        )
+        # If you expect a specific number of templates from your test data, verify it.
+        # Here, we expect 61 templates. Change if necessary.
+        self.assertEqual(len(templates), 61, "Unexpected number of templates produced.")
+        self.assertIn("K", templates[0], "Template should contain the context key 'K'.")
+
+    def test_process_level(self):
+        """
+        Tests the _process_level function by grouping data based on parent cluster IDs,
+        processing each group, and then verifying that cluster keys and templates are updated.
+        """
+        # Use the loaded test data for processing at a child level.
+        data = deepcopy(self.data)
+        cluster_indices, templates = self.cluster._process_level(
+            data, "ITS", "K", self.cluster.cluster, 1
+        )
+
+        # Check that each clustered result has the "R_1" field.
+        self.assertIn(
+            "R_1",
+            cluster_indices[0],
+            "Each cluster result should have the 'R_1' field for level 1 clustering.",
+        )
+        self.assertIn(
+            "K", cluster_indices[0], "Each cluster result should contain the key 'K'."
+        )
+        # Validate that templates include the necessary keys.
+        self.assertIn("K", templates[0], "Each template should contain the key 'K'.")
+        self.assertIn(
+            "Parent",
+            templates[0],
+            "Each template should contain the key 'Parent' to link to a parent cluster.",
+        )
+
+    def test_fit(self):
+        """
+        Tests the fit method which processes a list of graph data entries, classifying each based on
+        hierarchical clustering, and verifies that cluster indices and templates are updated at multiple levels.
+        """
+        data, templates = self.cluster.fit(self.data, its_key="ITS", context_key="K")
+
+        # Check that each data entry has keys for the expected levels.
+        for level in range(4):  # Levels 0, 1, 2, 3 (since max_radius=3)
+            self.assertIn(
+                f"R_{level}",
+                data[0],
+                f"Data entry should include the key 'R_{level}' after processing.",
+            )
+
+        # Check that a template list exists for each hierarchical level.
+        self.assertEqual(
+            len(templates), 4, "There should be 4 levels of templates (0, 1, 2, 3)."
+        )
+
+        # Validate that the first template of the parent level contains required keys.
+        self.assertIn(
+            "K",
+            templates[0][0],
+            "The first template in level 0 should contain the key 'K'.",
+        )
+        self.assertIn(
+            "Child",
+            templates[0][0],
+            "The first template in level 0 should contain the key 'Child' if child relationships were established.",
+        )
+        # Validate that a template in level 1 contains a Parent key.
+        if len(templates) > 1 and templates[1]:
+            self.assertIn(
+                "Parent",
+                templates[1][0],
+                "Templates at level 1 should contain the key 'Parent' linking to the parent cluster.",
+            )
+
+
+if __name__ == "__main__":
+    unittest.main()

synkit-0.0.5/Test/Graph/Context/test_radius_expand.py

@@ -0,0 +1,108 @@
+import unittest
+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
+
+
+class TestRadiusExpand(unittest.TestCase):
+
+    def setUp(self):
+        self.data = load_from_pickle("Data/Testcase/graph.pkl.gz")
+
+    def test_find_unequal_order_edges(self):
+        # Create a graph with edges that include various 'order' and 'standard_order' attributes.
+        G = nx.Graph()
+        # Edge qualifies: unequal order and standard_order != 0.
+        G.add_edge(1, 2, order=(1, 2), standard_order=1)
+        # Edge does not qualify: equal order.
+        G.add_edge(2, 3, order=(1, 1), standard_order=1)
+        # Edge qualifies.
+        G.add_edge(3, 4, order=(2, 3), standard_order=1)
+        # Edge does not qualify because standard_order == 0.
+        G.add_edge(1, 3, order=(1, 2), standard_order=0)
+        result = set(RadiusExpand.find_unequal_order_edges(G))
+        expected = {1, 2, 3, 4}
+        self.assertEqual(result, expected)
+
+    def test_extract_subgraph(self):
+        # Create a test graph
+        G = nx.Graph()
+        G.add_edges_from([(1, 2), (2, 3), (3, 4)])
+
+        # Node indices for subgraph extraction
+        node_indices = [2, 3]
+
+        # Extract subgraph and test
+        subgraph = RadiusExpand.extract_subgraph(G, node_indices)
+        self.assertTrue(nx.is_isomorphic(subgraph, nx.Graph([(2, 3)])))
+
+    def test_longest_radius_extension(self):
+        # Create a graph where a chain of edges with standard_order == 0 exists.
+        G = nx.Graph()
+        G.add_edge(0, 1, standard_order=0)
+        G.add_edge(1, 2, standard_order=0)
+        # This edge is blocked because standard_order != 0.
+        G.add_edge(2, 3, standard_order=1)
+        # Compute longest extension from node 0.
+        path = RadiusExpand.longest_radius_extension(G, [0])
+        self.assertEqual(path, [0, 1, 2])
+
+        # Add an alternative branch: from node 1 to node 4.
+        G.add_edge(1, 4, standard_order=0)
+        # Now, DFS might find either [0, 1, 2] or [0, 1, 4]. Both have length 3.
+        path2 = RadiusExpand.longest_radius_extension(G, [0])
+        self.assertEqual(len(path2), 3)
+        self.assertTrue(set(path2).issubset(set(G.nodes())))
+
+    def test_remove_normal_edges(self):
+        # Build a graph with a custom attribute 'weight' and remove those edges where weight == 0.
+        G = nx.Graph()
+        G.add_edge(1, 2, weight=0)
+        G.add_edge(2, 3, weight=1)
+        G.add_edge(3, 4, weight=0)
+        G.add_edge(4, 5, weight=2)
+        modified = RadiusExpand.remove_normal_edges(G, "weight")
+        # Expected to keep only edges where weight is not 0: (2,3) and (4,5).
+        expected_edges = {(2, 3), (4, 5)}
+        self.assertEqual(set(modified.edges()), expected_edges)
+
+    def test_extract_k(self):
+        its = self.data[0]["ITS"]
+        rc = get_rc(its)
+        context = RadiusExpand.extract_k(its, 0)
+        self.assertTrue(graph_isomorphism(rc, context, use_defaults=True))
+
+        # Test with a positive n_knn value.
+        context = RadiusExpand.extract_k(its, 1)
+        self.assertTrue(subgraph_isomorphism(rc, context))
+        self.assertTrue(subgraph_isomorphism(context, its))
+
+        # Test with n_knn == -1 to automatically determine neighbor expansion.
+        context = RadiusExpand.extract_k(its, -1)
+        self.assertTrue(graph_isomorphism(its, context, use_defaults=True))
+
+    def test_context_extraction(self):
+        data = self.data[0]
+        result = RadiusExpand.context_extraction(
+            data, its_key="ITS", context_key="K", n_knn=1
+        )
+        self.assertIn("K", result)
+        self.assertTrue(subgraph_isomorphism(result["RC"], result["K"]))
+        self.assertTrue(subgraph_isomorphism(result["K"], result["ITS"]))
+
+    def test_paralle_context_extraction(self):
+        data_list = self.data[0:3]
+        results = RadiusExpand.paralle_context_extraction(
+            data_list, its_key="ITS", context_key="K", n_jobs=1, verbose=0, n_knn=1
+        )
+        self.assertEqual(len(results), 3)
+        for res in results:
+            self.assertIn("K", res)
+            self.assertTrue(subgraph_isomorphism(res["RC"], res["K"]))
+            self.assertTrue(subgraph_isomorphism(res["K"], res["ITS"]))
+
+
+if __name__ == "__main__":
+    unittest.main()

{synkit-0.0.4/Test/Graph → synkit-0.0.5/Test/Graph/Hydrogen}/test_graph_hydrogen.py

@@ -2,7 +2,7 @@ import unittest
 from synkit.Graph.ITS.aam_validator import AAMValidator
 from synkit.Graph.Cluster.graph_morphism import graph_isomorphism
 from synkit.IO.chem_converter import rsmi_to_graph, graph_to_rsmi
-from synkit.Graph.hydrogen import implicit_hydrogen, explicit_hydrogen
+from synkit.Graph.Hyrogen._misc import implicit_hydrogen, explicit_hydrogen
 
 
 class TestGraphH(unittest.TestCase):

synkit-0.0.5/Test/Graph/Hydrogen/test_hcomplete.py

@@ -0,0 +1,77 @@
+import unittest
+import networkx as nx
+from copy import deepcopy
+from synkit.IO.data_io import load_from_pickle
+from synkit.Graph.ITS.its_decompose import its_decompose
+from synkit.Graph.Hyrogen.hcomplete import HComplete
+
+
+class TestHComplete(unittest.TestCase):
+
+    def setUp(self):
+        """Setup before each test."""
+        # Create sample graphs
+        self.data = load_from_pickle("./Data/Testcase/hydro/hydrogen_test.pkl.gz")
+
+    def test_process_single_graph_data_success(self):
+        """Test the process_single_graph_data method."""
+        processed_data = HComplete.process_single_graph_data(self.data[0], "ITS", "RC")
+        self.assertTrue(isinstance(processed_data["ITS"], nx.Graph))
+        self.assertTrue(isinstance(processed_data["RC"], nx.Graph))
+
+    def test_process_single_graph_data_fail(self):
+        """Test the process_single_graph_data method."""
+        processed_data = HComplete.process_single_graph_data(self.data[16], "ITS", "RC")
+        self.assertIsNone(processed_data["ITS"])
+        self.assertIsNone(processed_data["RC"])
+
+    def test_process_single_graph_data_empty_graph(self):
+        """Test that an empty graph results in empty ITSGraph and GraphRules."""
+        empty_graph_data = {
+            "ITS": None,
+            "RC": None,
+        }
+
+        processed_data = HComplete.process_single_graph_data(
+            empty_graph_data, "ITSGraph"
+        )
+
+        # Ensure the result is None or empty as expected for an empty graph
+        self.assertIsNone(processed_data["ITS"])
+        self.assertIsNone(processed_data["RC"])
+
+    def test_process_graph_data_parallel(self):
+        """Test the process_graph_data_parallel method."""
+        result = HComplete().process_graph_data_parallel(
+            self.data,
+            "ITS",
+            "RC",
+            n_jobs=1,
+            verbose=0,
+        )
+        result = [value for value in result if value["ITS"]]
+        # Check if the result matches the input data structure
+        self.assertEqual(len(result), 45)  # 45 valid graphs
+
+    def test_process_multiple_hydrogens(self):
+        """Test the process_multiple_hydrogens method."""
+        graphs = deepcopy(self.data[0])
+        its = graphs["ITS"]
+        react_graph, prod_graph = its_decompose(its)
+
+        result = HComplete.process_multiple_hydrogens(
+            graphs,
+            "ITS",
+            "RC",
+            react_graph,
+            prod_graph,
+            ignore_aromaticity=False,
+            balance_its=True,
+        )
+
+        self.assertTrue(isinstance(result["ITS"], nx.Graph))
+        self.assertTrue(isinstance(result["RC"], nx.Graph))
+
+
+if __name__ == "__main__":
+    unittest.main()

synkit-0.0.5/doc/conf.py

@@ -0,0 +1,30 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# For the full list of built-in configuration values, see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Project information -----------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
+
+project = "synkit"
+copyright = "2025, Tieu-Long Phan"
+author = "Tieu-Long Phan"
+
+# -- General configuration ---------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
+
+extensions = [
+    "sphinx.ext.autodoc",
+    "sphinx.ext.autosectionlabel",
+    "sphinx.ext.githubpages",
+]
+
+templates_path = ["_templates"]
+exclude_patterns = []
+
+
+# -- Options for HTML output -------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
+
+html_theme = "sphinx_rtd_theme"
+html_static_path = ["_static"]

synkit-0.0.5/doc/getting_started.rst

@@ -0,0 +1,66 @@
+.. _getting-started-synkit:
+
+===============
+Getting Started
+===============
+
+Welcome to the **synkit** documentation. This guide will assist you in setting up **synkit**, a versatile toolkit designed to streamline and enhance your workflows.
+
+Introduction
+------------
+
+**synkit** is designed to provide tools and functions that simplify complex tasks and improve productivity. It is essential for professionals looking to optimize their processes efficiently.
+
+Installation
+============
+
+Installing **synkit** is straightforward using pip, the Python package installer. For a more controlled and conflict-free environment, we recommend setting up **synkit** within a virtual environment.
+
+Requirements
+------------
+
+Before installing **synkit**, ensure you have Python 3.11 or later installed on your machine. The use of a virtual environment is recommended to avoid conflicts with other Python packages.
+
+Creating a Virtual Environment (Optional)
+-----------------------------------------
+
+Setting up a virtual environment for **synkit** is an optional but recommended step. It isolates the installation and dependencies of **synkit** from other Python projects, which helps prevent conflicts and maintain a clean workspace.
+
+1. **Create a virtual environment**:
+
+   Use the following command to create a virtual environment named `synkit_env`. This step requires the `conda` package manager, which can be installed via the Anaconda distribution.
+
+   .. code-block:: bash
+
+       conda create -n synkit_env python=3.11
+
+2. **Activate the virtual environment**:
+
+   Once the environment is created, activate it using:
+
+   .. code-block:: bash
+
+       conda activate synkit_env
+
+Installing **synkit** via Pip
+---------------------------------
+
+After setting up and activating your virtual environment, install **synkit** using pip by running the following command:
+
+.. code-block:: bash
+
+   pip install synkit
+
+This command will download and install the latest version of **synkit** along with its required dependencies.
+
+
+Further Resources
+=================
+
+For more detailed documentation, usage examples, and API guides, visit the [official **synkit** documentation](https://tieulongphan.github.io/SynKit).
+
+Support
+-------
+
+If you encounter any issues or require assistance, please refer to the community support forums or file an issue on the [**synkit** GitHub page](https://github.com/TieuLongPhan/SynKit/issues).
+

synkit-0.0.5/doc/index.rst

@@ -0,0 +1,23 @@
+.. synutility documentation master file, created by
+   sphinx-quickstart on Fri Oct 18 11:47:09 2024.
+   You can adapt this file completely to your liking, but it should at least
+   contain the root `toctree` directive.
+
+Welcome to synkit documentation!
+====================================
+
+Add your content using ``reStructuredText`` syntax. See the
+`reStructuredText <https://www.sphinx-doc.org/en/master/usage/restructuredtext/index.html>`_
+documentation for details.
+
+
+.. toctree::
+   :maxdepth: 2
+   
+   getting_started
+   io
+   graph
+   reactor
+   rule
+   references
+