synkit 0.0.7__tar.gz → 0.0.8__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synkit
-Version: 0.0.7
+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

{synkit-0.0.7 → 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.7 → synkit-0.0.8}/Test/Graph/ITS/test_its_expand.py

@@ -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.7 → synkit-0.0.8}/Test/IO/test_chemical_converter.py

@@ -86,7 +86,10 @@ class TestChemicalConversions(unittest.TestCase):
     def test_smiles_to_graph_valid(self):
         # Test converting a valid SMILES to a graph
         result = smiles_to_graph(
-            "[CH3:1][CH2:2][OH:3]", False, True, True, use_index_as_atom_map=True
+            "[CH3:1][CH2:2][OH:3]",
+            False,
+            True,
+            True,
         )
         self.assertIsInstance(result, nx.Graph)
         self.assertEqual(result.number_of_nodes(), 3)
@@ -94,7 +97,10 @@ class TestChemicalConversions(unittest.TestCase):
     def test_smiles_to_graph_invalid(self):
         # Test converting an invalid SMILES string to a graph
         result = smiles_to_graph(
-            "invalid_smiles", True, False, False, use_index_as_atom_map=True
+            "invalid_smiles",
+            True,
+            False,
+            False,
         )
         self.assertIsNone(result)
 

synkit-0.0.8/build-doc.sh

@@ -0,0 +1,31 @@
+#!/bin/bash
+
+set -e
+
+echo "Checking and installing documentation dependencies..."
+
+# Function to check and install a Python package if missing
+install_if_missing() {
+    PACKAGE=$1
+    python -c "import $PACKAGE" 2>/dev/null || {
+        echo "Installing $PACKAGE..."
+        pip install "$PACKAGE"
+    }
+}
+
+# Check and install main Sphinx packages
+install_if_missing sphinx
+install_if_missing sphinx_rtd_theme
+
+# sphinxcontrib-bibtex can have a dash in its import, so:
+pip show sphinxcontrib-bibtex >/dev/null 2>&1 || {
+    echo "Installing sphinxcontrib-bibtex..."
+    pip install sphinxcontrib-bibtex
+}
+
+echo "Building Sphinx documentation..."
+
+# Build the docs (adjust source/build dirs as needed)
+python3 -m sphinx -b html ./doc ./docs
+
+echo "Documentation built in ./docs"

{synkit-0.0.7 → synkit-0.0.8}/doc/api.rst

@@ -2,15 +2,6 @@
 API
 ====
 
-IO Module
-=========
-The `IO` module provides tools for handling input and output operations related to the chemical converter. It allows seamless interaction with various chemical data formats.
-
-.. automodule:: synkit.IO.chem_converter
-   :members:
-   :undoc-members:
-   :show-inheritance:
-
 Chem Module
 ===========
 The `Chem` module provides tools for handling input and output operations related to the chemical converter. It allows seamless interaction with various chemical data formats.
@@ -198,3 +189,47 @@ The ``synkit.Vis`` package offers a suite of **visualization utilities** for bot
    :members:
    :undoc-members:
    :show-inheritance:
+
+IO Module
+=========
+The `IO` module provides tools for handling input and output operations related to the chemical converter. It allows seamless interaction with various chemical data formats.
+
+Chemical Conversion
+-------------------
+.. automodule:: synkit.IO.chem_converter
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+.. automodule:: synkit.IO.mol_to_graph
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+.. automodule:: synkit.IO.graph_to_mol
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+.. automodule:: synkit.IO.nx_to_gml
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+.. automodule:: synkit.IO.gml_to_nx
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+IO Functions
+------------
+
+.. automodule:: synkit.IO.data_io
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+.. automodule:: synkit.IO.data_io
+   :members:
+   :undoc-members:
+   :show-inheritance:

{synkit-0.0.7 → synkit-0.0.8}/doc/io.rst

@@ -102,31 +102,31 @@ Set ``core=True`` to include only the **reaction center**, and ``useSmile=True``
    :linenos:
 
    from synkit.IO import (
-       rsmi_to_its,
-       smart_to_gml,
-       its_to_gml,
-       save_text_as_gml,
-       load_gml_as_text,
+      rsmi_to_its,
+      smart_to_gml,
+      its_to_gml,
+      save_text_as_gml,
+      load_gml_as_text,
    )
 
    # Define the aldol reaction template
    reaction = (
-       '[CH3:1][CH:2]=[O:3].'
-       '[CH:4]([H:7])([H:8])[CH:5]=[O:6]'
-       '>>'
-       '[CH3:1][CH:2]=[CH:4][CH:5]=[O:6].'
-       '[O:3]([H:7])([H:8])'
+      '[CH3:1][CH:2]=[O:3].'
+      '[CH:4]([H:7])([H:8])[CH:5]=[O:6]'
+      '>>'
+      '[CH3:1][CH:2]=[CH:4][CH:5]=[O:6].'
+      '[O:3]([H:7])([H:8])'
    )
 
    # Option 1: Direct SMARTS → GML
-   gml_rule_1 = smart_to_gml(reaction, core=True, useSmile=False)
+   gml_rule_1 = smart_to_gml(reaction, core=True, useSmiles=False)
 
    # Option 2: SMILES → ITS → GML
    its_graph = rsmi_to_its(reaction, core=True)
    gml_rule_2 = its_to_gml(its_graph, core=True)
 
    # Save to disk
-   save_text_as_gml("aldol_rule.gml", gml_rule_2)
+   save_text_as_gml(gml_text=gml_rule_2, file_path="aldol_rule.gml")
 
    # Load back into text
    loaded_rule = load_gml_as_text("aldol_rule.gml")

{synkit-0.0.7 → synkit-0.0.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "synkit"
-version = "0.0.7"
+version = "0.0.8"
 authors = [
     {name="Tieu Long Phan", email="tieu@bioinf.uni-leipzig.de"}
 ]

{synkit-0.0.7 → synkit-0.0.8}/synkit/Chem/Reaction/aam_validator.py

@@ -85,10 +85,10 @@ class AAMValidator:
         its_graphs, rc_graphs = [], []
         try:
             for rsmi in (mapped_smile, ground_truth):
-                G, H = rsmi_to_graph(
-                    rsmi=rsmi, sanitize=True, drop_non_aam=True, light_weight=True
+                G, H = rsmi_to_graph(rsmi=rsmi, sanitize=True, drop_non_aam=True)
+                its = ITSConstruction().ITSGraph(
+                    G, H, ignore_aromaticity=ignore_aromaticity
                 )
-                its = ITSConstruction.ITSGraph(G, H, ignore_aromaticity)
                 its_graphs.append(its)
                 rc_graphs.append(get_rc(its))
 

{synkit-0.0.7 → synkit-0.0.8}/synkit/Graph/Hyrogen/hcomplete.py

@@ -287,7 +287,7 @@ class HComplete:
             current_prod_graph = HComplete.add_hydrogen_nodes_multiple_utils(
                 current_prod_graph, zip(hydrogen_nodes_form, permutation)
             )
-            its = ITSConstruction.ITSGraph(
+            its = ITSConstruction().ITSGraph(
                 current_react_graph,
                 current_prod_graph,
                 ignore_aromaticity=ignore_aromaticity,

{synkit-0.0.7 → synkit-0.0.8}/synkit/Graph/ITS/its_construction.py

@@ -1,5 +1,5 @@
 import networkx as nx
-from typing import Tuple, Dict, Any
+from typing import Tuple, Dict, Any, Optional, List
 from copy import deepcopy
 
 
@@ -211,3 +211,107 @@ class ITSConstruction:
                 new_graph[u][v]["standard_order"] = 0
 
         return new_graph
+
+    @staticmethod
+    def construct(
+        G: nx.Graph,
+        H: nx.Graph,
+        *,
+        ignore_aromaticity: bool = False,
+        balance_its: bool = True,
+        node_attrs: Optional[List[str]] = None,
+        edge_attrs: Optional[List[str]] = None,
+    ) -> nx.Graph:
+        """
+        Constructs an ITS (Imaginary Transition State) graph from two input graphs,
+        and annotates each node and edge with a tuple: ((G attributes...), (H attributes...)).
+
+        The order of attributes in the tuple is defined by `node_attrs` and `edge_attrs`.
+        Users are responsible for remembering the order.
+
+        :param G: The first input NetworkX graph (typically the reactant).
+        :type G: nx.Graph
+        :param H: The second input NetworkX graph (typically the product).
+        :type H: nx.Graph
+        :param ignore_aromaticity: If True, aromaticity is ignored in edge comparison.
+        :type ignore_aromaticity: bool
+        :param balance_its: If True, balances the ITS size using node count.
+        :type balance_its: bool
+        :param node_attrs: List of node attributes for the tuple (order matters!).
+        :type node_attrs: list[str] or None
+        :param edge_attrs: List of edge attributes for the tuple (order matters!).
+        :type edge_attrs: list[str] or None
+
+        :returns: The constructed ITS NetworkX graph with `typesGH` tuples on nodes and edges.
+        :rtype: nx.Graph
+        """
+        if node_attrs is None:
+            node_attrs = [
+                "element",
+                "charge",
+                "atom_map",
+                "hcount",
+                "aromatic",
+                "neighbors",
+            ]
+        if edge_attrs is None:
+            edge_attrs = ["order"]
+
+        # Construct initial ITS graph using the existing method
+        its = ITSConstruction.ITSGraph(
+            G, H, ignore_aromaticity=ignore_aromaticity, balance_its=balance_its
+        )
+
+        # Attach node typesGH as a tuple: ((G attributes...), (H attributes...))
+        for n in its.nodes():
+            g_attrs = tuple(
+                G.nodes[n].get(attr, 0) if n in G.nodes else 0 for attr in node_attrs
+            )
+            h_attrs = tuple(
+                H.nodes[n].get(attr, 0) if n in H.nodes else 0 for attr in node_attrs
+            )
+            its.nodes[n]["typesGH"] = (g_attrs, h_attrs)
+
+        its = ITSConstruction.add_edges_to_ITS(its, G, H, ignore_aromaticity)
+
+        return its
+
+    def typesGH(self) -> Dict[str, Dict[str, Tuple[Any, Any]]]:
+        """
+        Returns the types and default values for selected node and edge attributes, useful for
+        interpreting the 'typesGH' annotation on ITS graphs.
+
+        :returns: Dictionary with node and edge attribute types and defaults, e.g.
+                  {"node": {attr: (type, 0)}, "edge": {attr: (type, 0)}}
+        :rtype: dict[str, dict[str, tuple[type, Any]]]
+        """
+        node_prop_types: Dict[str, Any] = {
+            "element": str,
+            "charge": int,
+            "atom_map": int,
+            "hcount": int,
+            "in_ring": int,
+            "radical": int,
+            "isomer": str,
+            "partial_charge": float,
+            "hybridization": str,
+            "implicit_hcount": int,
+            "neighbors": list,
+            "aromatic": int,
+        }
+        edge_prop_types: Dict[str, Any] = {
+            "order": float,
+            "ez_isomer": str,
+            "bond_type": str,
+            "conjugated": int,
+            "in_ring": int,
+        }
+        sel_nodes = {
+            a: node_prop_types.get(a, int) for a in getattr(self, "node_attrs", [])
+        }
+        sel_edges = {
+            a: edge_prop_types.get(a, int) for a in getattr(self, "edge_attrs", [])
+        }
+        node_defaults = {k: (tp, 0) for k, tp in sel_nodes.items()}
+        edge_defaults = {k: (tp, 0) for k, tp in sel_edges.items()}
+        return {"node": node_defaults, "edge": edge_defaults}

{synkit-0.0.7 → synkit-0.0.8}/synkit/Graph/ITS/its_expand.py

@@ -66,14 +66,13 @@ class ITSExpand:
         # Convert reaction SMILES to graph representation of reactants and products
         r, p = rsmi_to_graph(rsmi)
 
-        # Construct the Intermediate Transition State (ITS) graph from reactants and products
+        # Construct the Imaginary Transition State (ITS) graph from reactants and products
         rc = ITSConstruction().ITSGraph(r, p)
         # rc = get_rc(rc)
 
         # Convert a SMILES string to graph; parameters are indicative and function should exist
         G = smiles_to_graph(
             smi,
-            light_weight=light_weight,
             sanitize=True,
             drop_non_aam=False,
             use_index_as_atom_map=False,

{synkit-0.0.7 → synkit-0.0.8}/synkit/Graph/ITS/normalize_aam.py

@@ -128,7 +128,6 @@ class NormalizeAAM:
             rsmi = FixAAM().fix_aam_rsmi(rsmi)
         r_graph, p_graph = rsmi_to_graph(
             rsmi,
-            light_weight=True,
             sanitize=True,
             use_index_as_atom_map=True,
             drop_non_aam=True,

{synkit-0.0.7 → synkit-0.0.8}/synkit/IO/chem_converter.py

@@ -11,7 +11,7 @@ from synkit.Graph.ITS.its_construction import ITSConstruction
 from synkit.IO.nx_to_gml import NXToGML
 from synkit.IO.gml_to_nx import GMLToNX
 from synkit.Graph.ITS.its_decompose import get_rc, its_decompose
-from synkit.Graph.Hyrogen._misc import implicit_hydrogen
+from synkit.Graph.Hyrogen._misc import implicit_hydrogen, h_to_explicit
 
 
 logger = setup_logging()
@@ -20,9 +20,17 @@ logger = setup_logging()
 def smiles_to_graph(
     smiles: str,
     drop_non_aam: bool = False,
-    light_weight: bool = True,
     sanitize: bool = True,
     use_index_as_atom_map: bool = False,
+    node_attrs: Optional[List[str]] = [
+        "element",
+        "aromatic",
+        "hcount",
+        "charge",
+        "neighbors",
+        "atom_map",
+    ],
+    edge_attrs: Optional[List[str]] = ["order"],
 ) -> Optional[nx.Graph]:
     """
     Helper function to convert a SMILES string to a NetworkX graph.
@@ -59,9 +67,9 @@ def smiles_to_graph(
                 return None
 
         # Convert molecule to graph
-        graph_converter = MolToGraph()
-        graph = graph_converter.mol_to_graph(
-            mol, drop_non_aam, light_weight, use_index_as_atom_map
+        graph_converter = MolToGraph(node_attrs=node_attrs, edge_attrs=edge_attrs)
+        graph = graph_converter.transform(
+            mol, drop_non_aam=drop_non_aam, use_index_as_atom_map=use_index_as_atom_map
         )
         if graph is None:
             logger.warning(f"Failed to convert molecule to graph for SMILES: {smiles}")
@@ -78,9 +86,18 @@ def smiles_to_graph(
 def rsmi_to_graph(
     rsmi: str,
     drop_non_aam: bool = True,
-    light_weight: bool = True,
     sanitize: bool = True,
     use_index_as_atom_map: bool = True,
+    node_attrs: Optional[List[str]] = [
+        "element",
+        "aromatic",
+        "hcount",
+        "charge",
+        "neighbors",
+        "atom_map",
+    ],
+    edge_attrs: Optional[List[str]] = ["order"],
+    explicit_hydrogen: bool = False,
 ) -> Tuple[Optional[nx.Graph], Optional[nx.Graph]]:
     """
     Convert a reaction SMILES (RSMI) into reactant and product graphs.
@@ -103,13 +120,22 @@ def rsmi_to_graph(
         r_graph = smiles_to_graph(
             reactants_smiles,
             drop_non_aam,
-            light_weight,
             sanitize,
             use_index_as_atom_map,
+            node_attrs,
+            edge_attrs,
         )
         p_graph = smiles_to_graph(
-            products_smiles, drop_non_aam, light_weight, sanitize, use_index_as_atom_map
+            products_smiles,
+            drop_non_aam,
+            sanitize,
+            use_index_as_atom_map,
+            node_attrs,
+            edge_attrs,
         )
+        if explicit_hydrogen:
+            r_graph = h_to_explicit(r_graph)
+            p_graph = h_to_explicit(p_graph)
         return (r_graph, p_graph)
     except ValueError:
         logger.error(f"Invalid RSMI format: {rsmi}")
@@ -231,7 +257,7 @@ def smart_to_gml(
     if useSmiles is False:
         smart = rsmarts_to_rsmi(smart)
     r, p = rsmi_to_graph(smart, sanitize=sanitize)
-    its = ITSConstruction.ITSGraph(r, p)
+    its = ITSConstruction().ITSGraph(r, p)
     if core:
         its = get_rc(its)
         r, p = its_decompose(its)
@@ -332,10 +358,19 @@ def gml_to_its(gml: str) -> nx.Graph:
 def rsmi_to_its(
     rsmi: str,
     drop_non_aam: bool = True,
-    light_weight: bool = True,
     sanitize: bool = True,
     use_index_as_atom_map: bool = True,
     core: bool = False,
+    node_attrs: Optional[List[str]] = [
+        "element",
+        "aromatic",
+        "hcount",
+        "charge",
+        "neighbors",
+        "atom_map",
+    ],
+    edge_attrs: Optional[List[str]] = ["order"],
+    explicit_hydrogen: bool = False,
 ) -> nx.Graph:
     """
     Convert a reaction SMILES (rSMI) string to an ITS graph representation.
@@ -357,9 +392,9 @@ def rsmi_to_its(
     :raises Exception: If conversion fails.
     """
     r, p = rsmi_to_graph(
-        rsmi, drop_non_aam, light_weight, sanitize, use_index_as_atom_map
+        rsmi, drop_non_aam, sanitize, use_index_as_atom_map, node_attrs, edge_attrs, explicit_hydrogen
     )
-    its = ITSConstruction.ITSGraph(r, p)
+    its = ITSConstruction().ITSGraph(r, p)
     if core:
         its = get_rc(its)
     return its