synkit 0.0.5__tar.gz → 0.0.6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synkit
-Version: 0.0.5
+Version: 0.0.6
 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.5 → synkit-0.0.6}/pyproject.toml

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

{synkit-0.0.5 → synkit-0.0.6}/synkit/Chem/Molecule/standardize.py

@@ -88,7 +88,9 @@ def remove_explicit_hydrogens(mol: Chem.Mol) -> Chem.Mol:
     return Chem.RemoveHs(mol)
 
 
-def remove_radicals_and_add_hydrogens(mol: Chem.Mol) -> Optional[Chem.Mol]:
+def remove_radicals_and_add_hydrogens(
+    mol: Chem.Mol, removeH=True
+) -> Optional[Chem.Mol]:
     """
     Remove radicals from a molecule by setting radical electrons to zero and adding hydrogens where needed.
 
@@ -98,7 +100,7 @@ def remove_radicals_and_add_hydrogens(mol: Chem.Mol) -> Optional[Chem.Mol]:
     Returns:
     - Chem.Mol: Mol object with radicals removed and necessary hydrogens added.
     """
-    mol = Chem.RemoveHs(mol)  # Remove explicit hydrogens first
+    # mol = Chem.RemoveHs(mol)  # Remove explicit hydrogens first
     for atom in mol.GetAtoms():
         if atom.GetNumRadicalElectrons() > 0:
             atom.SetNumExplicitHs(
@@ -106,7 +108,10 @@ def remove_radicals_and_add_hydrogens(mol: Chem.Mol) -> Optional[Chem.Mol]:
             )
         atom.SetNumRadicalElectrons(0)
     mol = rdmolops.AddHs(mol)  # Add hydrogens back
-    return remove_explicit_hydrogens(mol)
+    if removeH:
+        return remove_explicit_hydrogens(mol)
+    else:
+        return mol
 
 
 def remove_isotopes(mol: Chem.Mol) -> Chem.Mol:
@@ -138,7 +143,7 @@ def clear_stereochemistry(mol: Chem.Mol) -> Chem.Mol:
     return mol
 
 
-def fix_radical_rsmi(rsmi: str) -> str:
+def fix_radical_rsmi(rsmi: str, removeH=True) -> str:
     """
     Takes a reaction SMILES string with potential radicals and returns a new reaction SMILES string
     where all radicals have been replaced by adding hydrogen atoms.
@@ -150,12 +155,13 @@ def fix_radical_rsmi(rsmi: str) -> str:
     - str: A reaction SMILES string with radicals replaced by hydrogen atoms.
     """
     r, p = rsmi.split(">>")
-    r_mol = Chem.MolFromSmiles(r)
-    p_mol = Chem.MolFromSmiles(p)
-
+    r_mol = Chem.MolFromSmiles(r, sanitize=False)
+    p_mol = Chem.MolFromSmiles(p, sanitize=False)
+    Chem.SanitizeMol(r_mol)
+    Chem.SanitizeMol(p_mol)
     if r_mol is not None and p_mol is not None:
-        r_mol = remove_radicals_and_add_hydrogens(r_mol)
-        p_mol = remove_radicals_and_add_hydrogens(p_mol)
+        r_mol = remove_radicals_and_add_hydrogens(r_mol, removeH)
+        p_mol = remove_radicals_and_add_hydrogens(p_mol, removeH)
 
         r_smiles = Chem.MolToSmiles(r_mol) if r_mol else r
         p_smiles = Chem.MolToSmiles(p_mol) if p_mol else p

synkit-0.0.6/synkit/Rule/compose_rule.py

@@ -0,0 +1,210 @@
+from typing import List, Set, Any, Dict, Optional
+from synkit.IO.chem_converter import gml_to_smart, smart_to_gml
+from synkit.Rule.rule_utils import _increment_gml_ids
+from synkit.Chem.Reaction.standardize import Standardize
+from synkit.Chem.Reaction.cleanning import Cleanning
+from synkit.Chem.Reaction.rsmi_utils import find_longest_fragment
+from mod import RCMatch, ruleGMLString
+from synkit.Reactor.core_engine import CoreEngine
+
+
+class ComposeRule:
+
+    @staticmethod
+    def filter_smallest_vertex(combo: List[object]) -> List[object]:
+        """
+        Filters and returns the elements from a list that have the smallest
+        number of vertices in their context.
+
+        Parameters:
+        - combo (List[object]): A list of objects, each with a 'context'
+        attribute that has a 'numVertices' attribute.
+
+        Returns:
+        - List[object]: A list of objects from the input list that have
+        the minimum number of vertices in their context.
+        """
+        # Extract the number of vertices from each rule's context and find the minimum
+        num_vertices = [rule.context.numVertices for rule in combo]
+        min_vertex = min(num_vertices)
+
+        # Collect all rules that have the minimum number of vertices
+        new_combo = [
+            rule
+            for rule, vertices in zip(combo, num_vertices)
+            if vertices == min_vertex
+        ]
+
+        return new_combo
+
+    @staticmethod
+    def rule_cluster(graphs: List[Any]) -> List[Any]:
+        """
+        Cluster graphs based on their isomorphic relationships and
+        return a representative from each cluster.
+
+        Parameters:
+        - graphs (List[Any]): A list of graph objects.
+
+        Returns:
+        - List[Any]: A list of graphs where each graph is a representative from a different cluster.
+        """
+        visited: Set[int] = set()
+        clusters: List[Set[int]] = []
+
+        for i, graph_i in enumerate(graphs):
+            if i in visited:
+                continue
+            cluster: Set[int] = {i}
+            visited.add(i)
+            for j, graph_j in enumerate(graphs):
+                if j in visited or j <= i:
+                    continue
+                # Assuming isomorphism() returns 1 for isomorphic graphs.
+                if graph_i.isomorphism(graph_j) == 1:
+                    cluster.add(j)
+                    visited.add(j)
+            clusters.append(cluster)
+
+        representative_graphs = [graphs[list(cluster)[0]] for cluster in clusters]
+        return representative_graphs
+
+    @staticmethod
+    def _compose_mapping(
+        rule_1: str, rule_2: str, mapping: Dict[int, int], return_string: bool = True
+    ) -> Any:
+        """
+        Compose two rule graphs from their GML representations using a mapping between external IDs.
+
+        Parameters:
+        - rule_1 (str): The GML representation for the first rule.
+        - rule_2 (str): The GML representation for the second rule.
+        - mapping (Dict[int, int]): A dictionary mapping external IDs in the first rule (child side)
+                                    to corresponding external IDs in the second rule (parent side).
+        - return_string (bool): If True, returns the composed rule as a GML string.
+
+        Returns:
+        - Any: The composed rule object or its GML string if return_string is True.
+        """
+        # Create rule objects from the GML inputs.
+        r1 = ruleGMLString(rule_1)
+        r2 = ruleGMLString(rule_2)
+
+        # Create an RCMatch object with r1 and r2.
+        m = RCMatch(r1, r2)
+
+        # Push alignments between vertices according to the mapping.
+        for child_ext_id, parent_ext_id in mapping.items():
+            v1 = r1.getVertexFromExternalId(child_ext_id)
+            v2 = r2.getVertexFromExternalId(parent_ext_id)
+            m.push(v1.right, v2.left)
+
+        # Compose the mapping.
+        composed_rule = m.compose()
+        if return_string:
+            composed_rule = composed_rule.getGMLString()
+        return composed_rule
+
+    @staticmethod
+    def _compose(rule_1: str, rule_2: str, return_string: bool = True) -> List[Any]:
+        """
+        Compose two rules and return a list of modifications that pass chemical valence checks.
+
+        Parameters:
+        - rule_1 (str): The first rule (in GML format) to compose.
+        - rule_2 (str): The second rule (in GML format) to compose.
+        - return_string (bool): If True, returns the composed rules as GML strings.
+
+        Returns:
+        - List[Any]: A list of valid composed rules (either as rule objects or as GML strings).
+                      Returns an empty list if an error occurs.
+        """
+        try:
+            m = RCMatch(
+                ruleGMLString(rule_1, add=False), ruleGMLString(rule_2, add=False)
+            )
+            modRes = m.composeAll()
+            modRes = ComposeRule.rule_cluster(modRes)
+            if return_string:
+                modRes = [i.getGMLString() for i in modRes]
+            return modRes
+        except Exception as e:
+            print("Error during rule composition:", e)
+            return []
+
+    @staticmethod
+    def _get_valid_rule(rules: List[str], format: str = "gml") -> List[str]:
+        """
+        Validate and convert a list of rule GML strings to either SMARTS or GML format.
+
+        Parameters:
+        - rules (List[str]): A list of rule GML strings.
+        - format (str): The output format. 'smart' returns SMARTS strings; otherwise, returns GML strings.
+
+        Returns:
+        - List[str]: A list of valid rules in the desired format.
+        """
+        new_rules: List[str] = []
+        for value in rules:
+            new = gml_to_smart(value, sanitize=True, explicit_hydrogen=False)[0]
+            if "Error" not in new:
+                if format == "smart":
+                    new_rules.append(new)
+                else:
+                    new_rules.append(
+                        smart_to_gml(new, sanitize=True, explicit_hydrogen=False)
+                    )
+        return new_rules
+
+    @staticmethod
+    def _get_comp_reaction(smart_1: str, smart_2: str) -> str:
+        """
+        Compute a representative reaction SMILES for the composed rule from two SMARTS strings.
+
+        Parameters:
+        - smart_1 (str): The first reaction in SMARTS notation.
+        - smart_2 (str): The second reaction in SMARTS notation.
+
+        Returns:
+        - str: A standardized reaction SMILES representing the composition.
+        """
+        std = Standardize()
+        rsmi_1 = std.fit(smart_1)
+        rsmi_2 = std.fit(smart_2)
+        r1, p1 = rsmi_1.split(">>")
+        r2, p2 = rsmi_2.split(">>")
+        new_rsmi = std.fit(f"{r1}.{r2}>>{p1}.{p2}")
+        return new_rsmi
+
+    def get_rule_comp(self, smart_1: str, smart_2: str) -> Optional[str]:
+        """
+        Compose two reaction SMARTS strings into a rule (GML format) that reproduces a reference reaction.
+
+        Parameters:
+        - smart_1 (str): The first reaction in SMARTS notation.
+        - smart_2 (str): The second reaction in SMARTS notation.
+
+        Returns:
+        - Optional[str]: The composed rule (in GML) if a valid candidate is found; otherwise, None.
+        """
+        rule_1 = smart_to_gml(smart_1, sanitize=True, explicit_hydrogen=False)
+        rule_2 = smart_to_gml(smart_2, sanitize=True, explicit_hydrogen=False)
+        reference_rsmi = self._get_comp_reaction(smart_1, smart_2)
+        candidate_rules = self._compose(rule_1, rule_2, return_string=True)
+        candidate_rules = [_increment_gml_ids(value) for value in candidate_rules]
+        initial_smiles = reference_rsmi.split(">>")[0].split(".")
+        largest_prod = find_longest_fragment(reference_rsmi.split(">>")[1].split("."))
+        cds = []
+        for candidate in candidate_rules:
+            inferred_rsmi = CoreEngine()._inference(candidate, initial_smiles)
+            inferred_rsmi = Cleanning.clean_smiles(inferred_rsmi)
+            inferred_prod = [i.split(">>")[1].split(".") for i in inferred_rsmi]
+            if any(largest_prod in smi for smi in inferred_prod):
+                cds.append(candidate)
+                # return candidate
+
+        cds = [ruleGMLString(i) for i in cds]
+        cds = self.filter_smallest_vertex(cds)
+        cds = [i.getGMLString() for i in cds]
+
+        return cds

synkit-0.0.6/synkit/Rule/rule_mapping.py

@@ -0,0 +1,314 @@
+import copy
+import networkx as nx
+from operator import eq
+from typing import Dict, List, Optional, Set, Tuple, Any
+from networkx.algorithms.isomorphism import generic_node_match, generic_edge_match
+from synkit.IO.chem_converter import gml_to_its
+
+
+class RuleMapping:
+    @staticmethod
+    def enumerate_all_unique_mappings(
+        child: nx.Graph, parent: nx.Graph
+    ) -> List[Dict[Any, Any]]:
+        """
+        Generate all unique mappings (as dictionaries) from the child graph to the parent graph.
+        A mapping is valid if:
+        - Every node from the child graph is assigned exactly one parent node.
+        - The parent's node has the same 'element' attribute as the child node.
+        - No parent's node is repeated in a mapping.
+
+        Parameters:
+        - child (nx.Graph): The child graph whose nodes will be mapped.
+        - parent (nx.Graph): The parent graph in which to search for matching nodes.
+
+        Returns:
+        - List[dict]: A list of mapping dictionaries. Each dictionary maps a child node to a unique
+                      parent node with the same 'element'. If no valid mapping exists, returns an empty list.
+        """
+        # Build candidate sets for each node in child, based on matching 'element' in parent
+        candidate_map: Dict[Any, List[Any]] = {}
+        for node, attrs in child.nodes(data=True):
+            element = attrs.get("element")
+            # Gather all parent nodes with the same element
+            candidates = [
+                pnode
+                for pnode, p_attrs in parent.nodes(data=True)
+                if p_attrs.get("element") == element
+            ]
+            candidate_map[node] = candidates
+
+        all_mappings: List[Dict[Any, Any]] = []
+        child_nodes = list(child.nodes())
+
+        def backtrack(
+            i: int, current_mapping: Dict[Any, Any], used_parents: Set[Any]
+        ) -> None:
+            # If we've assigned every child node, store a copy of the mapping.
+            if i == len(child_nodes):
+                all_mappings.append(current_mapping.copy())
+                return
+
+            child_node = child_nodes[i]
+            for candidate in candidate_map.get(child_node, []):
+                if candidate not in used_parents:
+                    current_mapping[child_node] = candidate
+                    used_parents.add(candidate)
+                    backtrack(i + 1, current_mapping, used_parents)
+                    used_parents.remove(candidate)
+                    del current_mapping[child_node]
+
+        # Backtracking to explore all valid mappings
+        backtrack(0, {}, set())
+        return all_mappings
+
+    @staticmethod
+    def standardize_order(
+        order_tuple: Tuple[float, ...],
+    ) -> Optional[Tuple[float, ...]]:
+        """
+        Standardizes an order tuple by adding 1 to every element repeatedly until no element is negative.
+        If the resulting tuple becomes all zeros, returns None, which indicates that the edge should be dropped.
+
+        For example:
+          (-1.0, 0.0) --> add 1 gives (0.0, 1.0)
+          (-2.0, -1.0) --> add 1 yields (-1.0, 0.0) --> add 1 yields (0.0, 1.0)
+          (0.0, 0.0) remains (0.0, 0.0) and then returns None.
+
+        Parameters:
+        - order_tuple (Tuple[float, ...]): The order attribute (tuple of floats).
+
+        Returns:
+        - Optional[Tuple[float, ...]]: The standardized tuple, or None if it becomes all zeros.
+        """
+        order_list = list(order_tuple)
+        while any(x < 0 for x in order_list):
+            order_list = [x + 1 for x in order_list]
+        if all(x == 0 for x in order_list):
+            return None
+        return tuple(order_list)
+
+    @staticmethod
+    def keep_largest_component(graph: nx.Graph) -> nx.Graph:
+        """
+        Given an undirected graph, returns the subgraph corresponding to the largest connected component.
+
+        Parameters:
+        - graph (nx.Graph): The input graph from which the largest component is extracted.
+
+        Returns:
+        - nx.Graph: A subgraph induced by the largest connected component of the input graph.
+        """
+        if graph.number_of_nodes() == 0:
+            return graph
+        # Find all connected components
+        components = list(nx.connected_components(graph))
+        # Identify the largest by number of nodes
+        largest = max(components, key=len)
+        # Return the induced subgraph (as a new, independent graph)
+        return graph.subgraph(largest).copy()
+
+    @staticmethod
+    def subtract_parent_from_child(
+        child: nx.Graph, parent: nx.Graph, mapping: Dict[Any, Any]
+    ) -> nx.Graph:
+        """
+        Create a new graph by performing a (parent - child) subtraction of edge attributes
+        using a given mapping from child nodes to parent nodes. The result is then reduced
+        to its largest connected component.
+
+        Steps:
+        1. Make a deep copy of the parent graph and remove all its edges.
+        2. Build the union of the parent's edges plus the child's edges mapped into the parent's node IDs.
+        3. For each edge in the union (using parent node IDs):
+            - new_standard_order = parent's standard_order - child's standard_order.
+            - If an 'order' tuple exists:
+                a. If one side is missing, assume zeros of appropriate length.
+                b. Compute (parent_order - child_order) element-wise.
+                c. Standardize the resulting tuple via standardize_order().
+                d. If None, omit the edge entirely.
+        4. Add each valid edge to the new graph.
+        5. Keep only the largest connected component.
+
+        Parameters:
+        - child (nx.Graph): The child graph (provides edge attributes to subtract).
+        - parent (nx.Graph): The parent graph (provides baseline edge/node attributes).
+        - mapping (Dict[Any, Any]): A one-to-one mapping from child nodes to parent nodes.
+
+        Returns:
+        - nx.Graph: A new graph (deep copy of parent, with edges recomputed),
+                    reduced to its largest connected component.
+        """
+        # 1. Deep copy the parent and remove its edges
+        new_graph = copy.deepcopy(parent)
+        new_graph.remove_edges_from(list(new_graph.edges()))
+
+        # 2. Build union of edges. We'll store them in a dictionary (u, v) -> {"parent", "child"}
+        union_edges: Dict[Tuple[Any, Any], Dict[str, Dict[str, Any]]] = {}
+
+        # Parent edges
+        for u, v, pdata in parent.edges(data=True):
+            key = tuple(sorted([u, v], key=lambda x: str(x)))
+            union_edges.setdefault(key, {})["parent"] = pdata
+
+        # Child edges (mapped)
+        for u, v, cdata in child.edges(data=True):
+            parent_u = mapping.get(u)
+            parent_v = mapping.get(v)
+            if parent_u is None or parent_v is None:
+                continue
+            key = tuple(sorted([parent_u, parent_v], key=lambda x: str(x)))
+            union_edges.setdefault(key, {})["child"] = cdata
+
+        # 3. Compute new edge attributes
+        for (u, v), entry in union_edges.items():
+            parent_data = entry.get("parent", {})
+            child_data = entry.get("child", {})
+
+            parent_so = parent_data.get("standard_order", 0)
+            child_so = child_data.get("standard_order", 0)
+            new_so = parent_so - child_so
+
+            parent_order = parent_data.get("order", None)
+            child_order = child_data.get("order", None)
+
+            new_order = None
+            if parent_order is not None or child_order is not None:
+                # If one side is missing, assume zero tuple
+                if parent_order is None and child_order is not None:
+                    parent_order = tuple(0 for _ in child_order)
+                if child_order is None and parent_order is not None:
+                    child_order = tuple(0 for _ in parent_order)
+
+                # Subtract if they match in length
+                if (
+                    isinstance(parent_order, tuple)
+                    and isinstance(child_order, tuple)
+                    and len(parent_order) == len(child_order)
+                ):
+                    computed_order = tuple(
+                        p - c for p, c in zip(parent_order, child_order)
+                    )
+                    new_order = RuleMapping.standardize_order(computed_order)
+
+            new_edge_data = {"standard_order": new_so}
+            # Only add the 'order' attribute if new_order is not None
+            if new_order is not None:
+                new_edge_data["order"] = new_order
+                # If new_order is None, we skip adding this edge
+
+            if new_order is not None:
+                new_graph.add_edge(u, v, **new_edge_data)
+
+        # 4. Return the largest connected component
+        return RuleMapping.keep_largest_component(new_graph)
+
+    @staticmethod
+    def graph_alignment(
+        child: nx.Graph,
+        parent: nx.Graph,
+        node_label_names: List[str] = ["element"],
+        node_label_default: List[str] = ["*"],
+        edge_attribute: str = "standard_order",
+    ) -> Tuple[bool, Optional[Dict[Any, Any]]]:
+        """
+        Check whether the child and parent graphs are isomorphic using specified node and edge match criteria.
+        If they are isomorphic, return the mapping from child to parent.
+
+        Parameters:
+        - child (nx.Graph): The child graph to align.
+        - parent (nx.Graph): The parent graph to align with.
+        - node_label_names (List[str]): Node attribute names for matching (default: ["element"]).
+        - node_label_default (List[str]): Default values for those attributes if missing (default: ["*"]).
+        - edge_attribute (str): The edge attribute to match (default: "standard_order").
+
+        Returns:
+        - Tuple[bool, Optional[Dict[Any, Any]]]:
+            A tuple (is_iso, mapping):
+              - is_iso (bool): True if the graphs are isomorphic; otherwise, False.
+              - mapping (dict or None): The child→parent node mapping if isomorphic, else None.
+        """
+        node_match = generic_node_match(
+            node_label_names, node_label_default, [eq] * len(node_label_names)
+        )
+        edge_match = generic_edge_match(edge_attribute, 1, eq)
+
+        gm = nx.algorithms.isomorphism.GraphMatcher(
+            child, parent, node_match=node_match, edge_match=edge_match
+        )
+        is_iso = gm.is_isomorphic()
+        return is_iso, (gm.mapping if is_iso else None)
+
+    @staticmethod
+    def get_child1_to_child2_mapping(
+        mapping_child1_to_parent: Dict[Any, Any],
+        mapping_child2_to_parent: Dict[Any, Any],
+    ) -> Dict[Any, Optional[Any]]:
+        """
+        Build a mapping from Child1 to Child2 using each child's mapping to a common Parent.
+
+        If a Parent node in Child1's mapping is not in Child2's inverted mapping,
+        that Child1 node will map to None.
+
+        Parameters:
+        - mapping_child1_to_parent (dict): Mapping from Child1 nodes → Parent nodes.
+        - mapping_child2_to_parent (dict): Mapping from Child2 nodes → Parent nodes.
+
+        Returns:
+        - dict: A dictionary from Child1 node → Child2 node based on the shared Parent node.
+        """
+        # Invert Child2→Parent to get Parent→Child2
+        inverted_child2 = {
+            parent_node: child2_node
+            for child2_node, parent_node in mapping_child2_to_parent.items()
+        }
+
+        # Build Child1→Child2 by looking up each Parent node in the inverted Child2 mapping
+        mapping_child1_to_child2: Dict[Any, Optional[Any]] = {}
+        for child1_node, parent_node in mapping_child1_to_parent.items():
+            mapping_child1_to_child2[child1_node] = inverted_child2.get(
+                parent_node, None
+            )
+        mapping_child1_to_child2 = {
+            key: value
+            for key, value in mapping_child1_to_child2.items()
+            if value is not None
+        }
+        return mapping_child1_to_child2
+
+    def fit(self, rule_1: str, rule_2: str, comp_rule: str) -> Optional[Dict[Any, Any]]:
+        """
+        Demonstrate an alignment-based composition workflow using the class methods.
+
+        1. Convert each GML-based rule into an internal graph (via gml_to_its).
+        2. Enumerate all unique mappings from rule_2 to comp_rule.
+        3. For each mapping, subtract rule_2 from comp_rule using that mapping.
+        4. Check if rule_1 is isomorphic to the resulting new graph.
+           - If isomorphic, build a child1→child2 mapping and return it.
+
+        Parameters:
+        - rule_1 (str): GML representation of the first rule.
+        - rule_2 (str): GML representation of the second rule.
+        - comp_rule (str): GML representation of a composite rule.
+
+        Returns:
+        - Optional[dict]: A dictionary mapping rule_1's nodes to the new_graph's nodes if alignment is found.
+                          Returns None otherwise.
+        """
+        # Convert GML to internal graph structures
+        rc_1 = gml_to_its(rule_1)
+        rc_2 = gml_to_its(rule_2)
+        comp_its = gml_to_its(comp_rule)
+
+        # Enumerate mappings from rule_2 → comp_rule
+        maps_2 = self.enumerate_all_unique_mappings(rc_2, comp_its)
+        for map_2 in maps_2:
+            # Subtract rule_2 from comp_rule with this mapping
+            new_graph = self.subtract_parent_from_child(rc_2, comp_its, map_2)
+            # Check if rule_1 is isomorphic to new_graph
+            is_iso, map_1 = self.graph_alignment(rc_1, new_graph)
+            if is_iso and map_1 is not None:
+                # If isomorphic, build a final mapping from rule_1 → new_graph
+                mappings = self.get_child1_to_child2_mapping(map_1, map_2)
+                return mappings
+        return None

synkit-0.0.6/synkit/Rule/seq_comp.py

@@ -0,0 +1,72 @@
+from typing import List, Dict, Optional
+from synkit.IO.chem_converter import smart_to_gml
+from synkit.Rule.compose_rule import ComposeRule
+from synkit.Rule.rule_mapping import RuleMapping
+
+
+class SeqComp:
+    """
+    A class for generating pairwise mappings between sequential chemical reaction rules.
+
+    This class takes a list of reaction SMARTS strings, converts them to their corresponding
+    GML representations, composes candidate reaction rules for each consecutive pair, and computes
+    a mapping between the rules using a rule mapping algorithm.
+    """
+
+    def __init__(self) -> None:
+        """
+        Initialize an instance of the SeqComp class.
+        """
+        pass
+
+    @staticmethod
+    def sequence_map(smarts: List[str]) -> Dict[str, Optional[dict]]:
+        """
+        Generate pairwise mapping dictionaries between consecutive reaction SMARTS strings.
+
+        This function processes a list of reaction SMARTS strings by:
+          1. Converting each SMARTS string to its GML representation.
+          2. For each consecutive pair, composing candidate rules using ComposeRule().get_rule_comp().
+          3. Using the first candidate (if available) and the original GMLs to compute a mapping
+             using RuleMapping().fit().
+          4. Storing the resulting mapping in a dictionary with keys in the format "i:i+1".
+
+        Parameters:
+        - smarts (List[str]): The list of reaction SMARTS strings.
+
+        Returns:
+        - Dict[str, Optional[dict]]:
+            A dictionary where each key is a string "i:i+1" representing the consecutive pair indices,
+            and the corresponding value is the mapping dictionary produced by RuleMapping().fit()
+            for that pair, or None if no valid mapping could be computed.
+        """
+        # Convert each SMARTS string to its GML representation.
+        gml_list = [smart_to_gml(s, sanitize=True) for s in smarts]
+        mappings: Dict[str, Optional[dict]] = {}
+
+        # Process each consecutive pair in the list.
+        for i in range(len(gml_list) - 1):
+            # Get the consecutive SMARTS and GML representations.
+            smart_a = smarts[i]
+            smart_b = smarts[i + 1]
+            rule_a = gml_list[i]
+            rule_b = gml_list[i + 1]
+
+            # Compose candidate rules between smart_a and smart_b.
+            candidate_rules = ComposeRule().get_rule_comp(smart_a, smart_b)
+
+            # If no candidate rule is found, assign None for this pair.
+            if not candidate_rules:
+                mappings[f"{i}:{i+1}"] = None
+                continue
+
+            # Try to compute the mapping using the first candidate rule.
+            try:
+                mapping_result = RuleMapping().fit(rule_a, rule_b, candidate_rules[0])
+            except Exception as e:
+                print(f"Error computing mapping for pair {i}:{i+1}: {e}")
+                mapping_result = None
+
+            mappings[f"{i}:{i+1}"] = mapping_result
+
+        return mappings

{synkit-0.0.5 → synkit-0.0.6}/synkit/Rule/strip_rule.py

@@ -31,7 +31,7 @@ def filter_context(context_lines, left_edges):
     return filtered_context
 
 
-def strip_context(gml_text: str, remove_all: bool = True) -> str:
+def strip_context(gml_text: str, remove_all: bool = False) -> str:
     """
     Filters or clears the 'context' section of GML-like content based on the remove_all flag.
     If remove_all is True, all edges in the 'context' section are removed.