synkit 0.0.1__py3-none-any.whl

synkit/ITS/normalize_aam.py

@@ -0,0 +1,183 @@
+import re
+import networkx as nx
+from rdkit import Chem
+from typing import List
+
+from synkit.IO.chem_converter import rsmi_to_graph
+from synkit.IO.graph_to_mol import GraphToMol
+from synkit.ITS.its_construction import ITSConstruction
+from synkit.ITS._misc import its_decompose, get_rc
+
+
+class NormalizeAAM:
+    """
+    Provides functionalities to normalize atom mappings in SMILES representations,
+    extract and process reaction centers from ITS graphs, and convert between
+    graph representations and molecular models.
+    """
+
+    def __init__(self) -> None:
+        """
+        Initializes the NormalizeAAM class.
+        """
+        pass
+
+    @staticmethod
+    def increment(match: re.Match) -> str:
+        """
+        Helper function to increment a matched atom mapping number by 1.
+
+        Parameters:
+        match (re.Match): A regex match object containing the atom mapping number.
+
+        Returns:
+        str: The incremented atom mapping number as a string.
+        """
+        return str(int(match.group()) + 1)
+
+    @staticmethod
+    def fix_atom_mapping(smiles: str) -> str:
+        """
+        Increments each atom mapping number in a SMILES string by 1.
+
+        Parameters:
+        smiles (str): The SMILES string with atom mapping numbers.
+
+        Returns:
+        str: The SMILES string with updated atom mapping numbers.
+        """
+        pattern = re.compile(r"(?<=:)\d+")
+        return pattern.sub(NormalizeAAM.increment, smiles)
+
+    @staticmethod
+    def fix_aam_rsmi(rsmi: str) -> str:
+        """
+        Adjusts atom mapping numbers in both reactant and product parts of a reaction SMILES (RSMI).
+
+        Parameters:
+        rsmi (str): The reaction SMILES string.
+
+        Returns:
+        str: The RSMI with updated atom mappings for both reactants and products.
+        """
+        r, p = rsmi.split(">>")
+        return f"{NormalizeAAM.fix_atom_mapping(r)}>>{NormalizeAAM.fix_atom_mapping(p)}"
+
+    @staticmethod
+    def fix_rsmi_kekulize(rsmi: str) -> str:
+        """
+        Filters the reactants and products of a reaction SMILES string.
+
+        Parameters:
+        - rsmi (str): A string representing the reaction SMILES in the form of "reactants >> products".
+
+        Returns:
+        - str: A filtered reaction SMILES string where invalid reactants/products are removed.
+        """
+        # Split the reaction into reactants and products
+        reactants, products = rsmi.split(">>")
+
+        # Filter valid reactants and products
+        filtered_reactants = NormalizeAAM.fix_kekulize(reactants)
+        filtered_products = NormalizeAAM.fix_kekulize(products)
+
+        # Return the filtered reaction SMILES
+        return f"{filtered_reactants}>>{filtered_products}"
+
+    @staticmethod
+    def fix_kekulize(smiles: str) -> str:
+        """
+        Filters and returns valid SMILES strings from a string of SMILES, joined by '.'.
+
+        This function processes a string of SMILES separated by periods (e.g., "CCO.CC=O"),
+        filters out invalid SMILES, and returns a string of valid SMILES joined by periods.
+
+        Parameters:
+        - smiles (str): A string containing SMILES strings separated by periods ('.').
+
+        Returns:
+        - str: A string of valid SMILES, joined by periods ('.').
+        """
+        smiles_list = smiles.split(".")  # Split SMILES by period
+        valid_smiles = []  # List to store valid SMILES strings
+
+        for smile in smiles_list:
+            mol = Chem.MolFromSmiles(smile, sanitize=False)
+            if mol:  # Check if molecule is valid
+                valid_smiles.append(
+                    Chem.MolToSmiles(
+                        mol, canonical=True, kekuleSmiles=True, allHsExplicit=True
+                    )
+                )
+        return ".".join(valid_smiles)  # Return valid SMILES joined by '.'
+
+    @staticmethod
+    def extract_subgraph(graph: nx.Graph, indices: List[int]) -> nx.Graph:
+        """
+        Extracts a subgraph from a given graph based on a list of node indices.
+
+        Parameters:
+        graph (nx.Graph): The original graph from which to extract the subgraph.
+        indices (List[int]): A list of node indices that define the subgraph.
+
+        Returns:
+        nx.Graph: The extracted subgraph.
+        """
+        return graph.subgraph(indices).copy()
+
+    def reset_indices_and_atom_map(
+        self, subgraph: nx.Graph, aam_key: str = "atom_map"
+    ) -> nx.Graph:
+        """
+        Resets the node indices and the atom_map of the subgraph to be continuous from 1 onwards.
+
+        Parameters:
+        subgraph (nx.Graph): The subgraph with possibly non-continuous indices.
+        aam_key (str): The attribute key for atom mapping. Defaults to 'atom_map'.
+
+        Returns:
+        nx.Graph: A new subgraph with continuous indices and adjusted atom_map.
+        """
+        new_graph = nx.Graph()
+        node_id_mapping = {
+            old_id: new_id for new_id, old_id in enumerate(subgraph.nodes(), 1)
+        }
+        for old_id, new_id in node_id_mapping.items():
+            node_data = subgraph.nodes[old_id].copy()
+            node_data[aam_key] = new_id
+            new_graph.add_node(new_id, **node_data)
+            for u, v, data in subgraph.edges(data=True):
+                new_graph.add_edge(node_id_mapping[u], node_id_mapping[v], **data)
+        return new_graph
+
+    def fit(self, rsmi: str, fix_aam_indice: bool = True) -> str:
+        """
+        Processes a reaction SMILES (RSMI) to adjust atom mappings, extract reaction centers,
+        decompose into separate reactant and product graphs, and generate the corresponding SMILES.
+
+        Parameters:
+        rsmi (str): The reaction SMILES string to be processed.
+        fix_aam_indice (bool): Whether to fix the atom mapping numbers. Defaults to True.
+
+        Returns:
+        str: The resulting reaction SMILES string with updated atom mappings.
+        """
+        rsmi = self.fix_rsmi_kekulize(rsmi)
+        if fix_aam_indice:
+            rsmi = self.fix_aam_rsmi(rsmi)
+        r_graph, p_graph = rsmi_to_graph(rsmi, light_weight=True, sanitize=False)
+        its = ITSConstruction().ITSGraph(r_graph, p_graph)
+        rc = get_rc(its)
+        keep_indice = [
+            indice
+            for indice, data in its.nodes(data=True)
+            if indice not in rc.nodes() and data["element"] != "H"
+        ]
+        keep_indice.extend(rc.nodes())
+        subgraph = self.extract_subgraph(its, keep_indice)
+        subgraph = self.reset_indices_and_atom_map(subgraph)
+        r_graph, p_graph = its_decompose(subgraph)
+        r_mol, p_mol = GraphToMol().graph_to_mol(
+            r_graph, sanitize=False
+        ), GraphToMol().graph_to_mol(p_graph, sanitize=False)
+        return f"{Chem.MolToSmiles(r_mol)}>>{Chem.MolToSmiles(p_mol)}"

synkit/ITS/partial_expand.py

@@ -0,0 +1,170 @@
+import networkx as nx
+from synutility.SynIO.Format.nx_to_gml import NXToGML
+from synutility.SynIO.Format.chemical_conversion import (
+    rsmi_to_graph,
+    graph_to_rsmi,
+    smiles_to_graph,
+)
+
+from synutility.SynAAM.misc import its_decompose, get_rc
+from synutility.SynAAM.its_construction import ITSConstruction
+from synutility.SynAAM.its_builder import ITSBuilder
+from synutility.SynChem.Reaction.standardize import Standardize
+from synutility.SynAAM.inference import aam_infer
+
+std = Standardize()
+
+
+class PartialExpand:
+    """
+    A class for partially expanding reaction SMILES (RSMI) by applying transformation
+    rules based on the reaction center (RC) graph.
+
+    This class provides methods for expanding a given RSMI by identifying the
+    reaction center (RC), applying transformation rules, and standardizing atom mappings
+    to generate a full AAM RSMI.
+
+    Methods:
+    - expand(rsmi: str) -> str:
+        Expands a reaction SMILES string by identifying the reaction center (RC),
+        applying transformation rules, and standardizing atom mappings.
+
+    - graph_expand(partial_its: nx.Graph, rsmi: str) -> str:
+        Expands a reaction SMILES string using an Imaginary Transition State
+        (ITS) graph and applies the transformation rule based on the reaction center (RC).
+    """
+
+    def __init__(self) -> None:
+        """
+        Initializes the PartialExpand class.
+
+        This constructor currently does not initialize any instance-specific attributes.
+        """
+        pass
+
+    @staticmethod
+    def graph_expand(partial_its: nx.Graph, rsmi: str) -> str:
+        """
+        Expands a reaction SMILES string by applying transformation rules using an
+        ITS graph based on the reaction center (RC) graph.
+
+        This method extracts the reaction center (RC) from the ITS graph, decomposes it
+        into reactant and product graphs, generates a GML rule for transformation,
+        and applies the rule to the RSMI string.
+
+        Parameters:
+        - partial_its (nx.Graph): The Intermediate Transition State (ITS) graph.
+        - rsmi (str): The input reaction SMILES string to be expanded.
+
+        Returns:
+        - str: The transformed reaction SMILES string after applying the
+        transformation rules.
+        """
+        # Extract the reaction center (RC) graph from the ITS graph
+        rc = get_rc(partial_its)
+
+        # Decompose the RC into reactant and product graphs
+        r_graph, p_graph = its_decompose(rc)
+
+        # Transform the graph into a GML rule
+        rule = NXToGML().transform((r_graph, p_graph, rc))
+
+        # Apply the transformation rule to the RSMI
+        transformed_rsmi = aam_infer(rsmi, rule)[0]
+
+        return transformed_rsmi
+
+    @staticmethod
+    def expand_aam_with_transform(rsmi: str) -> str:
+        """
+        Expands a reaction SMILES string by identifying the reaction center (RC),
+        applying transformation rules, and standardizing the atom mappings.
+
+        This method constructs the Intermediate Transition State (ITS) graph from the
+        input RSMI, applies the reaction transformation rules using `graph_expand`,
+        and returns the transformed reaction SMILES string.
+
+        Parameters:
+        - rsmi (str): The input reaction SMILES string to be expanded.
+
+        Returns:
+        - str: The transformed reaction SMILES string after applying the
+        transformation rules.
+
+        Raises:
+        - Exception: If an error occurs during the expansion process, the original RSMI
+        is returned.
+        """
+        try:
+            # Convert RSMI to reactant and product graphs
+            r_graph, p_graph = rsmi_to_graph(rsmi, light_weight=True, sanitize=False)
+
+            # Construct the ITS graph from the reactant and product graphs
+            its = ITSConstruction().ITSGraph(r_graph, p_graph)
+
+            # Standardize smiles
+            rsmi = std.fit(rsmi)
+            # Apply graph expansion and return the result
+            return PartialExpand.graph_expand(its, rsmi)
+
+        except Exception as e:
+            # Log the error and return the original RSMI if something goes wrong
+            print(f"An error occurred during RSMI expansion: {e}")
+            return None
+
+    @staticmethod
+    def expand_aam_with_its(rsmi: str, use_G: bool = True, light_weight=True) -> str:
+        """
+        Expands a partial reaction SMILES string to a full reaction SMILES by reconstructing
+        intermediate transition states (ITS) and decomposing them back into reactants and products.
+
+        Parameters:
+        - rsmi (str): The reaction SMILES string that potentially contains a partial mapping of atoms.
+        - use_G (bool, optional): A flag to determine which part of the reaction SMILES to expand.
+        If True, uses the reactants' part for expansion; if False, uses the products' part.
+
+        Returns:
+        - str: The expanded reaction SMILES string with a complete mapping of all atoms involved
+        in the reaction.
+
+        Note:
+        - This function assumes that the input reaction SMILES is formatted correctly and split
+        into reactants and products separated by '>>'.
+        - The function relies on graph transformation methods to construct the ITS graph, decompose it,
+        and finally convert the resulting graph back into a SMILES string.
+        """
+        # Split the reaction SMILES based on the use_G flag
+        smi = rsmi.split(">>")[0] if use_G else rsmi.split(">>")[1]
+
+        # 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
+        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,
+        )
+
+        # Rebuild the ITS graph from the generated graph and the reconstructed ITS
+        its = ITSBuilder().ITSGraph(G, rc)
+
+        # Decompose the ITS graph back into modified reactants and products
+        r, p = its_decompose(its)
+
+        # Convert the modified reactants and products back into a reaction SMILES string
+        return graph_to_rsmi(r, p, its, True, False, True)
+
+
+if __name__ == "__main__":
+    rsmi = "[CH3][CH:1]=[CH2:2].[H:3][H:4]>>[CH3][CH:1]([H:3])[CH2:2][H:4]"
+    rsmi = "CC[CH2:3][Cl:1].[NH2:2][H:4]>>CC[CH2:3][NH2:2].[Cl:1][H:4]"
+    print(PartialExpand.expand(rsmi))
+# self.rsmi = "BrCc1ccc(Br)cc1.COCCO>>Br.COCCOCc1ccc(Br)cc1"
+#         self.gml = smart_to_gml("[Br:1][CH3:2].[OH:3][H:4]>>[Br:1][H:4].[CH3:2][OH:3]")

synkit/Reactor/core_engine.py

@@ -0,0 +1,164 @@
+from rdkit import Chem
+from pathlib import Path
+from typing import List, Union
+from collections import Counter
+from synkit.IO.data_io import load_gml_as_text
+
+import torch
+from mod import *
+
+
+class CoreEngine:
+    """
+    The MØDModeling class encapsulates functionalities for reaction modeling using the MØD
+    toolkit. It provides methods for forward and backward prediction based on templates
+    library.
+    """
+
+    @staticmethod
+    def generate_reaction_smiles(
+        temp_results: List[str], base_smiles: str, is_forward: bool = True
+    ) -> List[str]:
+        """
+        Constructs reaction SMILES strings from intermediate results using a base SMILES
+        string, indicating whether the process is a forward or backward reaction. This
+        function iterates over a list of intermediate SMILES strings, combines them with
+        the base SMILES, and formats them into complete reaction SMILES strings.
+
+        Parameters:
+        - temp_results (List[str]): Intermediate SMILES strings resulting from partial
+        reactions or combinations.
+        - base_smiles (str): The SMILES string representing the starting point of the
+        reaction, either as reactants or products, depending on the reaction direction.
+        - is_forward (bool, optional): Flag to determine the direction of the reaction;
+        'True' for forward reactions where 'base_smiles' are reactants, and 'False' for
+        backward reactions where 'base_smiles' are products. Defaults to True.
+
+        Returns:
+        - List[str]: A list of complete reaction SMILES strings, formatted according to
+        the specified reaction direction.
+        """
+        results = []
+        for comb in temp_results:
+            joined_smiles = ".".join(comb)
+            reaction_smiles = (
+                f"{base_smiles}>>{joined_smiles}"
+                if is_forward
+                else f"{joined_smiles}>>{base_smiles}"
+            )
+            results.append(reaction_smiles)
+        return results
+
+    @staticmethod
+    def perform_reaction(
+        rule_file_path: Union[str, str],
+        initial_smiles: List[str],
+        prediction_type: str = "forward",
+        print_results: bool = False,
+        verbosity: int = 0,
+    ) -> List[str]:
+        """
+        Applies a specified reaction rule, loaded from a GML file, to a set of initial
+        molecules represented by SMILES strings. The reaction can be simulated in forward
+        or backward direction and repeated multiple times.
+
+        Parameters:
+        - rule_file_path (str): Path to the GML file containing the reaction rule.
+        - initial_smiles (List[str]): Initial molecules represented as SMILES strings.
+        - type (str, optional): Direction of the reaction ('forward' for forward,
+        'backward' for backward). Defaults to 'forward'.
+        - print_results (bool): Print results in latex or not. Defaults to False.
+
+        Returns:
+        - List[str]: SMILES strings of the resulting molecules or reactions.
+        """
+
+        # Determine the rule inversion based on reaction type
+        invert_rule = prediction_type == "backward"
+        # Convert SMILES strings to molecule objects, avoiding duplicate conversions
+        initial_molecules = [smiles(smile, add=False) for smile in (initial_smiles)]
+
+        def deduplicateGraphs(initial):
+            res = []
+            for cand in initial:
+                for a in res:
+                    if cand.isomorphism(a) != 0:
+                        res.append(a)  # the one we had already
+                        break
+                else:
+                    # didn't find any isomorphic, use the new one
+                    res.append(cand)
+            return res
+
+        initial_molecules = deduplicateGraphs(initial_molecules)
+
+        initial_molecules = sorted(
+            initial_molecules, key=lambda molecule: molecule.numVertices, reverse=False
+        )
+        # Load the reaction rule from the GML file
+        rule_path = Path(rule_file_path)
+
+        try:
+            if rule_path.is_file():
+                gml_content = load_gml_as_text(rule_file_path)
+            else:
+                gml_content = rule_file_path
+        except Exception as e:
+            # print(f"An error occurred while loading the GML file: {e}")
+            gml_content = rule_file_path
+        reaction_rule = ruleGMLString(gml_content, invert=invert_rule, add=False)
+        # Initialize the derivation graph and execute the strategy
+        dg = DG(graphDatabase=initial_molecules)
+        config.dg.doRuleIsomorphismDuringBinding = False
+        dg.build().apply(initial_molecules, reaction_rule, verbosity=verbosity)
+        if print_results:
+            dg.print()
+
+        temp_results = []
+        for e in dg.edges:
+            productSmiles = [v.graph.smiles for v in e.targets]
+            temp_results.append(productSmiles)
+            # print(productSmiles)
+
+        if len(temp_results) == 0:
+            # print(1)
+            dg = DG(graphDatabase=initial_molecules)
+            # dg.build().execute(strategy, verbosity=8)
+            config.dg.doRuleIsomorphismDuringBinding = False
+            dg.build().apply(
+                initial_molecules, reaction_rule, verbosity=verbosity, onlyProper=False
+            )
+            temp_results, small_educt = [], []
+            for edge in dg.edges:
+                temp_results.append([vertex.graph.smiles for vertex in edge.targets])
+                small_educt.append([vertex.graph.smiles for vertex in edge.sources])
+
+            for key, solution in enumerate(temp_results):
+                educt = small_educt[key]
+                small_educt_counts = Counter(
+                    Chem.CanonSmiles(smile) for smile in educt if smile is not None
+                )
+                reagent_counts = Counter([Chem.CanonSmiles(s) for s in initial_smiles])
+                reagent_counts.subtract(small_educt_counts)
+                reagent = [
+                    smile
+                    for smile, count in reagent_counts.items()
+                    for _ in range(count)
+                    if count > 0
+                ]
+                solution.extend(reagent)
+
+        reaction_processing_map = {
+            "forward": lambda smiles: CoreEngine.generate_reaction_smiles(
+                temp_results, ".".join(initial_smiles), is_forward=True
+            ),
+            "backward": lambda smiles: CoreEngine.generate_reaction_smiles(
+                temp_results, ".".join(initial_smiles), is_forward=False
+            ),
+        }
+
+        # Use the reaction type to select the appropriate processing function and apply it
+        if prediction_type in reaction_processing_map:
+            return reaction_processing_map[prediction_type](initial_smiles)
+        else:
+            return ""

synkit/Reactor/inference.py

@@ -0,0 +1,73 @@
+import torch
+from typing import List, Any
+from synkit.IO.dg_to_gml import DGToGML
+from synkit.ITS.normalize_aam import NormalizeAAM
+from synkit.Chem.Reaction.standardize import Standardize
+from synkit.Reactor.rule_apply import rule_apply
+
+std = Standardize()
+
+
+def aam_infer(rsmi: str, gml: Any) -> List[str]:
+    """
+    Infers a set of normalized SMILES from a reaction SMILES string and a graph model (GML).
+
+    This function takes a reaction SMILES string (rsmi) and a graph model (gml), applies the
+    reaction transformation using the graph model, normalizes and standardizes the resulting
+    SMILES, and returns a list of SMILES that match the original reaction's structure after
+    normalization and standardization.
+
+    Steps:
+    1. The reactants in the reaction SMILES string are separated.
+    2. The transformation is applied to the reactants using the provided graph model (gml).
+    3. The resulting SMILES are transformed to a canonical form.
+    4. The resulting SMILES are normalized and standardized.
+    5. The function returns the normalized SMILES that match the original reaction SMILES.
+
+    Parameters:
+    - rsmi (str): The reaction SMILES string in the form "reactants >> products".
+    - gml (Any): A graph model or data structure used for applying the reaction transformation.
+
+    Returns:
+    - List[str]: A list of valid, normalized, and standardized SMILES strings that match the original reaction SMILES.
+    """
+    # Split the input reaction SMILES into reactants and products
+    smiles = rsmi.split(">>")[0].split(".")
+
+    # Apply the reaction transformation based on the graph model (GML)
+    dg = rule_apply(smiles, gml)
+
+    # Get the transformed reaction SMILES from the graph
+    transformed_rsmi = list(DGToGML.getReactionSmiles(dg).values())
+    transformed_rsmi = [value[0] for value in transformed_rsmi]
+
+    # Normalize the transformed SMILES
+    normalized_rsmi = []
+    for value in transformed_rsmi:
+        try:
+            value = NormalizeAAM().fit(value)
+            normalized_rsmi.append(value)
+        except Exception as e:
+            print(e)
+            continue
+
+    # Standardize the normalized SMILES
+    curated_smiles = []
+    for value in normalized_rsmi:
+        try:
+            curated_smiles.append(std.fit(value))
+        except Exception as e:
+            print(e)
+            curated_smiles.append(None)
+            continue
+
+    # Standardize the original SMILES for comparison
+    org_smiles = std.fit(rsmi)
+
+    # Filter out the SMILES that match the original reaction SMILES
+    final = []
+    for key, value in enumerate(curated_smiles):
+        if value == org_smiles:
+            final.append(normalized_rsmi[key])
+
+    return final