synkit 0.0.1__py3-none-any.whl

synkit/Chem/Reaction/cleanning.py

@@ -0,0 +1,59 @@
+from typing import List
+from synkit.Chem.Reaction.standardize import Standardize
+from synkit.Chem.Reaction.balance_check import BalanceReactionCheck
+
+
+class Cleanning:
+    def __init__(self) -> None:
+        pass
+
+    @staticmethod
+    def remove_duplicates(smiles_list: List[str]) -> List[str]:
+        """
+        Removes duplicate SMILES strings from a list, maintaining the order of
+        first occurrences. Uses a set to track seen SMILES for efficiency.
+
+        Parameters:
+        - smiles_list (List[str]): A list of SMILES strings representing
+        chemical reactions.
+
+        Returns:
+        - List[str]: A list with unique SMILES strings, preserving the original order.
+        """
+        seen = set()
+        unique_smiles = [
+            smiles for smiles in smiles_list if not (smiles in seen or seen.add(smiles))
+        ]
+        return unique_smiles
+
+    @staticmethod
+    def clean_smiles(smiles_list: List[str]) -> List[str]:
+        """
+        Cleans a list of SMILES strings by standardizing them, checking their chemical
+        balance, and removing duplicates. Each SMILES is first checked for validity and
+        then standardized. Only balanced reactions are kept.
+
+        Parameters:
+        - smiles_list (List[str]): A list of SMILES strings representing chemical reactions.
+
+        Returns:
+        - List[str]: A list of cleaned and standardized SMILES strings.
+        """
+        # Standardize and check balance in separate list comprehensions
+        standardizer = Standardize()
+        balance_checker = BalanceReactionCheck()
+
+        standardized_smiles = [
+            standardizer.standardize_rsmi(smiles, True)
+            for smiles in smiles_list
+            if smiles
+        ]
+        balanced_smiles = [
+            smiles
+            for smiles in standardized_smiles
+            if balance_checker.rsmi_balance_check(smiles)
+        ]
+
+        # Remove duplicates from the balanced SMILES list
+        clean_smiles = Cleanning.remove_duplicates(balanced_smiles)
+        return clean_smiles

synkit/Chem/Reaction/deionize.py

@@ -0,0 +1,289 @@
+import random
+from itertools import permutations
+from itertools import combinations
+from joblib import Parallel, delayed
+from typing import List, Tuple, Callable, Dict
+
+from rdkit import Chem
+from rdkit.Chem.MolStandardize import rdMolStandardize
+
+from synkit.Chem.Reaction.balance_check import BalanceReactionCheck
+
+
+class Deionize:
+    """
+    A class to deionize reactions.
+    """
+
+    @staticmethod
+    def random_pair_ions(
+        charges: List[int], smiles: List[str]
+    ) -> Tuple[List[List[str]], List[List[int]]]:
+        """
+        Generates non-overlapping groups of ions (2, 3, or 4) based on
+        their charges and corresponding SMILES representations,
+        aiming to maximize the total number of ions used by preferring
+        multiple smaller groups over fewer larger groups.
+
+        Parameters:
+        - charges (List[int]): A list of integer charges of the ions.
+        - smiles (List[str]): A list of SMILES strings representing the ions.
+
+        Returns:
+        - Tuple[List[List[str]], List[List[int]]]: A tuple containing two lists:
+            - The first list contains the groups of SMILES strings.
+            - The second list contains the groups of charges.
+        """
+
+        def find_groups(indices, size):
+            """Finds and removes groups of a specific size that sum to zero charge."""
+            for group in combinations(indices, size):
+                if sum(charges[i] for i in group) == 0:
+                    return group
+            return []
+
+        # Prepare initial variables
+        indices = list(range(len(charges)))
+        random.shuffle(indices)  # Shuffle indices to ensure variety
+        used_indices = set()
+        grouped_smiles = []
+        grouped_charges = []
+
+        for group_size in range(
+            2, 5
+        ):  # Start with pairs, then triples, and finally quads
+            while True:
+                group = find_groups(
+                    [i for i in indices if i not in used_indices], group_size
+                )
+                if not group:
+                    break  # No more groups of this size can be formed
+                grouped_smiles.append([smiles[i] for i in group])
+                grouped_charges.append([charges[i] for i in group])
+                used_indices.update(group)
+
+        return grouped_smiles, grouped_charges
+
+    @staticmethod
+    def uncharge_anion(smiles: str, charges: int = -1) -> str:
+        """
+        Removes charge from an anionic species represented by a SMILES string.
+
+        This function uses RDKit's standardization tools to neutralize
+        the charges in the molecule. It returns
+        the SMILES representation of the uncharged molecule.
+
+        Parameters::
+        - smiles (str): A SMILES string representing the anionic species.
+
+        Returns:
+        - str: The SMILES string of the uncharged molecule.
+
+        Note:
+        - The function assumes valid SMILES input.
+        """
+        if smiles == "[N-]=[N+]=[N-]":
+            return "[N-]=[N+]=[N]"
+        if charges == -1:
+            # Convert the SMILES string to an RDKit molecule object
+            mol = Chem.MolFromSmiles(smiles)
+
+            # Initialize the uncharger
+            uncharger = rdMolStandardize.Uncharger()
+
+            # Apply the uncharger to the molecule
+            uncharged_mol = uncharger.uncharge(mol)
+
+            # Convert the uncharged molecule back to a SMILES string
+            return Chem.MolToSmiles(uncharged_mol)
+
+        elif charges < -1:
+            new_smiles = (
+                smiles.replace(f"{charges}", "").replace("[", "").replace("]", "")
+            )
+            return new_smiles
+
+    @staticmethod
+    def uncharge_cation(smiles: str, charges: int = 1) -> str:
+        """
+        Removes charge from a cationic species represented by a SMILES string.
+
+        This function uses RDKit's standardization tools to neutralize
+        the charges in the molecule. It returns the
+        SMILES representation of the uncharged molecule.
+
+        Parameters::
+        - smiles (str): A SMILES string representing the cationic species.
+
+        Returns:
+        - str: The SMILES string of the uncharged molecule.
+
+        Note:
+        - The function assumes valid SMILES input.
+        """
+
+        if charges == 1:
+            new_smiles = smiles.replace("+", "")
+        elif charges > 1:
+            # For multiple positive charges, directly modify the SMILES string
+            new_smiles = smiles.replace(f"+{charges}", "")
+        return new_smiles
+
+    @staticmethod
+    def uncharge_smiles(charge_smiles: str) -> str:
+        """
+        Processes a SMILES string containing ionic and non-ionic parts,
+        neutralizes the charges, and returns a modified SMILES string.
+
+        The function splits the input SMILES string into individual components,
+        identifies ionic and non-ionic parts,
+        and attempts to neutralize charged ions.
+        It then creates permutations of the modified ions and combines them into
+        a single SMILES string, ensuring the molecular structure is valid.
+
+        Parameters::
+        - charge_smiles (str): A SMILES string that may contain ionic and non-ionic parts.
+
+        Returns:
+        - str: A modified SMILES string with neutralized charges.
+
+        Note:
+        - This function depends on RDKit for molecular operations.
+        - The function assumes a valid SMILES input.
+        - The 'uncharge_anion' and 'random_pair_ions' functions
+                    must be defined and accessible.
+        """
+
+        smiles = charge_smiles.split(".")
+        charges = [Chem.rdmolops.GetFormalCharge(Chem.MolFromSmiles(i)) for i in smiles]
+
+        if all(charge == 0 for charge in charges):
+            return charge_smiles
+
+        valid_smiles, non_ionic_smiles = [], []
+        original_ionic_parts, original_ion_charges = [], []
+
+        # Splitting the SMILES into ionic and non-ionic parts
+        for smile, charge in zip(smiles, charges):
+            if charge == 0:
+                non_ionic_smiles.append(smile)
+            else:
+                original_ionic_parts.append(smile)
+                original_ion_charges.append(charge)
+
+        valid_smiles.extend(non_ionic_smiles)
+        paired_smiles, paired_charges = Deionize.random_pair_ions(
+            original_ion_charges, original_ionic_parts
+        )
+        # Processing each pair of ionic parts
+        for i_smile, i_charge in zip(paired_smiles, paired_charges):
+            modified_ions = []
+            for ion, charge in zip(i_smile, i_charge):
+                if int(charge) > 0:
+                    new_ion = Deionize.uncharge_cation(ion, charge)
+                    modified_ions.append(new_ion)
+                elif int(charge) < 0:
+                    new_ion = Deionize.uncharge_anion(ion, charge)
+                    modified_ions.append(new_ion)
+            # Creating permutations of the modified ions
+            check_merge = False
+            for perm in permutations(modified_ions):
+                combined_ionic = "".join(perm)
+                if Chem.MolFromSmiles(combined_ionic):
+                    coordinate_pattern = ["->", "<-"]
+                    if all(
+                        pattern not in Chem.CanonSmiles(combined_ionic)
+                        for pattern in coordinate_pattern
+                    ):
+                        valid_smiles.append(Chem.CanonSmiles(combined_ionic))
+                        check_merge = True
+                        break
+            if check_merge is False:
+                valid_smiles.extend(i_smile)
+        return ".".join(valid_smiles)
+
+    @staticmethod
+    def ammonia_hydroxide_standardize(reaction_smiles: str) -> str:
+        """
+        Replaces occurrences of ammonium hydroxide (NH4+ and OH-) in a
+        reaction SMILES string with a simplified representation (N.O or O.N).
+
+        Parameters::
+            reaction_smiles (str): The reaction SMILES string to be standardized.
+
+        Returns:
+            str: The standardized reaction SMILES string with
+                ammonium hydroxide represented as 'N.O' or 'O.N'.
+        """
+        # Simplify the representation of ammonium hydroxide in the reaction SMILES
+        new_smiles = reaction_smiles.replace("[NH4+].[OH-]", "N.O").replace(
+            "[OH-].[NH4+]", "O.N"
+        )
+        return new_smiles
+
+    @classmethod
+    def apply_uncharge_smiles_to_reactions(
+        cls,
+        reactions: List[Dict[str, str]],
+        uncharge_smiles_func: Callable[[str], str],
+        n_jobs: int = 4,
+    ) -> List[Dict[str, str]]:
+        """
+        Applies a given uncharge SMILES function to the reactants
+        and products of a list of chemical reactions,
+        parallelizing the process for improved performance.
+        Each reaction is expected to be a dictionary
+        with at least 'reactants' and 'products' keys.
+        The function adds three new keys to each reaction
+        dictionary: 'uncharged_reactants', 'uncharged_products',
+        and 'uncharged_reactions', containing
+        the uncharged SMILES strings of reactants, products,
+        and the overall reaction, respectively.
+
+        Parameters::
+        - reactions (List[Dict[str, str]]): A list of dictionaries, where each dictionary
+        represents a chemical reaction with 'reactants' and 'products' keys.
+        - uncharge_smiles_func (Callable[[str], str]): A function that takes a SMILES
+        string as input and returns a modified SMILES string with neutralized charges.
+
+        Returns:
+        - List[Dict[str, str]]: The input list of reaction dictionaries, modified in-place
+        to include 'uncharged_reactants', 'uncharged_products', and 'uncharged_reactions'
+        keys.
+        """
+
+        # Define a helper function for processing a single reaction
+        def process_reaction(reaction):
+            fix_reactants = cls.ammonia_hydroxide_standardize(reaction["reactants"])
+            fix_products = cls.ammonia_hydroxide_standardize(reaction["products"])
+
+            uncharged_reactants = uncharge_smiles_func(fix_reactants)
+            uncharged_products = uncharge_smiles_func(fix_products)
+            uncharged_reactants_formula = (
+                BalanceReactionCheck().get_combined_molecular_formula(
+                    uncharged_reactants
+                )
+            )
+            uncharged_products_formula = (
+                BalanceReactionCheck().get_combined_molecular_formula(
+                    uncharged_products
+                )
+            )
+            if uncharged_reactants_formula != uncharged_products_formula:
+                reaction["success"] = False
+                reaction["new_reactants"] = fix_reactants
+                reaction["new_products"] = fix_products
+            else:
+                reaction["success"] = True
+                reaction["new_reactants"] = uncharged_reactants
+                reaction["new_products"] = uncharged_products
+            reaction["standardized_reactions"] = (
+                f"{reaction['new_reactants']}>>{reaction['new_products']}"
+            )
+            return reaction
+
+        # Use joblib to parallelize the processing of reactions
+        reactions = Parallel(n_jobs=n_jobs)(
+            delayed(process_reaction)(reaction) for reaction in reactions
+        )
+        return reactions

synkit/Chem/Reaction/neutralize.py

@@ -0,0 +1,256 @@
+from rdkit import Chem
+from joblib import Parallel, delayed
+from typing import Dict, Any, List, Union, Tuple
+
+
+class Neutralize:
+    """
+    A class for neutralizing unbalanced charges in a reaction.
+    """
+
+    @staticmethod
+    def calculate_charge(smiles: str) -> int:
+        """
+        Calculates the formal charge of a given molecule represented by a SMILES string.
+
+        Parameters:
+        - smiles (str): A SMILES string representing a molecule.
+
+        Returns:
+        - int: The formal charge of the molecule.
+        """
+        mol = Chem.MolFromSmiles(smiles)
+        if mol is None:
+            return 0
+        return Chem.rdmolops.GetFormalCharge(mol)
+
+    @staticmethod
+    def parse_reaction(reaction_smiles: str) -> Tuple[str, str]:
+        """
+        Parses a reaction SMILES string into reactants and products.
+
+        Parameters:
+        - reaction_smiles (str): A reaction SMILES string of the form
+                            "reactants>>products".
+
+        Returns:
+        - Tuple[str, str]: A tuple containing the reactants and
+                            products SMILES strings, respectively.
+
+        This function uses a while loop and exception handling to
+        manage parsing errors and ensure the input is correctly formatted.
+        """
+        try:
+            reactants, products = reaction_smiles.split(">>")
+            return reactants, products
+        except ValueError:
+            return None, None
+
+    @staticmethod
+    def calculate_charge_dict(
+        reaction: Dict[str, str], reaction_column: str
+    ) -> Dict[str, Union[str, int]]:
+        """
+        Calculates and adds the total charge of products in a single reaction.
+
+        Parameters:
+        - reaction (Dict[str, str]): A dictionary representing a reaction with keys
+          'R-id' and 'new_reaction'.
+
+        Returns:
+        - Dict[str, Union[str, int]]: The same reaction dictionary, with an added key
+          'total_charge_in_products' indicating the sum of formal charges in its products.
+        """
+        reactants, products = Neutralize.parse_reaction(reaction[reaction_column])
+        if reactants is None or products is None:
+            reaction.update(
+                {"reactants": None, "products": None, "total_charge_in_products": None}
+            )
+        else:
+            reaction["reactants"] = reactants
+            reaction["products"] = products
+            products = products.split(".")
+            total_charge = sum(
+                Neutralize.calculate_charge(product) for product in products
+            )
+            reaction["total_charge_in_products"] = total_charge
+        return reaction
+
+    @staticmethod
+    def fix_negative_charge(
+        reaction_dict: Dict[str, any],
+        charges_column: str = "total_charge_in_products",
+        id_column: str = "R-id",
+        reaction_column: str = "reactions",
+    ) -> Dict[str, any]:
+        """
+        Adjusts a reaction dictionary to compensate for a negative charge
+        in the products by adding [Na+] ions.
+
+        This function calculates the number of sodium ions ([Na+]) needed to neutralize
+        negative charges in the reaction products. It then adds the appropriate number of
+        sodium ions to both the reactants and products.
+
+        Parameters::
+        - reaction_dict (Dict[str, any]): A dictionary representing a chemical reaction.
+        Must include keys for 'total_charge_in_products', 'reactants', 'products', 'R-id',
+        and 'label'.
+
+        Returns:
+        - Dict[str, any]: A new reaction dictionary with adjusted reactants and products
+        to neutralize the negative charge. The 'total_charge_in_products' is set to 0,
+        assuming the charge has been neutralized.
+        """
+
+        num_na_to_add = abs(reaction_dict[charges_column])
+        sodium_ion = "[Na+]"
+
+        # Generate the string to add, with the correct number of sodium ions
+        sodium_addition = (
+            "." + ".".join([sodium_ion] * num_na_to_add) if num_na_to_add > 0 else ""
+        )
+
+        # Add the sodium ions to reactants and products
+        new_reactants = reaction_dict["reactants"] + sodium_addition
+        new_products = reaction_dict["products"] + sodium_addition
+
+        # Generate the new reaction string
+        new_reactions = new_reactants + ">>" + new_products
+
+        # Create the new reaction dictionary
+        new_reaction_dict = {
+            id_column: reaction_dict["R-id"],
+            reaction_column: new_reactions,
+            "reactants": new_reactants,
+            "products": new_products,
+            charges_column: 0,  # Assuming the charge is neutralized
+        }
+
+        return new_reaction_dict
+
+    @staticmethod
+    def fix_positive_charge(
+        reaction_dict: Dict[str, any],
+        charges_column: str = "total_charge_in_products",
+        id_column: str = "R-id",
+        reaction_column: str = "reactions",
+    ) -> Dict[str, any]:
+        """
+        Adjusts a reaction dictionary to compensate for a positive charge
+        in the products by adding [Cl-] ions. The function
+        takes into account the total positive charge indicated
+        in the reaction dictionary and adds an equivalent number of
+        chloride ions ([Cl-]) to both reactants and products to neutralize the charge.
+
+        Parameters::
+        - reaction_dict (Dict[str, any]): A dictionary representing a chemical reaction.
+        This dictionary must include keys for reactants, products, and a specified charge
+        column (default is 'total_charge_in_products') which contains the total charge of
+        the products.
+        - charges_column (str, optional): The key in `reaction_dict` that contains the
+        total charge of the products. Defaults to 'total_charge_in_products'.
+
+        Returns:
+        - Dict[str, any]: A modified reaction dictionary with added [Cl-] ions to
+        neutralize the positive charge. The 'total_charge_in_products' is updated to 0,
+        indicating that the reaction's charge has been neutralized. The dictionary
+        includes updated 'reactants', 'products', and a new reaction string.
+        """
+
+        num_cl_to_add = abs(reaction_dict[charges_column])
+        chloride_ion = "[Cl-]"
+
+        # Generate the string to add, with the correct number of chloride ions
+        chloride_addition = (
+            "." + ".".join([chloride_ion] * num_cl_to_add) if num_cl_to_add > 0 else ""
+        )
+
+        # Add the chloride ions to reactants and products
+        new_reactants = reaction_dict["reactants"] + chloride_addition
+        new_products = reaction_dict["products"] + chloride_addition
+
+        # Generate the new reaction string
+        new_reactions = new_reactants + ">>" + new_products
+
+        # Create and return the new reaction dictionary with the neutralized charge
+        new_reaction_dict = {
+            "R-id": reaction_dict[id_column],
+            reaction_column: new_reactions,
+            "reactants": new_reactants,
+            "products": new_products,
+            charges_column: 0,
+        }
+
+        return new_reaction_dict
+
+    @staticmethod
+    def fix_unbalanced_charged(
+        reaction_dict: Dict[str, any],
+        reaction_column: str,
+    ) -> Dict[str, any]:
+        """
+        Adjusts a reaction dictionary to compensate for an unbalanced charge in the
+        products by adding either [Cl-] ions for a positive charge or [Na+] ions for a
+        negative charge. The function determines the direction of the charge imbalance
+        using the specified charges column and applies the appropriate correction.
+
+        Parameters::
+        - reaction_dict (Dict[str, any]): A dictionary representing a chemical reaction.
+        This dictionary must include keys for reactants, products, and a specified charge
+        column which contains the total charge of the products.
+        - charges_column (str, optional): The key in `reaction_dict` that contains the
+        total charge of the products. Defaults to 'total_charge_in_products'.
+
+        Returns:
+        - Dict[str, any]: A modified reaction dictionary with added ions to neutralize the
+        charge imbalance. The returned dictionary will have its charge neutralized and
+        include updated 'reactants', 'products', and a new reaction string. The specific
+        ions added ([Cl-] for positive charges or [Na+] for negative charges) depend on
+        the initial charge imbalance.
+        """
+        reaction_dict = Neutralize.calculate_charge_dict(reaction_dict, reaction_column)
+        if reaction_dict["total_charge_in_products"] > 0:
+            return Neutralize.fix_positive_charge(
+                reaction_dict, "total_charge_in_products"
+            )
+        elif reaction_dict["total_charge_in_products"] < 0:
+            return Neutralize.fix_negative_charge(
+                reaction_dict, "total_charge_in_products"
+            )
+        else:
+            return reaction_dict
+
+    @classmethod
+    def parallel_fix_unbalanced_charge(
+        cls,
+        reaction_dicts: List[Dict[str, Any]],
+        reaction_column: str,
+        n_jobs: int = 4,
+    ) -> List[Dict[str, Any]]:
+        """
+        Processes a list of reaction dictionaries in parallel to compensate
+        for unbalanced charges in the products, adding either [Cl-] ions
+        for positive charges or [Na+] ions for negative charges.
+
+        Parameters::
+        - reaction_dicts (List[Dict[str, Any]]): A list of dictionaries, each representing
+        a chemical reaction that may have an unbalanced charge.
+        - charges_column (str): The key in each reaction dictionary that contains the
+        total charge of the products. Defaults to 'total_charge_in_products'.
+        - n_jobs (int): The number of CPU cores to use for parallel processing.
+        -1 means using all available cores.
+
+        Returns:
+        - List[Dict[str, Any]]: A list of modified reaction dictionaries
+        with charges neutralized, reflecting the addition of necessary ions.
+
+        Note:
+        - This function requires the joblib library for parallel execution.
+        Ensure joblib is installed and available for import.
+        """
+        # Use joblib.Parallel and joblib.delayed to parallelize the charge fixing
+        fixed_reactions = Parallel(n_jobs=n_jobs)(
+            delayed(cls.fix_unbalanced_charged)(reaction_dict, reaction_column)
+            for reaction_dict in reaction_dicts
+        )
+        return fixed_reactions