synkit 0.0.1__py3-none-any.whl

synkit/Chem/Fingerprint/fp_calculator.py

@@ -0,0 +1,122 @@
+import pandas as pd
+import numpy as np
+from drfp import DrfpEncoder
+from joblib import Parallel, delayed
+from typing import Optional
+from synkit.IO.debug import setup_logging
+from synkit.Chem.Fingerprint.transformation_fp import TransformationFP
+
+
+class FPCalculator:
+    """
+    Class to calculate fingerprint vectors for chemical compounds represented by SMILES strings.
+
+    Attributes:
+    - data (pd.DataFrame): DataFrame containing SMILES strings and potentially other data.
+    - smiles_column (str): Name of the column containing the SMILES strings.
+    - fp_type (str): Type of fingerprint to calculate; supports 'drfp'.
+    - n_jobs (int): Number of parallel jobs to run for performance enhancement.
+    - verbose (int): Verbosity level of parallel computation.
+    - save_path (Optional[str]): Path to save the resulting DataFrame. If None, the DataFrame is not saved.
+    """
+
+    def __init__(
+        self,
+        data: pd.DataFrame,
+        smiles_column: str = "smiles",
+        fp_type: str = "drfp",
+        n_jobs: int = 2,
+        verbose: int = 0,
+        save_path: Optional[str] = None,
+    ):
+        self.data = data
+        self.smiles_column = smiles_column
+        self.fp_type = fp_type
+        self.n_jobs = n_jobs
+        self.verbose = verbose
+        self.save_path = save_path
+        self.logger = setup_logging()
+        self._validate_fp_type(fp_type)
+
+    def _validate_fp_type(self, fp_type: str) -> None:
+        valid_fps = [
+            "drfp",
+            "avalon",
+            "maccs",
+            "torsion",
+            "pharm2D",
+            "ecfp2",
+            "ecfp4",
+            "ecfp6",
+            "fcfp2",
+            "fcfp4",
+            "fcfp6",
+        ]
+        if fp_type not in valid_fps:
+            raise ValueError(
+                f"Unsupported fingerprint type '{fp_type}'. Currently supported: {', '.join(valid_fps)}."
+            )
+
+    @staticmethod
+    def calculate_drfp(smiles: str) -> np.ndarray:
+        """
+        Calculate the fingerprint vector for a given SMILES string using the DrfpEncoder.
+
+        Parameters:
+        - smiles (str): A SMILES string representing a chemical compound.
+
+        Returns:
+        - np.ndarray: A numpy array representing the fingerprint vector.
+        """
+        return DrfpEncoder.encode(smiles)[0]
+
+    @staticmethod
+    def smiles_to_vec(reaction_smiles: str, fp_type: str) -> np.ndarray:
+        """
+        Convert a SMILES string to a fingerprint vector based on the specified fingerprint type.
+
+        Parameters:
+        - reaction_smiles (str): A SMILES string representing a chemical compound.
+        - fp_type (str): Type of fingerprint to calculate.
+
+        Returns:
+        - np.ndarray: A numpy array representing the fingerprint vector.
+
+        Raises:
+            ValueError: If an unsupported fingerprint type is specified.
+        """
+        if fp_type == "drfp":
+            return FPCalculator.calculate_drfp(reaction_smiles)
+        else:
+            return TransformationFP.fit(reaction_smiles, ">>", fp_type, True)
+
+    def fit(self) -> pd.DataFrame:
+        """
+        Calculates the fingerprints for all SMILES strings in the dataset according to the specified fingerprint type.
+
+        Returns:
+        - pd.DataFrame: The original DataFrame with an added column for the calculated fingerprints.
+
+        Raises:
+            ValueError: If the SMILES column specified does not exist in the DataFrame.
+        """
+        if self.smiles_column not in self.data.columns:
+            raise ValueError(
+                f"Column '{self.smiles_column}' does not exist in the DataFrame."
+            )
+
+        fps = Parallel(n_jobs=self.n_jobs, verbose=self.verbose)(
+            delayed(FPCalculator.smiles_to_vec)(smiles, self.fp_type)
+            for smiles in self.data[self.smiles_column]
+        )
+
+        fps_df = pd.DataFrame(
+            fps, columns=[f"{self.fp_type}_{i}" for i in range(len(fps[0]))]
+        )
+        result_data = pd.concat([self.data, fps_df], axis=1)
+
+        if self.save_path:
+            result_data.to_csv(self.save_path, index=False)
+            self.logger.info(f"Data saved to {self.save_path}")
+
+        return result_data

synkit/Chem/Fingerprint/smiles_featurizer.py

@@ -0,0 +1,185 @@
+import numpy as np
+from rdkit import Chem, DataStructs
+from rdkit.Chem import AllChem, MACCSkeys
+from rdkit.Chem.AtomPairs import Pairs, Torsions
+from rdkit.Avalon import pyAvalonTools as fpAvalon
+from rdkit.Chem.Pharm2D import Gobbi_Pharm2D, Generate
+
+
+class SmilesFeaturizer:
+    def __init__(self):
+        """
+        Initializes the SmilesFeaturizer class without any specific parameters for fingerprint generation.
+        """
+        pass
+
+    @staticmethod
+    def smiles_to_mol(smiles: str) -> Chem.Mol:
+        """
+        Converts a SMILES string to an RDKit Mol object.
+
+        Parameters:
+        - smiles (str): The SMILES string to be converted.
+
+        Returns:
+        - Chem.Mol: The corresponding RDKit Mol object.
+        """
+        mol = Chem.MolFromSmiles(smiles)
+        if mol is None:
+            raise ValueError("Invalid SMILES string provided.")
+        return mol
+
+    @staticmethod
+    def get_maccs_keys(mol: Chem.Mol):
+        """
+        Generates MACCS keys fingerprint from an RDKit Mol object.
+
+        Parameters:
+        - mol (Chem.Mol): The Mol object to be featurized.
+
+        Returns:
+        - RDKit ExplicitBitVect: The MACCS keys fingerprint of the Mol object.
+        """
+        return MACCSkeys.GenMACCSKeys(mol)
+
+    @staticmethod
+    def get_avalon_fp(mol: Chem.Mol, nBits: int = 1024):
+        """
+        Generates Avalon fingerprint from an RDKit Mol object.
+
+        Parameters:
+        - mol (Chem.Mol): The Mol object to be featurized.
+        - nBits (int): The number of bits in the generated fingerprint.
+
+        Returns:
+        - RDKit ExplicitBitVect: The Avalon fingerprint of the Mol object.
+        """
+        return fpAvalon.GetAvalonFP(mol, nBits)
+
+    @staticmethod
+    def get_ecfp(
+        mol: Chem.Mol, radius: int, nBits: int = 2048, useFeatures: bool = False
+    ):
+        """
+        Generates Extended-Connectivity Fingerprints (ECFP) or
+        Feature-Class Fingerprints (FCFP) from an RDKit Mol object.
+
+        Parameters:
+        - mol (Chem.Mol): The Mol object to be featurized.
+        - radius (int): The radius of the fingerprint.
+        - nBits (int): The number of bits in the generated fingerprint.
+        - useFeatures (bool): Whether to use atom features instead of atom identities.
+
+        Returns:
+        - RDKit ExplicitBitVect: The ECFP or FCFP fingerprint of the Mol object.
+        """
+        return AllChem.GetMorganFingerprintAsBitVect(
+            mol, radius, nBits=nBits, useFeatures=useFeatures
+        )
+
+    @staticmethod
+    def get_rdk_fp(
+        mol: Chem.Mol, maxPath: int, fpSize: int = 2048, nBitsPerHash: int = 2
+    ):
+        """
+        Generates RDKit fingerprint from an RDKit Mol object.
+
+        Parameters:
+        - mol (Chem.Mol): The Mol object to be featurized.
+        - maxPath (int): The maximum path length (in bonds) to be included.
+        - fpSize (int): The size of the fingerprint.
+        - nBitsPerHash (int): The number of bits per hash.
+
+        Returns:
+        - RDKit ExplicitBitVect: The RDKit fingerprint of the Mol object.
+        """
+        return Chem.RDKFingerprint(
+            mol, maxPath=maxPath, fpSize=fpSize, nBitsPerHash=nBitsPerHash
+        )
+
+    @staticmethod
+    def mol_to_ap(mol: Chem.Mol) -> np.ndarray:
+        """
+        Generates an Atom Pair fingerprint as a NumPy array from an RDKit Mol object.
+
+        Parameters:
+        - mol (Chem.Mol): The Mol object to be featurized.
+
+        Returns:
+        - RDKit ExplicitBitVect: The RDKit fingerprint of the Mol object.
+        """
+        return Pairs.GetAtomPairFingerprint(mol)
+
+    @staticmethod
+    def mol_to_torsion(mol: Chem.Mol) -> np.ndarray:
+        """
+        Generates a Topological Torsion fingerprint as a NumPy array from an RDKit Mol object.
+
+        Parameters:
+        - mol (Chem.Mol): The Mol object to be featurized.
+
+        Returns:
+        - RDKit ExplicitBitVect: The RDKit fingerprint of the Mol object.
+        """
+        return Torsions.GetTopologicalTorsionFingerprintAsIntVect(mol)
+
+    @staticmethod
+    def mol_to_pharm2d(mol: Chem.Mol) -> np.ndarray:
+        """
+        Generates a 2D Pharmacophore fingerprint as a NumPy array from an RDKit Mol object.
+
+        Parameters:
+        - mol (Chem.Mol): The Mol object to be featurized.
+
+        Returns:
+        - RDKit ExplicitBitVect: The RDKit fingerprint of the Mol object.
+        """
+        return Generate.Gen2DFingerprint(mol, Gobbi_Pharm2D.factory)
+
+    @classmethod
+    def featurize_smiles(
+        cls, smiles: str, fingerprint_type: str, convert_to_array: bool = True, **kwargs
+    ) -> np.ndarray:
+        """
+        Featurizes a SMILES string into the specified type of fingerprint, optionally converting it to a NumPy array.
+
+        Parameters:
+        - smiles (str): The SMILES string to be featurized.
+        - fingerprint_type (str): The type of fingerprint to generate.
+        - convert_to_array (bool): Whether to convert the fingerprint to a NumPy array. Defaults to True.
+        - **kwargs: Additional keyword arguments for the fingerprint function.
+
+        Returns:
+        - np.ndarray or RDKit ExplicitBitVect: The requested type of fingerprint for the SMILES string,
+          either as a NumPy array or as an RDKit bit vector, depending on `convert_to_array`.
+        """
+        mol = cls.smiles_to_mol(smiles)
+        if fingerprint_type == "maccs":
+            fp = cls.get_maccs_keys(mol)
+        elif fingerprint_type == "avalon":
+            fp = cls.get_avalon_fp(mol, **kwargs)
+        elif fingerprint_type.startswith("ecfp") or fingerprint_type.startswith("fcfp"):
+            radius = int(fingerprint_type[4])
+            useFeatures = fingerprint_type.startswith("fcfp")
+            nBits = kwargs.get("nBits", 2048)
+            fp = cls.get_ecfp(mol, radius, nBits=nBits, useFeatures=useFeatures)
+        elif fingerprint_type.startswith("rdk"):
+            maxPath = int(fingerprint_type[3])
+            fp = cls.get_rdk_fp(mol, maxPath, **kwargs)
+        elif fingerprint_type == "avalon":
+            return cls.mol_to_ap(mol)
+        elif fingerprint_type == "torsion":
+            return cls.mol_to_torsion(mol)
+        elif fingerprint_type == "pharm2d":
+            return cls.mol_to_pharm2d(mol)
+        else:
+            raise ValueError(f"Unsupported fingerprint type: {fingerprint_type}")
+        if convert_to_array:
+            if fingerprint_type == "pharm2d":
+                return np.frombuffer(fp.ToBitString().encode(), "u1") - ord("0")
+            else:
+                ar = np.zeros((1,), dtype=np.int8)
+                DataStructs.ConvertToNumpyArray(fp, ar)
+                return ar
+        else:
+            return fp

synkit/Chem/Fingerprint/transformation_fp.py

@@ -0,0 +1,79 @@
+import numpy as np
+from typing import Union, Any
+from rdkit.DataStructs import cDataStructs
+from synkit.Chem.Fingerprint.smiles_featurizer import SmilesFeaturizer
+
+
+class TransformationFP:
+    """
+    A class for handling the transformation of chemical reactions into reaction fingerprints
+    based on SMILES strings.
+    """
+
+    def __init__(self) -> None:
+        """
+        Initializes the TransformationFP object. Currently, this constructor does not
+        perform any operations.
+        """
+        pass
+
+    @staticmethod
+    def convert_arr2vec(arr: np.ndarray) -> cDataStructs.ExplicitBitVect:
+        """
+        Converts a numpy array to a RDKit ExplicitBitVect.
+
+        Parameters:
+        - arr (np.ndarray): The input array.
+
+        Returns:
+        - cDataStructs.ExplicitBitVect: The converted bit vector.
+        """
+        arr_tostring = "".join(arr.astype(str))
+        EBitVect = cDataStructs.CreateFromBitString(arr_tostring)
+        return EBitVect
+
+    @staticmethod
+    def fit(
+        reaction_smiles: str,
+        symbols: str,
+        fp_type: str,
+        abs: bool,
+        return_array: bool = True,
+        **kwargs: Any,
+    ) -> Union[np.ndarray, cDataStructs.ExplicitBitVect]:
+        """
+        Generates a reaction fingerprint for a given reaction represented by a SMILES string.
+
+        Parameters:
+        - reaction_smiles (str): The SMILES string of the reaction, separated by `symbols`.
+        - symbols (str): The symbol used to separate reactants and products in the SMILES string.
+        - fp_type (str): The type of fingerprint to generate (e.g., 'maccs', 'ecfp').
+        - abs (bool): Whether to take the absolute value of the reaction fingerprint difference.
+        - return_array (bool): Whether to return the reaction fingerprint as a numpy array or as a bit vector.
+
+        Returns:
+        - Union[np.ndarray, cDataStructs.ExplicitBitVect]: The reaction fingerprint either as an array
+          or a bit vector, depending on the value of `return_array`.
+        """
+        react, prod = reaction_smiles.split(symbols)
+        react_fps = None
+        for s in react.split("."):
+            if react_fps is None:
+                react_fps = SmilesFeaturizer.featurize_smiles(s, fp_type, **kwargs)
+            else:
+                react_fps += SmilesFeaturizer.featurize_smiles(s, fp_type, **kwargs)
+
+        prod_fps = None
+        for s in prod.split("."):
+            if prod_fps is None:
+                prod_fps = SmilesFeaturizer.featurize_smiles(s, fp_type, **kwargs)
+            else:
+                prod_fps += SmilesFeaturizer.featurize_smiles(s, fp_type, **kwargs)
+
+        reaction_fp = np.subtract(prod_fps, react_fps)
+        if abs:
+            reaction_fp = np.abs(reaction_fp)
+        if return_array:
+            return reaction_fp
+        else:
+            return TransformationFP.convert_arr2vec(reaction_fp)

synkit/Chem/Molecule/standardize.py

@@ -0,0 +1,137 @@
+from rdkit import Chem
+from rdkit.Chem import rdmolops
+from rdkit.Chem.MolStandardize import rdMolStandardize
+from rdkit.Chem.SaltRemover import SaltRemover
+
+
+def normalize_molecule(mol: Chem.Mol) -> Chem.Mol:
+    """
+    Normalize a molecule using RDKit's Normalizer.
+
+    Parameters:
+    - mol (Chem.Mol): RDKit Mol object to be normalized.
+
+    Returns:
+    - Chem.Mol: Normalized RDKit Mol object.
+    """
+    normalizer = rdMolStandardize.Normalizer()
+    return normalizer.normalize(mol)
+
+
+def canonicalize_tautomer(mol: Chem.Mol) -> Chem.Mol:
+    """
+    Canonicalize the tautomer of a molecule using RDKit's TautomerCanonicalizer.
+
+    Parameters:
+    - mol (Chem.Mol): RDKit Mol object.
+
+    Returns:
+    - Chem.Mol: Mol object with canonicalized tautomer.
+    """
+    tautomer_canonicalizer = rdMolStandardize.TautomerEnumerator()
+    return tautomer_canonicalizer.Canonicalize(mol)
+
+
+def salts_remover(mol: Chem.Mol) -> Chem.Mol:
+    """
+    Remove salt fragments from a molecule using RDKit's SaltRemover.
+
+    Parameters:
+    - mol (Chem.Mol): RDKit Mol object.
+
+    Returns:
+    - Chem.Mol: Mol object with salts removed.
+    """
+    remover = SaltRemover()
+    return remover.StripMol(mol)
+
+
+def uncharge_molecule(mol: Chem.Mol) -> Chem.Mol:
+    """
+    Neutralize a molecule by removing counter-ions using RDKit's Uncharger.
+
+    Parameters:
+    - mol (Chem.Mol): RDKit Mol object.
+
+    Returns:
+    - Chem.Mol: Neutralized Mol object.
+    """
+    uncharger = rdMolStandardize.Uncharger()
+    return uncharger.uncharge(mol)
+
+
+def fragments_remover(mol: Chem.Mol) -> Chem.Mol:
+    """
+    Remove small fragments from a molecule, keeping only the largest one.
+
+    Parameters:
+    - mol (Chem.Mol): RDKit Mol object.
+
+    Returns:
+    - Chem.Mol: Mol object with small fragments removed.
+    """
+    frags = Chem.GetMolFrags(mol, asMols=True, sanitizeFrags=True)
+    return max(frags, default=None, key=lambda m: m.GetNumAtoms())
+
+
+def remove_explicit_hydrogens(mol: Chem.Mol) -> Chem.Mol:
+    """
+    Remove explicit hydrogens from a molecule to leave only the heavy atoms.
+
+    Parameters:
+    - mol (Chem.Mol): RDKit Mol object.
+
+    Returns:
+    - Chem.Mol: Mol object with explicit hydrogens removed.
+    """
+    return Chem.RemoveHs(mol)
+
+
+def remove_radicals_and_add_hydrogens(mol: Chem.Mol) -> Chem.Mol:
+    """
+    Remove radicals from a molecule by setting radical electrons to zero and adding hydrogens where needed.
+
+    Parameters:
+    - mol (Chem.Mol): RDKit Mol object.
+
+    Returns:
+    - Chem.Mol: Mol object with radicals removed and necessary hydrogens added.
+    """
+    mol = Chem.RemoveHs(mol)  # Remove explicit hydrogens first
+    for atom in mol.GetAtoms():
+        if atom.GetNumRadicalElectrons() > 0:
+            atom.SetNumExplicitHs(
+                atom.GetNumExplicitHs() + atom.GetNumRadicalElectrons()
+            )
+        atom.SetNumRadicalElectrons(0)
+    mol = rdmolops.AddHs(mol)  # Add hydrogens back
+    return remove_explicit_hydrogens(mol)
+
+
+def remove_isotopes(mol: Chem.Mol) -> Chem.Mol:
+    """
+    Remove isotopic information from a molecule.
+
+    Parameters:
+    - mol (Chem.Mol): RDKit Mol object.
+
+    Returns:
+    - Chem.Mol: Mol object with isotopes removed.
+    """
+    for atom in mol.GetAtoms():
+        atom.SetIsotope(0)
+    return mol
+
+
+def clear_stereochemistry(mol: Chem.Mol) -> Chem.Mol:
+    """
+    Clear all stereochemical information from a molecule.
+
+    Parameters:
+    - mol (Chem.Mol): RDKit Mol object.
+
+    Returns:
+    - Chem.Mol: Mol object with stereochemistry cleared.
+    """
+    Chem.RemoveStereochemistry(mol)
+    return mol

synkit/Chem/Reaction/balance_check.py

@@ -0,0 +1,162 @@
+from rdkit import Chem
+from rdkit.Chem.rdMolDescriptors import CalcMolFormula
+
+from joblib import Parallel, delayed
+from typing import List, Dict, Union, Tuple
+
+
+class BalanceReactionCheck:
+    """
+    A class to check the balance of chemical reactions given in SMILES format.
+    It supports parallel execution and maintains the input format in the output.
+    """
+
+    def __init__(
+        self,
+        n_jobs: int = 4,
+        verbose: int = 0,
+    ):
+        """
+        Initializes the class with given input data, the column name
+        for reactions in the input, number of jobs for
+        parallel processing, and verbosity level.
+
+        Parameters:
+        - input_data (Union[str, List[Union[str, Dict[str, str]]]]): A single SMILES
+        string, a list of SMILES strings, or a list of dictionaries with 'reactions' keys.
+        - rsmi_column (str): The key/column name for reaction SMILES strings
+        in the input data.
+        - n_jobs (int): The number of parallel jobs to run for balance checking.
+        - verbose (int): The verbosity level of joblib parallel execution.
+        """
+
+        self.n_jobs = n_jobs
+        self.verbose = verbose
+
+    @staticmethod
+    def get_combined_molecular_formula(smiles: str) -> str:
+        """
+        Computes the molecular formula for a molecule represented by a SMILES string.
+
+        Parameters:
+        - smiles (str): The SMILES string of the molecule.
+
+        Returns:
+        - str: The molecular formula, or an empty string if the molecule is invalid.
+        """
+        mol = Chem.MolFromSmiles(smiles)
+        if not mol:
+            return ""
+        return CalcMolFormula(mol)
+
+    @staticmethod
+    def parse_input(
+        input_data: Union[str, List[Union[str, Dict[str, str]]]],
+        rsmi_column: str = "reactions",
+    ) -> List[Dict[str, str]]:
+        """
+        Parses the input data into a standardized list containing
+        dictionaries for each reaction.
+
+        Parameters:
+        - input_data (Union[str, List[Union[str, Dict[str, str]]]]):
+        The input data to be processed.
+
+        Returns:
+        - List[Dict[str, str]]: A list of dictionaries with reaction SMILES strings.
+        """
+        standardized_input = []
+        if isinstance(input_data, str):
+            standardized_input.append({rsmi_column: input_data})
+        elif isinstance(input_data, list):
+            for item in input_data:
+                if isinstance(item, str):
+                    standardized_input.append({rsmi_column: item})
+                elif isinstance(item, dict) and rsmi_column in item:
+                    standardized_input.append(item)
+        else:
+            raise ValueError("Unsupported input type")
+        return standardized_input
+
+    @staticmethod
+    def parse_reaction(reaction_smiles: str) -> Tuple[List[str], List[str]]:
+        """
+        Splits a reaction SMILES string into reactants and products.
+
+        Parameters:
+        - reaction_smiles (str): A SMILES string representing a chemical reaction.
+
+        Returns:
+        - Tuple[List[str], List[str]]: Lists of SMILES strings for reactants and products.
+        """
+        reactants_smiles, products_smiles = reaction_smiles.split(">>")
+        return reactants_smiles, products_smiles
+
+    @staticmethod
+    def rsmi_balance_check(reaction_smiles: str) -> bool:
+        """
+        Checks if a reaction SMILES string is balanced.
+
+        Parameters:
+        - reaction_smiles (str): A SMILES string representing a chemical reaction.
+
+        Returns:
+        - bool: True if the reaction is balanced, False otherwise.
+        """
+        reactants_smiles, products_smiles = BalanceReactionCheck.parse_reaction(
+            reaction_smiles
+        )
+        reactants_forumula = BalanceReactionCheck.get_combined_molecular_formula(
+            reactants_smiles
+        )
+        products_forumula = BalanceReactionCheck.get_combined_molecular_formula(
+            products_smiles
+        )
+        return reactants_forumula == products_forumula
+
+    @staticmethod
+    def dict_balance_check(
+        reaction_dict: Dict[str, str], rsmi_column: str
+    ) -> Dict[str, Union[bool, str]]:
+        """
+        Checks if a single reaction (in SMILES format) is balanced, maintaining
+        the input format.
+
+        Parameters:
+        - reaction_dict (Dict[str, str]): A dictionary containing the
+        reaction SMILES string.
+
+        Returns:
+        - Dict[str, Union[bool, str]]: A dictionary indicating if the reaction is
+        balanced, along with the original reaction data.
+        """
+        reaction_smiles = reaction_dict[rsmi_column]
+        balance = BalanceReactionCheck.rsmi_balance_check(reaction_smiles)
+        return {"balanced": balance, **reaction_dict}
+
+    def dicts_balance_check(
+        self,
+        input_data: Union[str, List[Union[str, Dict[str, str]]]],
+        rsmi_column: str = "reactions",
+    ) -> Tuple[List[Dict[str, Union[bool, str]]], List[Dict[str, Union[bool, str]]]]:
+        """
+        Checks the balance of all reactions in the input data.
+
+        Returns:
+        - Tuple[List[Dict[str, Union[bool, str]]], List[Dict[str, Union[bool, str]]]]:
+        Two lists containing dictionaries of balanced and unbalanced reactions,
+        respectively.
+        """
+
+        reactions = self.parse_input(input_data, rsmi_column)
+        results = Parallel(n_jobs=self.n_jobs, verbose=self.verbose)(
+            delayed(self.dict_balance_check)(reaction, rsmi_column)
+            for reaction in reactions
+        )
+
+        balanced_reactions = [reaction for reaction in results if reaction["balanced"]]
+        unbalanced_reactions = [
+            reaction for reaction in results if not reaction["balanced"]
+        ]
+
+        return balanced_reactions, unbalanced_reactions