synkit 1.6.5__py3-none-win_amd64.whl

synkit/Chem/Molecule/valence.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from typing import Protocol, runtime_checkable
+
+from rdkit import Chem
+from rdkit.Chem import rdchem as rdchem
+
+
+@runtime_checkable
+class _AtomLike(Protocol):
+    """Minimal protocol RDKit atoms satisfy (duck-typed for typing tools)."""
+
+    def GetValence(self, which: rdchem.ValenceType | int = ...) -> int: ...
+    def GetExplicitValence(self) -> int: ...
+    def GetImplicitValence(self) -> int: ...
+    def GetNumImplicitHs(self) -> int: ...
+
+
+class ValenceResolver:
+    """Warning-free valence utilities for RDKit atoms.
+
+    These helpers retrieve **explicit**, **implicit**, and **total** valences
+    while silencing common deprecation or signature warnings across RDKit
+    versions. They first try the modern keyword-argument API and then
+    fall back to older call signatures or legacy methods.
+
+    Preferred (modern) RDKit API:
+        - ``atom.GetValence(which=rdchem.ValenceType.EXPLICIT)``
+        - ``atom.GetValence(which=rdchem.ValenceType.IMPLICIT)``
+
+    Fallbacks maintain compatibility with older wrappers:
+        - ``atom.GetValence(rdchem.ValenceType.EXPLICIT)`` (positional)
+        - ``atom.GetExplicitValence()``
+        - ``atom.GetImplicitValence()``
+        - ``atom.GetNumImplicitHs()`` (as a last resort for implicit)
+
+    .. rubric:: Notes
+
+    * Returned values are coerced to Python ``int`` and guaranteed non-negative,
+      with ``0`` returned if all strategies fail.
+    * Values reflect the current atom state and must be queried again after
+      changes to hydrogen counts, aromaticity, or bond orders.
+    * ``Chem.Atom`` is an alias of ``rdchem.Atom``, but a structural duck-type
+      ``_AtomLike`` protocol is provided for static typing tools.
+
+    .. rubric:: Examples
+
+    >>> from rdkit import Chem
+    >>> m = Chem.MolFromSmiles("CCO")
+    >>> a = m.GetAtomWithIdx(1)  # central carbon
+    >>> ValenceResolver.explicit(a) >= 0
+    True
+    >>> ValenceResolver.total(a) == ValenceResolver.explicit(a) + ValenceResolver.implicit(a)
+    True
+    """
+
+    @staticmethod
+    def explicit(atom: Chem.Atom | _AtomLike) -> int:
+        """Return the **explicit valence** of an atom.
+
+        Tries modern ``GetValence(which=EXPLICIT)`` first, then older positional
+        form, then ``GetExplicitValence()``. Returns ``0`` on failure.
+
+        :param atom: RDKit atom instance.
+        :type atom: rdchem.Atom
+        :return: Explicit valence (non-negative integer).
+        :rtype: int
+        """
+        # Modern keyword form (preferred; avoids RDKit warnings)
+        try:
+            return int(atom.GetValence(which=rdchem.ValenceType.EXPLICIT))  # type: ignore[call-arg]
+        except TypeError:
+            # Some RDKit builds don't accept the kwarg form
+            try:
+                return int(atom.GetValence(rdchem.ValenceType.EXPLICIT))  # type: ignore[arg-type]
+            except Exception:
+                # Legacy explicit valence API
+                try:
+                    return int(atom.GetExplicitValence())
+                except Exception:
+                    return 0
+
+    @staticmethod
+    def implicit(atom: Chem.Atom | _AtomLike) -> int:
+        """Return the **implicit valence** of an atom.
+
+        Tries modern ``GetValence(which=IMPLICIT)`` first, then older positional
+        form, then ``GetImplicitValence()``, finally falls back to the number of
+        implicit hydrogens if needed. Returns ``0`` on failure.
+
+        :param atom: RDKit atom instance.
+        :type atom: rdchem.Atom
+        :return: Implicit valence (non-negative integer).
+        :rtype: int
+        """
+        # Modern keyword form (preferred)
+        try:
+            return int(atom.GetValence(which=rdchem.ValenceType.IMPLICIT))  # type: ignore[call-arg]
+        except TypeError:
+            # Older builds without kwarg support
+            try:
+                return int(atom.GetValence(rdchem.ValenceType.IMPLICIT))  # type: ignore[arg-type]
+            except Exception:
+                # Legacy implicit valence API
+                try:
+                    return int(atom.GetImplicitValence())
+                except Exception:
+                    # As a last resort, approximate with implicit Hs
+                    try:
+                        return int(atom.GetNumImplicitHs())
+                    except Exception:
+                        return 0
+
+    @staticmethod
+    def total(atom: Chem.Atom | _AtomLike) -> int:
+        """Return the **total valence** (explicit + implicit).
+
+        :param atom: RDKit atom instance.
+        :type atom: rdchem.Atom
+        :return: Total valence as ``explicit(atom) + implicit(atom)``.
+        :rtype: int
+        """
+        return ValenceResolver.explicit(atom) + ValenceResolver.implicit(atom)

synkit/Chem/Reaction/Mapper/__init__.py

@@ -0,0 +1,44 @@
+"""Compatibility alias for :mod:`synkit.Chem.Mapper`.
+
+Atom-to-atom mapping is now a top-level chemistry concern. New code should
+import from :mod:`synkit.Chem.Mapper`; this package preserves the former
+``synkit.Chem.Reaction.Mapper`` imports, including imports of its submodules.
+"""
+
+from __future__ import annotations
+
+import importlib
+import pkgutil
+import sys
+
+from synkit.Chem import Mapper as _mapper
+from synkit.Chem.Mapper import *  # noqa: F401,F403
+
+__all__ = _mapper.__all__
+__path__ = _mapper.__path__
+
+for _solver_name in ("exact", "slap", "_native"):
+    globals()[_solver_name] = getattr(_mapper, _solver_name)
+
+# Bind every canonical mapper module to its historical name. Besides keeping
+# deep imports working, this ensures classes imported through old and new
+# paths have the same identity.
+for _module_info in pkgutil.walk_packages(
+    _mapper.__path__, prefix=f"{_mapper.__name__}."
+):
+    _canonical_name = _module_info.name
+    _module = importlib.import_module(_canonical_name)
+    _suffix = _canonical_name.removeprefix(_mapper.__name__)
+    sys.modules[f"{__name__}{_suffix}"] = _module
+    if _suffix.count(".") == 1:
+        globals()[_suffix[1:]] = _module
+
+# Include flat compatibility aliases that no longer have their own source file.
+for _canonical_name, _module in list(sys.modules.items()):
+    if _canonical_name.startswith(f"{_mapper.__name__}."):
+        _suffix = _canonical_name.removeprefix(_mapper.__name__)
+        sys.modules[f"{__name__}{_suffix}"] = _module
+        if _suffix.count(".") == 1:
+            globals()[_suffix[1:]] = _module
+
+del _canonical_name, _mapper, _module, _module_info, _suffix, _solver_name

synkit/Chem/Reaction/__init__.py

@@ -0,0 +1,20 @@
+from .aam_validator import AAMValidator
+from .explicit_h_audit import (
+    ExplicitHydrogenReactionAudit,
+    MappedBondChange,
+    audit_explicit_h_reaction,
+    reaction_smiles_from_annotated_text,
+)
+from synkit.Chem.utils import remove_explicit_H_from_rsmi
+
+# from .standardize import Standardize
+# from .canon_rsmi import CanonRSMI
+
+__all__ = [
+    "AAMValidator",
+    "ExplicitHydrogenReactionAudit",
+    "MappedBondChange",
+    "audit_explicit_h_reaction",
+    "reaction_smiles_from_annotated_text",
+    "remove_explicit_H_from_rsmi",
+]

synkit/Chem/Reaction/aam_validator.py

@@ -0,0 +1,5 @@
+"""Backward-compatible AAMValidator import path."""
+
+from synkit.Chem.Mapper.aam_validator import AAMValidator
+
+__all__ = ["AAMValidator"]

synkit/Chem/Reaction/balance_check.py

@@ -0,0 +1,138 @@
+from rdkit import Chem
+from rdkit.Chem.rdMolDescriptors import CalcMolFormula
+from joblib import Parallel, delayed
+from typing import List, Dict, Union, Tuple, Any
+
+
+class BalanceReactionCheck:
+    """Check elemental balance of chemical reactions in SMILES format.
+
+    Supports checking single reactions, reaction dictionaries, or lists
+    in parallel.
+
+    :ivar n_jobs: Number of parallel jobs for batch checking.
+    :ivar verbose: Verbosity level for joblib.
+    """
+
+    def __init__(self, n_jobs: int = 4, verbose: int = 0) -> None:
+        """
+        :param n_jobs: Number of parallel jobs for batch balance checks. Defaults to 4.
+        :type n_jobs: int
+        :param verbose: Verbosity level passed to joblib. Defaults to 0.
+        :type verbose: int
+        """
+        self.n_jobs = n_jobs
+        self.verbose = verbose
+
+    @staticmethod
+    def get_combined_molecular_formula(smiles: str) -> str:
+        """Compute the molecular formula of a SMILES.
+
+        :param smiles: SMILES string of the molecule.
+        :type smiles: str
+        :return: Elemental formula (e.g., "C6H6") or empty string if
+            invalid.
+        :rtype: str
+        """
+        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]]:
+        """Normalize input into a list of reaction‐dicts.
+
+        :param input_data: A single SMILES, list of SMILES, or list of dicts containing `rsmi_column`.
+        :type input_data: str or List[Union[str, Dict[str, str]]]
+        :param rsmi_column: Key in dicts for the reaction SMILES. Defaults to "reactions".
+        :type rsmi_column: str
+        :return: List of dicts with a single key `rsmi_column` mapping to each reaction.
+        :rtype: List[Dict[str, str]]
+        :raises ValueError: If `input_data` is neither str nor list.
+        """
+        standardized: List[Dict[str, str]] = []
+        if isinstance(input_data, str):
+            standardized.append({rsmi_column: input_data})
+        elif isinstance(input_data, list):
+            for item in input_data:
+                if isinstance(item, str):
+                    standardized.append({rsmi_column: item})
+                elif isinstance(item, dict) and rsmi_column in item:
+                    standardized.append(item)
+        else:
+            raise ValueError("Unsupported input type for balance checking")
+        return standardized
+
+    @staticmethod
+    def parse_reaction(reaction_smiles: str) -> Tuple[str, str]:
+        """Split a reaction SMILES into reactant and product SMILES strings.
+
+        :param reaction_smiles: Reaction SMILES in 'reactants>>products'
+            format.
+        :type reaction_smiles: str
+        :return: Tuple of (reactants, products) SMILES.
+        :rtype: Tuple[str, str]
+        """
+        return tuple(reaction_smiles.split(">>"))
+
+    @staticmethod
+    def rsmi_balance_check(reaction_smiles: str) -> bool:
+        """Determine if a reaction SMILES is elementally balanced.
+
+        :param reaction_smiles: Reaction SMILES in 'reactants>>products'
+            format.
+        :type reaction_smiles: str
+        :return: True if reactant and product formulas match, else
+            False.
+        :rtype: bool
+        """
+        react, prod = BalanceReactionCheck.parse_reaction(reaction_smiles)
+        react_formula = BalanceReactionCheck.get_combined_molecular_formula(react)
+        prod_formula = BalanceReactionCheck.get_combined_molecular_formula(prod)
+        return react_formula == prod_formula
+
+    @staticmethod
+    def dict_balance_check(
+        reaction_dict: Dict[str, str], rsmi_column: str
+    ) -> Dict[str, Any]:
+        """Check balance for a single reaction dict, preserving original keys.
+
+        :param reaction_dict: Dict containing at least a `rsmi_column` key.
+        :type reaction_dict: Dict[str, str]
+        :param rsmi_column: Key for reaction SMILES in `reaction_dict`.
+        :type rsmi_column: str
+        :return: Original dict augmented with `"balanced": bool`.
+        :rtype: Dict[str, Any]
+        """
+        rsmi = reaction_dict[rsmi_column]
+        balanced = BalanceReactionCheck.rsmi_balance_check(rsmi)
+        return {"balanced": balanced, **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, Any]], List[Dict[str, Any]]]:
+        """Batch‐check balance for multiple reactions, in parallel.
+
+        :param input_data: Single reaction SMILES, list of SMILES, or
+            list of dicts.
+        :type input_data: Union[str, List[Union[str, Dict[str, str]]]]
+        :param rsmi_column: Key for reaction SMILES in each dict.
+            Defaults to "reactions".
+        :type rsmi_column: str
+        :return: Tuple (balanced_list, unbalanced_list) of dicts each
+            including `"balanced"`.
+        :rtype: Tuple[List[Dict[str, Any]], List[Dict[str, Any]]]
+        """
+        reactions = self.parse_input(input_data, rsmi_column)
+        results = Parallel(n_jobs=self.n_jobs, verbose=self.verbose)(
+            delayed(self.dict_balance_check)(rd, rsmi_column) for rd in reactions
+        )
+        balanced = [r for r in results if r["balanced"]]
+        unbalanced = [r for r in results if not r["balanced"]]
+        return balanced, unbalanced

synkit/Chem/Reaction/canon_rsmi.py

@@ -0,0 +1,249 @@
+import inspect
+import networkx as nx
+from rdkit import Chem
+from rdkit.Chem import MolFromSmiles as _rdkit_MolFromSmiles
+from typing import List, Tuple, Union, Optional
+
+from synkit.Graph.canon_graph import GraphCanonicaliser
+from synkit.IO import graph_to_smi, rsmi_to_graph
+
+
+class CanonRSMI:
+    """A **pure-Python / pure-NetworkX** utility for canonicalizing reaction
+    SMILES by expanding atom-maps and deterministically reindexing reaction
+    graphs.
+
+    Workflow
+    --------
+    1. **Expand atom-maps** on reactants to ensure each atom has a unique map ID.
+    2. **Convert** reaction SMILES to reactant/product NetworkX graphs.
+    3. **Canonicalize** the reactant graph using `GraphCanonicaliser` (generic or WL backend).
+    4. **Match** atom-map IDs to compute pairwise indices between reactants and products.
+    5. **Remap** the product graph to align with the canonical reactant ordering.
+    6. **Sync** each node’s `atom_map` attribute to its new graph index.
+    7. **Reassemble** the reaction SMILES from the canonical graphs.
+
+    Classes
+    -------
+    - `CanonRSMI` – Main interface for transforming any `reactants>>products` SMILES
+      into a canonicalized form, preserving all node and edge attributes.
+
+    .. rubric:: Example
+
+    >>> from canonical_rsm import CanonRSMI
+    >>> canon = CanonRSMI(backend='wl', wl_iterations=5)
+    >>> result = canon.canonicalise('[CH3:3][CH2:5][OH:10]>>[CH2:3]=[CH2:5].[OH2:10]')
+    >>> print(result.canonical_rsmi)
+    [OH:1][CH2:3][CH3:2]>>[CH2:2]=[CH2:3].[OH2:1]
+    """
+
+    def __init__(
+        self,
+        backend: str = "wl",
+        wl_iterations: int = 3,
+        morgan_radius: int = 3,
+        node_attrs: List[str] = ("element", "aromatic", "charge", "hcount"),
+    ):
+        self._canon = GraphCanonicaliser(
+            backend=backend,
+            wl_iterations=wl_iterations,
+            morgan_radius=morgan_radius,
+            node_attrs=node_attrs,
+        )
+        # internal storage
+        self._raw_rsmi: Optional[str] = None
+        self._canon_rsmi: Optional[str] = None
+        self._raw_reactant_graph: Optional[nx.Graph] = None
+        self._raw_product_graph: Optional[nx.Graph] = None
+        self._canon_reactant_graph: Optional[nx.Graph] = None
+        self._canon_product_graph: Optional[nx.Graph] = None
+        self._mapping_pairs: Optional[List[Tuple[int, int]]] = None
+
+    @staticmethod
+    def _mol_from_smiles(smi: str) -> Chem.Mol:
+        """RDKit MolFromSmiles with explicit sanitize step."""
+        mol = _rdkit_MolFromSmiles(smi, sanitize=False)
+        Chem.SanitizeMol(mol)
+        return mol
+
+    def expand_aam(self, rsmi: str) -> str:
+        """Assign new atom-map IDs to unmapped reactant atoms in
+        'reactants>>products' SMILES.
+
+        New IDs start at max(existing maps)+1.
+        """
+        try:
+            reac_s, prod_s = rsmi.split(">>")
+        except ValueError:
+            raise ValueError("Input must be in 'reactants>>products' form")
+
+        reac_mols = [self._mol_from_smiles(s) for s in reac_s.split(".")]
+        prod_mols = [self._mol_from_smiles(s) for s in prod_s.split(".")]
+
+        existing = {
+            atom.GetAtomMapNum()
+            for mol in (*reac_mols, *prod_mols)
+            for atom in mol.GetAtoms()
+            if atom.GetAtomMapNum() > 0
+        }
+        next_id = max(existing, default=0) + 1
+
+        for mol in reac_mols:
+            for atom in mol.GetAtoms():
+                if atom.GetAtomMapNum() == 0:
+                    atom.SetAtomMapNum(next_id)
+                    next_id += 1
+
+        new_reac = ".".join(Chem.MolToSmiles(m, canonical=True) for m in reac_mols)
+        new_prod = ".".join(Chem.MolToSmiles(m, canonical=True) for m in prod_mols)
+        return f"{new_reac}>>{new_prod}"
+
+    @staticmethod
+    def sync_atom_map_with_index(G: nx.Graph) -> None:
+        """
+        In-place: set each node's 'atom_map' attribute to its node ID.
+        """
+        nx.set_node_attributes(G, {n: n for n in G.nodes()}, "atom_map")
+
+    @staticmethod
+    def get_aam_pairwise_indices(
+        G: nx.Graph, H: nx.Graph, aam_key: str = "atom_map"
+    ) -> List[Tuple[int, int]]:
+        """Return sorted list of (G_node, H_node) for shared atom-map IDs."""
+        gmap = {
+            data[aam_key]: n
+            for n, data in G.nodes(data=True)
+            if data.get(aam_key, 0) > 0
+        }
+        hmap = {
+            data[aam_key]: n
+            for n, data in H.nodes(data=True)
+            if data.get(aam_key, 0) > 0
+        }
+        common = sorted(gmap.keys() & hmap.keys())
+        return [(gmap[k], hmap[k]) for k in common]
+
+    @staticmethod
+    def remap_graph(
+        G: nx.Graph, node_map: Union[List[int], List[Tuple[int, int]]]
+    ) -> nx.Graph:
+        """Remap a product graph to match a canonical reactant ordering:
+
+        :param G: reactant graph
+        :type G: nx.Graph
+        :param node_map: Product node ordering or ``(new, old)`` node pairs.
+        :type node_map: list[int] | list[tuple[int, int]]
+        :return:
+            remapped product graph
+        :rtype: nx.Graph
+        """
+
+        if not node_map:
+            raise ValueError("node_map must be non-empty")
+        if isinstance(node_map[0], int):
+            mapping = {old: new for new, old in enumerate(node_map, start=1)}
+        else:
+            mapping = {old: new for new, old in node_map}
+        missing = set(mapping) - set(G.nodes())
+        if missing:
+            raise KeyError(f"Mappings refer to nodes not in G: {missing}")
+        return nx.relabel_nodes(G, mapping, copy=True)
+
+    def canonicalise(self, rsmi: str) -> "CanonRSMI":
+        """
+        Full pipeline returning self with properties populated:
+          - raw_rsmi
+          - raw_reactant_graph, raw_product_graph
+          - mapping_pairs
+          - canonical_reactant_graph, canonical_product_graph
+          - canonical_rsmi
+        """
+        # store raw
+        self._raw_rsmi = rsmi
+        # expand and build graphs
+        expanded = self.expand_aam(rsmi)
+        self._raw_reactant_graph, self._raw_product_graph = rsmi_to_graph(expanded)
+        # canonicalise reactants
+        self._canon_reactant_graph = self._canon.canonicalise_graph(
+            self._raw_reactant_graph
+        ).canonical_graph
+        # map products
+        self._mapping_pairs = self.get_aam_pairwise_indices(
+            self._canon_reactant_graph, self._raw_product_graph
+        )
+        self._canon_product_graph = self.remap_graph(
+            self._raw_product_graph, self._mapping_pairs
+        )
+        # sync maps
+        self.sync_atom_map_with_index(self._canon_reactant_graph)
+        self.sync_atom_map_with_index(self._canon_product_graph)
+        # assemble output
+        self._canon_rsmi = (
+            f"{graph_to_smi(self._canon_reactant_graph)}>>"
+            f"{graph_to_smi(self._canon_product_graph)}"
+        )
+        return self
+
+    __call__ = canonicalise
+
+    @property
+    def raw_rsmi(self) -> Optional[str]:
+        """Original SMILES before canonicalisation."""
+        return self._raw_rsmi
+
+    @property
+    def canonical_rsmi(self) -> Optional[str]:
+        """Canonical SMILES after processing."""
+        return self._canon_rsmi
+
+    @property
+    def raw_reactant_graph(self) -> Optional[nx.Graph]:
+        """NetworkX graph of raw reactants."""
+        return self._raw_reactant_graph
+
+    @property
+    def raw_product_graph(self) -> Optional[nx.Graph]:
+        """NetworkX graph of raw products."""
+        return self._raw_product_graph
+
+    @property
+    def canonical_reactant_graph(self) -> Optional[nx.Graph]:
+        """NetworkX graph of canonicalised reactants."""
+        return self._canon_reactant_graph
+
+    @property
+    def canonical_product_graph(self) -> Optional[nx.Graph]:
+        """NetworkX graph of canonicalised products."""
+        return self._canon_product_graph
+
+    @property
+    def canonical_hash(self) -> Optional[str]:
+        """Reaction-level hash combining reactant and product canonical
+        hashes."""
+        if not self._canon_reactant_graph or not self._canon_product_graph:
+            return None
+        h_reac = self._canon.canonical_signature(self._canon_reactant_graph)
+        h_prod = self._canon.canonical_signature(self._canon_product_graph)
+        return f"{h_reac}>>{h_prod}"
+
+    @property
+    def mapping_pairs(self) -> Optional[List[Tuple[int, int]]]:
+        """List of atom-map index pairs between reactants and products."""
+        return self._mapping_pairs
+
+    def help(self) -> None:  # pragma: no cover
+        """Pretty-print the class doc and public methods with signatures."""
+        print(inspect.getdoc(self.__class__))
+        for meth in (
+            "expand_aam",
+            "canonicalise",
+            "get_aam_pairwise_indices",
+            "remap_graph",
+        ):
+            print(f"  • {meth}{inspect.signature(getattr(self, meth))}")
+
+    def __repr__(self) -> str:  # pragma: no cover
+        return (
+            f"<CanonRSMI backend={self._canon.backend!r} "
+            f"wl_iterations={self._canon._wl_k}>"
+        )

synkit/Chem/Reaction/cleaning.py

@@ -0,0 +1,58 @@
+from typing import List
+from synkit.Chem.Reaction.standardize import Standardize
+from synkit.Chem.Reaction.balance_check import BalanceReactionCheck
+
+
+class Cleaning:
+    """Utilities for cleaning and filtering reaction SMILES lists."""
+
+    def __init__(self) -> None:
+        """Initialize the Cleaning helper.
+
+        No instance attributes are used.
+        """
+        pass
+
+    @staticmethod
+    def remove_duplicates(smiles_list: List[str]) -> List[str]:
+        """Remove duplicate SMILES strings, preserving first occurrences.
+
+        :param smiles_list: List of reaction SMILES strings.
+        :type smiles_list: List[str]
+        :return: List of unique SMILES in original order.
+        :rtype: List[str]
+        """
+        seen = set()
+        return [smi for smi in smiles_list if not (smi in seen or seen.add(smi))]
+
+    @staticmethod
+    def clean_smiles(smiles_list: List[str]) -> List[str]:
+        """Standardize, balance‑check, and deduplicate reaction SMILES.
+
+        Steps:
+          1. Standardize each SMILES via `Standardize.standardize_rsmi`.
+          2. Keep only those that pass `BalanceReactionCheck.rsmi_balance_check`.
+          3. Remove duplicates preserving order.
+
+        :param smiles_list: List of reaction SMILES strings to clean.
+        :type smiles_list: List[str]
+        :return: Cleaned list of standardized, balanced, unique SMILES.
+        :rtype: List[str]
+        """
+        standardizer = Standardize()
+        balance_checker = BalanceReactionCheck()
+
+        standardized: List[str] = []
+        for smi in smiles_list:
+            try:
+                std = standardizer.standardize_rsmi(smi, stereo=True)
+                if std:
+                    standardized.append(std)
+            except Exception:
+                continue
+
+        balanced = [
+            smi for smi in standardized if balance_checker.rsmi_balance_check(smi)
+        ]
+
+        return Cleaning.remove_duplicates(balanced)