synkit 0.0.1__py3-none-any.whl

synkit/Chem/Reaction/reagent.py

@@ -0,0 +1,102 @@
+from rxnmapper import RXNMapper
+from typing import Tuple, Optional
+from synkit.IO.debug import setup_logging
+
+logger = setup_logging()
+rxn_mapper = RXNMapper()
+
+
+class Reagent:
+    def __init__(self) -> None:
+        pass
+
+    @staticmethod
+    def map_with_rxn_mapper(
+        reaction_smiles: str, rxn_mapper: RXNMapper = rxn_mapper
+    ) -> str:
+        """
+        Maps a reaction SMILES string using the RXNMapper.
+
+        Parameters:
+        - reaction_smiles (str): The SMILES string of the reaction to be mapped.
+        - rxn_mapper (RXNMapper): The RXNMapper instance used for mapping.
+
+        Returns:
+        - str: The atom-mapped reaction SMILES string, or the original reaction if mapping fails.
+        """
+        try:
+            # Perform the atom mapping using RXNMapper
+            mapped_rxn = rxn_mapper.get_attention_guided_atom_maps(
+                [reaction_smiles], canonicalize_rxns=False
+            )[0]["mapped_rxn"]
+            # Ensure we only take the mapped reaction if any extra information exists
+            return mapped_rxn.split(" ")[0] if " " in mapped_rxn else mapped_rxn
+        except Exception as e:
+            logger.error(
+                f"RXNMapper mapping failed for reaction '{reaction_smiles}': {e}"
+            )
+            return reaction_smiles
+
+    @staticmethod
+    def clean_reagents(
+        reaction_smiles: str, return_clean_reaction: bool = True
+    ) -> Tuple[Optional[str], Optional[str]]:
+        """
+        Identifies and removes reagents from a reaction based on atom mappings.
+
+        Parameters:
+        - reaction_smiles (str): The reaction in SMILES format.
+        - return_clean_reaction (bool): If True, returns the cleaned reaction and the detected reagents.
+          If False, only returns the detected reagents.
+
+        Returns:
+        - Tuple[Optional[str], Optional[str]]: A tuple containing the cleaned reaction (if requested) and the reagents.
+          If an error occurs, both elements of the tuple will be `None`.
+        """
+        try:
+            # Generate atom-atom mappings for the reaction
+            mapped_rsmi = Reagent.map_with_rxn_mapper(reaction_smiles)
+
+            # Split the original and mapped reactions into reactants and products
+            precursor, product = reaction_smiles.split(">>")
+            precursor1, product1 = mapped_rsmi.split(">>")
+
+            # Step 1: Identify unmapped reactants (reagents)
+            reactant_elements = precursor.split(".")
+            mapped_reactant_elements = precursor1.split(".")
+            clean_reactants = [
+                r for r in reactant_elements if r not in mapped_reactant_elements
+            ]
+            reagents_react = [
+                r for r in reactant_elements if r in mapped_reactant_elements
+            ]
+
+            # Step 2: Identify unmapped products (reagents)
+            product_elements = product.split(".")
+            mapped_product_elements = product1.split(".")
+            clean_products = [
+                p for p in product_elements if p not in mapped_product_elements
+            ]
+            reagents_prod = [
+                p for p in product_elements if p in mapped_product_elements
+            ]
+
+            # Combine the reagents detected from both reactants and products
+            reagents = reagents_react + reagents_prod
+            reagents_str = ".".join(reagents) if reagents else None
+
+            # Cleaned reaction without reagents
+            clean_reaction = (
+                (".".join(clean_reactants) + ">>" + ".".join(clean_products))
+                if clean_reactants or clean_products
+                else None
+            )
+
+            if return_clean_reaction:
+                return clean_reaction, reagents_str
+            else:
+                return None, reagents_str
+
+        except Exception as e:
+            logger.error(f"Error processing reaction: {e}")
+            return None, None

synkit/Chem/Reaction/standardize.py

@@ -0,0 +1,157 @@
+from rdkit import Chem
+from typing import List, Optional, Tuple
+
+
+class Standardize:
+    def __init__(self) -> None:
+        pass
+
+    @staticmethod
+    def remove_atom_mapping(reaction_smiles: str, symbol: str = ">>") -> str:
+        """
+        Removes atom mappings from both reactants and products in a reaction SMILES.
+
+        Parameters:
+        - reaction_smiles (str): A reaction SMILES string with atom mappings.
+        - symbol (str): The symbol that separates reactants and products.
+        Default is '>>'.
+
+        Returns:
+        - str: The reaction SMILES with atom mappings removed.
+        """
+        # Split the reaction SMILES into reactants and products
+        parts = reaction_smiles.split(symbol)
+        if len(parts) != 2:
+            raise ValueError(
+                "Invalid reaction SMILES format."
+                + " Expected format: 'reactants>>products'."
+            )
+
+        def clean_smiles(smiles: str) -> str:
+            mol = Chem.MolFromSmiles(smiles)  # Convert SMILES to an RDKit mol object
+            if mol is None:
+                raise ValueError(f"Invalid SMILES string: {smiles}")
+            for atom in mol.GetAtoms():
+                atom.SetAtomMapNum(0)  # Remove atom mapping
+            return Chem.MolToSmiles(mol, True)  # Convert mol back to SMILES
+
+        # Apply the cleaning function to both reactants and products
+        reactants_clean = clean_smiles(parts[0])
+        products_clean = clean_smiles(parts[1])
+
+        # Combine the cleaned reactants and products back into a reaction SMILES
+        return f"{reactants_clean}{symbol}{products_clean}"
+
+    @staticmethod
+    def filter_valid_molecules(smiles_list: List[str]) -> List[Chem.Mol]:
+        """
+        Filters and returns valid RDKit molecule objects from a list of SMILES strings.
+
+        Parameters:
+        - smiles_list (List[str]): A list of SMILES strings.
+
+        Returns:
+        - List[Chem.Mol]: A list of valid RDKit molecule objects.
+        """
+        valid_molecules = []
+        for smiles in smiles_list:
+            mol = Chem.MolFromSmiles(smiles)
+            if mol:
+                valid_molecules.append(mol)
+        return valid_molecules
+
+    @staticmethod
+    def standardize_rsmi(rsmi: str, stereo: bool = False) -> Optional[str]:
+        """
+        Standardizes a reaction SMILES (rSMI) by:
+        - Ensuring all reactants and products are valid molecules.
+        - Sorting the SMILES strings of reactants and products in ascending order.
+        - Optionally considering stereochemistry.
+
+        Parameters:
+        - rsmi (str): The reaction SMILES string to be standardized.
+        - stereo (bool): If True, stereochemical information is included in the SMILES.
+
+        Returns:
+        - Optional[str]: The standardized reaction SMILES,
+        or None if no valid molecules are found.
+        """
+        try:
+            reactants, products = rsmi.split(">>")
+        except ValueError:
+            raise ValueError(
+                "Invalid reaction SMILES format."
+                + " Expected format: 'reactants>>products'."
+            )
+
+        reactant_molecules = Standardize.filter_valid_molecules(reactants.split("."))
+        product_molecules = Standardize.filter_valid_molecules(products.split("."))
+
+        if not reactant_molecules or not product_molecules:
+            return None
+
+        standardized_reactants = ".".join(
+            sorted(
+                Chem.MolToSmiles(mol, isomericSmiles=stereo)
+                for mol in reactant_molecules
+            )
+        )
+        standardized_products = ".".join(
+            sorted(
+                Chem.MolToSmiles(mol, isomericSmiles=stereo)
+                for mol in product_molecules
+            )
+        )
+
+        return f"{standardized_reactants}>>{standardized_products}"
+
+    def fit(
+        self, rsmi: str, remove_aam: bool = True, ignore_stereo: bool = True
+    ) -> Optional[str]:
+        """
+        Fits the reaction SMILES by removing atom mappings and standardizing the reaction.
+
+        Parameters:
+        - rsmi (str): The reaction SMILES string to be processed.
+        - remove_aam (bool): If True, atom mappings are removed from the reaction SMILES.
+        - ignore_stereo (bool): If True, stereochemistry is ignored in the SMILES.
+
+        Returns:
+        - Optional[str]: The processed reaction SMILES, or None if the
+        standardization fails.
+        """
+        if remove_aam:
+            rsmi = self.remove_atom_mapping(rsmi)
+
+        rsmi = self.standardize_rsmi(rsmi, not ignore_stereo)
+        rsmi = rsmi.replace("[HH]", "[H][H]")
+        return rsmi
+
+    @staticmethod
+    def categorize_reactions(
+        reactions: List[str], target_reaction: str
+    ) -> Tuple[List[str], List[str]]:
+        """
+        Sorts a list of reaction SMILES strings into two groups based on
+        their match with a specified target reaction. The categorization process
+        distinguishes between reactions that align with the target reaction
+        and those that do not.
+
+        Parameters:
+        - reactions (List[str]): The array of reaction SMILES strings to be categorized.
+        - target_reaction (str): The SMILES string of the target reaction
+                                    used as the benchmark for categorization.
+
+        Returns:
+        - Tuple[List[str], List[str]]: A pair of lists, where the first contains
+                                    reactions matching the target and the second
+                                    comprises non-matching reactions.
+        """
+        match, not_match = [], []
+        target_reaction = Standardize.standardize_rsmi(target_reaction, stereo=False)
+        for reaction_smiles in reactions:
+            if reaction_smiles == target_reaction:
+                match.append(reaction_smiles)
+            else:
+                not_match.append(reaction_smiles)
+        return match, not_match

synkit/Chem/Reaction/tautomerize.py

@@ -0,0 +1,168 @@
+from typing import List, Dict, Optional
+from rdkit import Chem
+from fgutils import FGQuery
+from joblib import Parallel, delayed
+
+
+class Tautomerize:
+    """
+    A class to standardize molecules by converting specific functional groups to their
+    more common forms using RDKit for molecule manipulation.
+    """
+
+    @staticmethod
+    def standardize_enol(smiles: str, atom_indices: Optional[List[int]] = None) -> str:
+        """
+        Converts an enol form to a carbonyl form based on specified atom indices.
+
+        Parameters:
+        - smiles (str): The SMILES string.
+        - atom_indices (List[int], optional): List containing indices of two carbons and
+        one oxygen involved in the enol formation. Defaults to [0, 1, 2].
+
+        Returns:
+        - str: The SMILES string of the molecule after conversion.
+                Returns an error message if indices are invalid.
+        """
+        if atom_indices is None:
+            atom_indices = [0, 1, 2]
+
+        mol = Chem.MolFromSmiles(smiles)
+        if mol is None:
+            return "Invalid SMILES format."
+        emol = Chem.EditableMol(mol)
+
+        try:
+            c1_idx, c2_idx = (
+                i for i in atom_indices if mol.GetAtomWithIdx(i).GetSymbol() == "C"
+            )
+            o_idx = next(
+                i for i in atom_indices if mol.GetAtomWithIdx(i).GetSymbol() == "O"
+            )
+        except Exception as e:
+            return f"Error processing indices: {str(e)}"
+
+        try:
+            emol.RemoveBond(c1_idx, c2_idx)
+            emol.RemoveBond(c2_idx, o_idx)
+            emol.AddBond(c1_idx, c2_idx, order=Chem.rdchem.BondType.SINGLE)
+            emol.AddBond(c2_idx, o_idx, order=Chem.rdchem.BondType.DOUBLE)
+            new_mol = emol.GetMol()
+            Chem.SanitizeMol(new_mol)
+            return Chem.MolToSmiles(new_mol)
+        except Exception as e:
+            return f"Error in modifying molecule: {str(e)}"
+
+    @staticmethod
+    def standardize_hemiketal(smiles: str, atom_indices: List[int]) -> str:
+        """
+        Converts a hemiketal form to a carbonyl form based on specified atom indices.
+
+        Parameters:
+        - smiles (str): SMILES representation of the original molecule.
+        - atom_indices (List[int]): Indices of the carbon and two oxygen atoms
+        involved in the transformation.
+
+        Returns:
+        - str: SMILES string of the modified molecule if successful,
+                otherwise returns an error message.
+        """
+        mol = Chem.MolFromSmiles(smiles)
+        if mol is None:
+            return "Invalid SMILES format."
+        emol = Chem.EditableMol(mol)
+
+        try:
+            c_idx = next(
+                i for i in atom_indices if mol.GetAtomWithIdx(i).GetSymbol() == "C"
+            )
+            o1_idx, o2_idx = (
+                i for i in atom_indices if mol.GetAtomWithIdx(i).GetSymbol() == "O"
+            )
+            emol.RemoveBond(c_idx, o1_idx)
+            emol.RemoveBond(c_idx, o2_idx)
+            emol.AddBond(c_idx, o1_idx, order=Chem.rdchem.BondType.DOUBLE)
+            new_mol = emol.GetMol()
+            Chem.SanitizeMol(new_mol)
+            return Chem.MolToSmiles(new_mol)
+        except Exception as e:
+            return f"Error in modifying molecule: {str(e)}"
+
+    @staticmethod
+    def fix_smiles(smiles: str) -> str:
+        """
+        Performs the standardization process by identifying and converting all relevant
+        functional groups to their target forms based on predefined rules and updates the
+        SMILES string accordingly.
+
+        Parameters:
+        - smiles (str): SMILES string of the original molecule.
+
+        Returns:
+        - str: Canonical SMILES string of the standardized molecule.
+        """
+        query = FGQuery()
+        fg = query.get(smiles)
+        for item in fg:
+            if "hemiketal" in item:
+                atom_indices = item[1]
+                smiles = Tautomerize.standardize_hemiketal(smiles, atom_indices)
+                fg = query.get(smiles)
+            elif "enol" in item:
+                atom_indices = item[1]
+                smiles = Tautomerize.standardize_enol(smiles, atom_indices)
+                fg = query.get(smiles)
+        return Chem.CanonSmiles(smiles)
+
+    @staticmethod
+    def fix_dict(data: Dict[str, str], reaction_column: str) -> Dict[str, str]:
+        """
+        Updates a dictionary containing reaction data by
+        standardizing the SMILES strings of reactants and products.
+
+        Parameters:
+        - data (Dict[str, str]): Dictionary containing the reaction data.
+        - reaction_column (str): The key in the dictionary where the reaction SMILES
+        string is stored.
+
+        Returns:
+        - Dict[str, str]: The updated dictionary with standardized SMILES strings.
+        """
+        try:
+            reactants, products = data[reaction_column].split(">>")
+            reactants = Tautomerize.fix_smiles(reactants)
+            products = Tautomerize.fix_smiles(products)
+            data[reaction_column] = f"{reactants}>>{products}"
+        except ValueError:
+            smiles = data[reaction_column]
+            smiles = Tautomerize.fix_smiles(smiles)
+            data[reaction_column] = smiles
+        return data
+
+    @staticmethod
+    def fix_dicts(
+        data: List[Dict[str, str]],
+        reaction_column: str,
+        n_jobs: int = 4,
+        verbose: int = 0,
+    ) -> List[Dict[str, str]]:
+        """
+        Standardizes multiple dictionaries containing
+        reaction data in parallel.
+
+        Parameters:
+        - data (List[Dict[str, str]]): List of dictionaries, each containing reaction
+        data.
+        - reaction_column (str): The key where the reaction SMILES strings are
+        stored in each dictionary.
+        - n_jobs (int, optional): Number of jobs to run in parallel. Defaults to 4.
+        - verbose (int, optional): The verbosity level. Defaults to 0.
+
+        Returns:
+        - List[Dict[str, str]]: A list of updated dictionaries
+                            with standardized SMILES strings.
+        """
+        results = Parallel(n_jobs=n_jobs, verbose=verbose)(
+            delayed(Tautomerize.fix_dict)(d, reaction_column) for d in data
+        )
+        return results

synkit/Graph/Cluster/morphism.py

@@ -0,0 +1,83 @@
+import torch
+from operator import eq
+import networkx as nx
+from typing import Callable, Optional
+from networkx.algorithms.isomorphism import generic_node_match, generic_edge_match
+
+
+def graph_isomorphism(
+    graph_1: nx.Graph,
+    graph_2: nx.Graph,
+    node_match: Optional[Callable] = None,
+    edge_match: Optional[Callable] = None,
+    use_defaults: bool = False,
+) -> bool:
+    """
+    Determines if two graphs are isomorphic, considering provided node and edge matching
+    functions. Uses default matching settings if none are provided.
+
+    Parameters:
+    - graph_1 (nx.Graph): The first graph to compare.
+    - graph_2 (nx.Graph): The second graph to compare.
+    - node_match (Optional[Callable]): The function used to match nodes.
+    Uses default if None.
+    - edge_match (Optional[Callable]): The function used to match edges.
+    Uses default if None.
+
+    Returns:
+    - bool: True if the graphs are isomorphic, False otherwise.
+    """
+    # Define default node and edge attributes and match settings
+    if use_defaults:
+        node_label_names = ["element", "charge"]
+        node_label_default = ["*", 0]
+        edge_attribute = "order"
+
+        # Default node and edge match functions if not provided
+        if node_match is None:
+            node_match = generic_node_match(
+                node_label_names, node_label_default, [eq] * len(node_label_names)
+            )
+        if edge_match is None:
+            edge_match = generic_edge_match(edge_attribute, 1, eq)
+
+    # Perform the isomorphism check using NetworkX
+    return nx.is_isomorphic(
+        graph_1, graph_2, node_match=node_match, edge_match=edge_match
+    )
+
+
+def rule_isomorphism(
+    rule_1: str, rule_2: str, morphism_type: str = "isomorphic"
+) -> bool:
+    """
+    Evaluates if two GML-formatted rule representations are isomorphic or one is a
+    subgraph of the other.
+
+    Converts GML strings to `ruleGMLString` objects and uses these to check for:
+    - 'isomorphic': Complete structural correspondence between both rules.
+    - 'monomorphic': One rule being a subgraph of the other.
+
+    Parameters:
+    - rule_1 (str): GML string of the first rule.
+    - rule_2 (str): GML string of the second rule.
+    - morphism_type (str, optional): Type of morphism to check
+    ('isomorphic' or 'monomorphic').
+
+    Returns:
+    - bool: True if the specified morphism condition is met, False otherwise.
+
+    Raises:
+    - Exception: Issues during GML parsing or morphism checking.
+    """
+    from mod import ruleGMLString
+
+    # Create ruleGMLString objects from the GML strings
+    rule_obj_1 = ruleGMLString(rule_1)
+    rule_obj_2 = ruleGMLString(rule_2)
+
+    # Check the relationship based on morphism_type and return the result
+    if morphism_type == "isomorphic":
+        return rule_obj_1.isomorphism(rule_obj_2) == 1
+    else:
+        return rule_obj_1.monomorphism(rule_obj_2) == 1