synkit 0.0.1__py3-none-any.whl

synkit/IO/parse_rule.py

@@ -0,0 +1,172 @@
+import re
+
+# Regex patterns for nodes and edges
+NODE_REGEX = re.compile(r'node \[ id (\d+) label "(\w+)" \]')
+EDGE_REGEX = re.compile(r'edge \[ source (\d+) target (\d+) label "(.+?)" \]')
+
+
+def find_block(lines, keyword):
+    """
+    Finds the start and end indices of a block (e.g., "left [", "context [", etc.)
+    in the given lines of GML. Returns (start_idx, end_idx) or (None, None) if not found.
+    """
+    start_idx = None
+    depth = 0
+    for i, line in enumerate(lines):
+        stripped = line.strip()
+        if start_idx is None and stripped.startswith(keyword):
+            start_idx = i
+            depth = 1
+        elif start_idx is not None:
+            # Check brackets to maintain correct depth
+            if stripped.endswith("["):
+                depth += 1
+            elif stripped == "]":
+                depth -= 1
+                if depth == 0:
+                    return start_idx, i
+    return None, None
+
+
+def get_nodes_from_edges(block_lines):
+    """
+    Extract node IDs from edges in the given block lines.
+    Returns a set of node IDs found in the edges.
+    """
+    node_set = set()
+    for line in block_lines:
+        m = EDGE_REGEX.search(line.strip())
+        if m:
+            source, target, _ = m.groups()
+            node_set.update([source, target])
+    return node_set
+
+
+def parse_context(context_lines, node_regex=None, edge_regex=None):
+    """
+    Parse the context lines to identify nodes and edges.
+    Returns two structures:
+    - context_nodes: {node_id: label}
+    - context_edges: list of (source, target, label)
+    """
+
+    context_nodes = {}
+    context_edges = []
+    for line in context_lines:
+        stripped = line.strip()
+        nm = NODE_REGEX.search(stripped)
+        if nm:
+            nid, lbl = nm.groups()
+            context_nodes[nid] = lbl
+        else:
+            em = EDGE_REGEX.search(stripped)
+            if em:
+                source, target, label = em.groups()
+                context_edges.append((source, target, label))
+    return context_nodes, context_edges
+
+
+def filter_context(context_lines, relevant_nodes):
+    """
+    Given the context lines and a set of relevant nodes, remove hydrogen nodes
+    not in relevant_nodes and all edges connected to them. Returns filtered lines.
+    """
+    context_nodes, context_edges = parse_context(context_lines)
+
+    # Identify hydrogen nodes to remove
+    hydrogen_nodes_to_remove = {
+        nid
+        for nid, lbl in context_nodes.items()
+        if lbl == "H" and nid not in relevant_nodes
+    }
+
+    filtered_context = []
+    for line in context_lines:
+        stripped = line.strip()
+        nm = NODE_REGEX.search(stripped)
+        em = EDGE_REGEX.search(stripped)
+
+        if nm:
+            nid, lbl = nm.groups()
+            if nid not in hydrogen_nodes_to_remove:
+                filtered_context.append(line)
+        elif em:
+            source, target, label = em.groups()
+            if (
+                source not in hydrogen_nodes_to_remove
+                and target not in hydrogen_nodes_to_remove
+            ):
+                filtered_context.append(line)
+        else:
+            # Keep section lines like "context [" or "]"
+            filtered_context.append(line)
+
+    return filtered_context
+
+
+def strip_context(gml_text: str, remove_all: bool = True) -> 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.
+    If False, it removes hydrogen nodes that do not appear in both 'left' and 'right' sections,
+    along with their edges, while preserving the original structure and formatting of the GML.
+
+    Parameters:
+    - gml_text (str): GML-like content describing a chemical reaction rule.
+    - remove_all (bool): Flag to determine if all edges should be removed from the 'context'.
+
+    Returns:
+    - str: The modified GML content with the filtered 'context' section.
+    """
+    lines = gml_text.split("\n")
+
+    # Locate main sections: rule, left, context, right
+    rule_start, rule_end = find_block(lines, "rule [")
+    left_start, left_end = find_block(lines, "left [")
+    context_start, context_end = find_block(lines, "context [")
+    right_start, right_end = find_block(lines, "right [")
+
+    # If we cannot find proper structure, return original text
+    if any(
+        x is None
+        for x in [
+            rule_start,
+            rule_end,
+            left_start,
+            left_end,
+            context_start,
+            context_end,
+            right_start,
+            right_end,
+        ]
+    ):
+        return gml_text
+
+    # fmt: off
+    context_lines = lines[context_start: context_end + 1]
+
+    # Determine relevant nodes by intersection of nodes in left and right edges
+    left_nodes = get_nodes_from_edges(lines[left_start: left_end + 1])
+    right_nodes = get_nodes_from_edges(lines[right_start: right_end + 1])
+    # fmt: on
+    relevant_nodes = left_nodes.intersection(right_nodes)
+
+    # Filter the context section based on relevant nodes
+    filtered_context = filter_context(context_lines, relevant_nodes)
+
+    if remove_all:
+        # Remove all edges from the context
+        # Retain only node lines and other structural lines
+        final_context = []
+        for line in filtered_context:
+            if not EDGE_REGEX.search(line.strip()):
+                final_context.append(line)
+        filtered_context = final_context
+
+    # Rebuild the full GML text
+    # Replace the original context lines with the filtered or cleared context lines
+    # fmt: off
+    new_lines = lines[:context_start] + filtered_context + lines[context_end + 1:]
+    # fmt: on
+
+    return "\n".join(new_lines)

synkit/IO/smiles_to_id.py

@@ -0,0 +1,119 @@
+import time
+import requests
+import urllib.parse
+from typing import List
+from joblib import Parallel, delayed
+
+
+def smiles_to_iupac(smiles_string: str, timeout: int = 1):
+    """
+    Converts a SMILES string to its corresponding IUPAC name(s) using the PubChem PUG REST API.
+
+    Parameters:
+    - smiles_string (str): The SMILES string of the compound (e.g., "C=O" for formaldehyde).
+    - timeout (int, optional): The timeout in seconds for the request. Default is 1 second.
+
+    Returns:
+    - list: A list of IUPAC names associated with the SMILES string. Returns an empty list if none found.
+    """
+    # URL encode the SMILES string to handle special characters
+    encoded_smiles = urllib.parse.quote(smiles_string)
+
+    # PubChem PUG REST API endpoint to retrieve properties
+    url = f"https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/smiles/{encoded_smiles}/property/IUPACName/JSON"
+
+    retries = 3  # Number of retries in case of failure
+    delay = 2  # Delay between retries (in seconds)
+
+    for attempt in range(retries):
+        try:
+            response = requests.get(url, timeout=timeout)  # Adjust timeout for speed
+            response.raise_for_status()  # Raise an HTTPError for bad responses
+
+            data = response.json()
+
+            # Extract the IUPAC name(s) from the response
+            properties = data.get("PropertyTable", {}).get("Properties", [])
+
+            if not properties:
+                print(f"No properties found for SMILES: {smiles_string}")
+                return []
+
+            iupac_names = [
+                prop.get("IUPACName") for prop in properties if prop.get("IUPACName")
+            ]
+
+            if iupac_names:
+                return iupac_names
+            else:
+                print(f"No IUPAC name found for SMILES: {smiles_string}")
+                return []
+
+        except (requests.exceptions.RequestException, ValueError, KeyError) as e:
+            # If an error occurs, retry a few times
+            print(
+                f"Attempt {attempt + 1} failed for SMILES: {smiles_string}, Error: {e}"
+            )
+            if attempt < retries - 1:
+                time.sleep(delay)  # Wait before retrying
+            else:
+                print(f"Final failure for SMILES: {smiles_string}")
+                return []
+
+    return []
+
+
+def batch_process_smiles(smiles_batch: List[str], timeout=1):
+    """
+    Processes a batch of SMILES strings to get IUPAC names.
+
+    Parameters:
+    - smiles_batch (list): A list of SMILES strings to process.
+    - timeout (int): Timeout for requests (in seconds).
+
+    Returns:
+    - list: A list of IUPAC name results for each SMILES in the batch.
+    """
+    return [smiles_to_iupac(smiles, timeout) for smiles in smiles_batch]
+
+
+def get_iupac_for_smiles_list(
+    smiles_list: List[str], batch_size=10, n_jobs=4, timeout=1
+):
+    """
+    Convert a list of SMILES strings to their corresponding IUPAC names using the PubChem API with batch processing.
+
+    Parameters:
+    smiles_list (list): A list of SMILES strings to be converted to IUPAC names.
+    batch_size (int): Number of SMILES strings to process in each batch.
+    n_jobs (int): Number of parallel jobs to run for batch processing.
+    timeout (int): Timeout for requests (in seconds).
+
+    Returns:
+    dict: A dictionary with SMILES as keys and lists of IUPAC names as values.
+    """
+    # Split the list into smaller batches
+    # fmt: off
+    batches = [
+        smiles_list[i: i + batch_size] for i in range(0, len(smiles_list), batch_size)
+    ]
+    # fmt: on
+
+    # Use joblib's Parallel and delayed to process batches in parallel
+    batch_results = Parallel(n_jobs=n_jobs)(
+        delayed(batch_process_smiles)(batch, timeout) for batch in batches
+    )
+
+    # Flatten the list of results and map to SMILES
+    flattened_results = [item for sublist in batch_results for item in sublist]
+    iupac_dict = dict(zip(smiles_list, flattened_results))
+
+    return iupac_dict
+
+
+# Example of usage
+smiles_list = ["CCO", "C=O", "CC(=O)O", "C1=CC=CC=C1", "C2H6O", "C4H10", "C5H12"]
+iupac_results = get_iupac_for_smiles_list(smiles_list, batch_size=3, n_jobs=2)
+
+for smiles, iupac_names in iupac_results.items():
+    print(f"SMILES: {smiles} => IUPAC Names: {iupac_names}")

synkit/ITS/_misc.py

@@ -0,0 +1,280 @@
+import re
+import networkx as nx
+from rdkit import Chem
+from rdkit.Chem.MolStandardize import rdMolStandardize
+
+from typing import Optional, List
+
+
+def get_rc(
+    ITS: nx.Graph,
+    element_key: list = ["element", "charge", "typesGH", "atom_map"],
+    bond_key: str = "order",
+    standard_key: str = "standard_order",
+) -> nx.Graph:
+    """
+    Extracts the reaction center (RC) graph from a given ITS graph by identifying edges
+    where the bond order changes, indicating a reaction event.
+
+    Parameters:
+    - ITS (nx.Graph): The ITS graph to extract the RC from.
+    - element_key (list): List of node attribute keys for atom properties.
+    Defaults to ['element', 'charge', 'typesGH'].
+    - bond_key (str): Edge attribute key for bond order. Defaults to 'order'.
+    - standard_key (str): Edge attribute key for standard order information.
+    Defaults to 'standard_order'.
+
+    Returns:
+    - nx.Graph: A new graph representing the reaction center of the ITS.
+    """
+    rc = nx.Graph()
+    for n1, n2, data in ITS.edges(data=True):
+        if data.get(bond_key, [None, None])[0] != data.get(bond_key, [None, None])[1]:
+            rc.add_node(
+                n1, **{k: ITS.nodes[n1][k] for k in element_key if k in ITS.nodes[n1]}
+            )
+            rc.add_node(
+                n2, **{k: ITS.nodes[n2][k] for k in element_key if k in ITS.nodes[n2]}
+            )
+            rc.add_edge(
+                n1, n2, **{bond_key: data[bond_key], standard_key: data[standard_key]}
+            )
+    return rc
+
+
+def its_decompose(its_graph: nx.Graph, nodes_share="typesGH", edges_share="order"):
+    """
+    Decompose an ITS graph into two separate graphs G and H based on shared
+    node and edge attributes.
+
+    Parameters:
+    - its_graph (nx.Graph): The integrated transition state (ITS) graph.
+    - nodes_share (str): Node attribute key that stores tuples with node attributes
+    or G and H.
+    - edges_share (str): Edge attribute key that stores tuples with edge attributes
+    for G and H.
+
+    Returns:
+    - Tuple[nx.Graph, nx.Graph]: A tuple containing the two graphs G and H.
+    """
+    G = nx.Graph()
+    H = nx.Graph()
+
+    # Decompose nodes
+    for node, data in its_graph.nodes(data=True):
+        if nodes_share in data:
+            node_attr_g, node_attr_h = data[nodes_share]
+            # Unpack node attributes for G
+            G.add_node(
+                node,
+                element=node_attr_g[0],
+                aromatic=node_attr_g[1],
+                hcount=node_attr_g[2],
+                charge=node_attr_g[3],
+                neighbors=node_attr_g[4],
+                atom_map=node,
+            )
+            # Unpack node attributes for H
+            H.add_node(
+                node,
+                element=node_attr_h[0],
+                aromatic=node_attr_h[1],
+                hcount=node_attr_h[2],
+                charge=node_attr_h[3],
+                neighbors=node_attr_h[4],
+                atom_map=node,
+            )
+
+    # Decompose edges
+    for u, v, data in its_graph.edges(data=True):
+        if edges_share in data:
+            order_g, order_h = data[edges_share]
+            if order_g > 0:  # Assuming 0 means no edge in G
+                G.add_edge(u, v, order=order_g)
+            if order_h > 0:  # Assuming 0 means no edge in H
+                H.add_edge(u, v, order=order_h)
+
+    return G, H
+
+
+def compare_graphs(
+    graph1: nx.Graph,
+    graph2: nx.Graph,
+    node_attrs: list = ["element", "aromatic", "hcount", "charge", "neighbors"],
+    edge_attrs: list = ["order"],
+) -> bool:
+    """
+    Compare two graphs based on specified node and edge attributes.
+
+    Parameters:
+    - graph1 (nx.Graph): The first graph to compare.
+    - graph2 (nx.Graph): The second graph to compare.
+    - node_attrs (list): A list of node attribute names to include in the comparison.
+    - edge_attrs (list): A list of edge attribute names to include in the comparison.
+
+    Returns:
+    - bool: True if both graphs are identical with respect to the specified attributes,
+    otherwise False.
+    """
+    # Compare node sets
+    if set(graph1.nodes()) != set(graph2.nodes()):
+        return False
+
+    # Compare nodes based on attributes
+    for node in graph1.nodes():
+        if node not in graph2:
+            return False
+        node_data1 = {attr: graph1.nodes[node].get(attr, None) for attr in node_attrs}
+        node_data2 = {attr: graph2.nodes[node].get(attr, None) for attr in node_attrs}
+        if node_data1 != node_data2:
+            return False
+
+    # Compare edge sets with sorted tuples
+    if set(tuple(sorted(edge)) for edge in graph1.edges()) != set(
+        tuple(sorted(edge)) for edge in graph2.edges()
+    ):
+        return False
+
+    # Compare edges based on attributes
+    for edge in graph1.edges():
+        # Sort the edge for consistent comparison
+        sorted_edge = tuple(sorted(edge))
+        if sorted_edge not in graph2.edges():
+            return False
+        edge_data1 = {attr: graph1.edges[edge].get(attr, None) for attr in edge_attrs}
+        edge_data2 = {
+            attr: graph2.edges[sorted_edge].get(attr, None) for attr in edge_attrs
+        }
+        if edge_data1 != edge_data2:
+            return False
+
+    return True
+
+
+def enumerate_tautomers(reaction_smiles: str) -> Optional[List[str]]:
+    """
+    Enumerates possible tautomers for reactants while canonicalizing the products in a
+    reaction SMILES string. This function first splits the reaction SMILES string into
+    reactants and products. It then generates all possible tautomers for the reactants and
+    canonicalizes the product molecule. The function returns a list of reaction SMILES
+    strings for each tautomer of the reactants combined with the canonical product.
+
+    Parameters:
+    - reaction_smiles (str): A SMILES string of the reaction formatted as
+    'reactants>>products'.
+
+    Returns:
+    - List[str] | None: A list of SMILES strings for the reaction, with each string
+    representing a different
+    - tautomer of the reactants combined with the canonicalized products. Returns None if
+    an error occurs or if invalid SMILES strings are provided.
+
+    Raises:
+    - ValueError: If the provided SMILES strings cannot be converted to molecule objects,
+    indicating invalid input.
+    """
+    try:
+        # Split the input reaction SMILES string into reactants and products
+        reactants_smiles, products_smiles = reaction_smiles.split(">>")
+
+        # Convert SMILES strings to molecule objects
+        reactants_mol = Chem.MolFromSmiles(reactants_smiles)
+        products_mol = Chem.MolFromSmiles(products_smiles)
+
+        if reactants_mol is None or products_mol is None:
+            raise ValueError(
+                "Invalid SMILES string provided for reactants or products."
+            )
+
+        # Initialize tautomer enumerator
+
+        enumerator = rdMolStandardize.TautomerEnumerator()
+
+        # Enumerate tautomers for the reactants and canonicalize the products
+        try:
+            reactants_can = enumerator.Enumerate(reactants_mol)
+        except Exception as e:
+            print(f"An error occurred: {e}")
+            reactants_can = [reactants_mol]
+        products_can = products_mol
+
+        # Convert molecule objects back to SMILES strings
+        reactants_can_smiles = [Chem.MolToSmiles(i) for i in reactants_can]
+        products_can_smiles = Chem.MolToSmiles(products_can)
+
+        # Combine each reactant tautomer with the canonical product in SMILES format
+        rsmi_list = [i + ">>" + products_can_smiles for i in reactants_can_smiles]
+        if len(rsmi_list) == 0:
+            return [reaction_smiles]
+        else:
+            # rsmi_list.remove(reaction_smiles)
+            rsmi_list.insert(0, reaction_smiles)
+            return rsmi_list
+
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        return [reaction_smiles]
+
+
+def mapping_success_rate(list_mapping_data):
+    """
+    Calculate the success rate of entries containing atom mappings in a list of data
+    strings.
+
+    Parameters:
+    - list_mapping_in_data (list of str): List containing strings to be searched for atom
+    mappings.
+
+    Returns:
+    - float: The success rate of finding atom mappings in the list as a percentage.
+
+    Raises:
+    - ValueError: If the input list is empty.
+    """
+    atom_map_pattern = re.compile(r":\d+")
+    if not list_mapping_data:
+        raise ValueError("The input list is empty, cannot calculate success rate.")
+
+    success = sum(
+        1 for entry in list_mapping_data if re.search(atom_map_pattern, entry)
+    )
+    rate = 100 * (success / len(list_mapping_data))
+
+    return round(rate, 2)
+
+
+def expand_hydrogens(graph: nx.Graph) -> nx.Graph:
+    """
+    For each node in the graph that has an 'hcount' attribute greater than zero,
+    adds the specified number of hydrogen nodes and connects them with edges that
+    have specific attributes.
+
+    Parameters
+    - graph (nx.Graph): A graph representing a molecule with nodes that can
+    include 'element', 'hcount', 'charge', and 'atom_map' attributes.
+
+    Returns:
+    - nx.Graph: A new graph with hydrogen atoms expanded.
+    """
+    new_graph = graph.copy()  # Create a copy to modify and return
+    atom_map = (
+        max(data["atom_map"] for _, data in graph.nodes(data=True))
+        if graph.nodes
+        else 0
+    )
+
+    # Iterate through each node to process potential hydrogens
+    for node, data in graph.nodes(data=True):
+        hcount = data.get("hcount", 0)
+        if hcount > 0:
+            for _ in range(hcount):
+                atom_map += 1
+                hydrogen_node = {
+                    "element": "H",
+                    "charge": 0,
+                    "atom_map": atom_map,
+                }
+                new_graph.add_node(atom_map, **hydrogen_node)
+                new_graph.add_edge(node, atom_map, order=(1.0, 1.0), standard_order=0.0)
+
+    return new_graph