synkit 1.6.5__py3-none-win_amd64.whl

synkit/Chem/Reaction/tautomerize.py

@@ -0,0 +1,205 @@
+from typing import List, Dict, Optional
+from rdkit import Chem
+from joblib import Parallel, delayed
+
+from synkit.Graph.FG import smiles_to_graph_and_functional_groups
+
+
+class Tautomerize:
+    """Standardize molecules by converting enol and hemiketal tautomers into
+    their more stable carbonyl forms, and apply these corrections to individual
+    SMILES or collections of reaction data."""
+
+    @staticmethod
+    def standardize_enol(smiles: str, atom_indices: Optional[List[int]] = None) -> str:
+        """Convert an enol tautomer into its corresponding carbonyl form.
+
+        :param smiles: SMILES string of the enol-containing molecule.
+        :type smiles: str
+        :param atom_indices: List of three atom indices [C1, C2, O]
+            defining the enol. If None, defaults to [0, 1, 2].
+        :type atom_indices: List[int] or None
+        :return: SMILES of the molecule after enol→carbonyl conversion,
+            or an error message if the input is invalid or indices fail.
+        :rtype: str
+        """
+        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:
+            c_idxs = [
+                i for i in atom_indices if mol.GetAtomWithIdx(i).GetSymbol() == "C"
+            ]
+            c1_idx, c2_idx = c_idxs[:2]
+            o_idx = next(
+                i for i in atom_indices if mol.GetAtomWithIdx(i).GetSymbol() == "O"
+            )
+        except Exception as e:
+            return f"Error processing indices: {e}"
+
+        try:
+            emol.RemoveBond(c1_idx, c2_idx)
+            emol.RemoveBond(c2_idx, o_idx)
+            emol.AddBond(c1_idx, c2_idx, Chem.rdchem.BondType.SINGLE)
+            emol.AddBond(c2_idx, o_idx, 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: {e}"
+
+    @staticmethod
+    def standardize_hemiketal(smiles: str, atom_indices: List[int]) -> str:
+        """Convert a hemiketal tautomer into its corresponding carbonyl form.
+
+        :param smiles: SMILES string of the hemiketal-containing
+            molecule.
+        :type smiles: str
+        :param atom_indices: List of atom indices [C, O1, O2] defining
+            the hemiketal.
+        :type atom_indices: List[int]
+        :return: SMILES of the molecule after hemiketal→carbonyl
+            conversion, or an error message if the input is invalid.
+        :rtype: str
+        """
+        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"
+            )
+            o_idxs = [
+                i for i in atom_indices if mol.GetAtomWithIdx(i).GetSymbol() == "O"
+            ]
+            o1_idx = o_idxs[0]
+        except Exception as e:
+            return f"Error processing indices: {e}"
+
+        try:
+            emol.RemoveBond(c_idx, o1_idx)
+            if len(o_idxs) > 1:
+                emol.RemoveBond(c_idx, o_idxs[1])
+            emol.AddBond(c_idx, o1_idx, 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: {e}"
+
+    @staticmethod
+    def fix_smiles(smiles: str) -> str:
+        """Iteratively apply enol and hemiketal standardizations until no
+        further changes, then return the canonical SMILES.
+
+        :param smiles: SMILES string to standardize.
+        :type smiles: str
+        :return: Canonical SMILES of the standardized molecule.
+        :rtype: str
+        """
+        while True:
+            targets = Tautomerize._tautomer_targets(smiles)
+            if not targets:
+                break
+            label, indices = targets[0]
+            if label == "hemiketal":
+                smiles = Tautomerize.standardize_hemiketal(smiles, indices)
+            elif label == "enol":
+                smiles = Tautomerize.standardize_enol(smiles, indices)
+        return Chem.CanonSmiles(smiles)
+
+    @staticmethod
+    def _tautomer_targets(smiles: str) -> list[tuple[str, List[int]]]:
+        """Return RDKit-index targets used by the tautomer repair helpers."""
+        mol = Chem.MolFromSmiles(smiles)
+        if mol is None:
+            return []
+        graph, groups = smiles_to_graph_and_functional_groups(smiles)
+        node_to_idx = {
+            (
+                atom.GetAtomMapNum() if atom.GetAtomMapNum() else atom.GetIdx() + 1
+            ): atom.GetIdx()
+            for atom in mol.GetAtoms()
+        }
+
+        targets = [
+            (label, [node_to_idx[node] for node in nodes])
+            for label, nodes in groups
+            if label in {"hemiketal", "enol"}
+        ]
+        targets.extend(
+            ("hemiketal", [node_to_idx[node] for node in nodes])
+            for nodes in Tautomerize._geminal_diol_nodes(graph)
+        )
+        return targets
+
+    @staticmethod
+    def _geminal_diol_nodes(graph) -> list[tuple[int, ...]]:
+        """Legacy tautomerization compatibility for hydrated carbonyls."""
+        targets: list[tuple[int, ...]] = []
+        for carbon, data in graph.nodes(data=True):
+            if data.get("element") != "C":
+                continue
+            hydroxyls = [
+                neighbor
+                for neighbor in graph.neighbors(carbon)
+                if graph.nodes[neighbor].get("element") == "O"
+                and graph.nodes[neighbor].get("hcount", 0) >= 1
+                and graph.edges[carbon, neighbor].get("order") == 1.0
+            ]
+            if len(hydroxyls) >= 2:
+                targets.append((carbon, hydroxyls[0], hydroxyls[1]))
+        return targets
+
+    @staticmethod
+    def fix_dict(data: Dict[str, str], reaction_column: str) -> Dict[str, str]:
+        """Standardize the reactant and product SMILES in a reaction
+        dictionary.
+
+        :param data: Dictionary containing a reaction SMILES under `reaction_column`.
+        :type data: Dict[str, str]
+        :param reaction_column: Key in `data` where the reaction SMILES is stored.
+        :type reaction_column: str
+        :return: The same dictionary with standardized reaction SMILES.
+        :rtype: Dict[str, str]
+        """
+        try:
+            react, prod = data[reaction_column].split(">>")
+            data[reaction_column] = (
+                f"{Tautomerize.fix_smiles(react)}>>{Tautomerize.fix_smiles(prod)}"
+            )
+        except ValueError:
+            data[reaction_column] = Tautomerize.fix_smiles(data[reaction_column])
+        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]]:
+        """Standardize multiple reaction dictionaries in parallel.
+
+        :param data: List of dictionaries containing reaction SMILES under `reaction_column`.
+        :type data: List[Dict[str, str]]
+        :param reaction_column: Key in each dictionary for the reaction SMILES.
+        :type reaction_column: str
+        :param n_jobs: Number of parallel jobs to run. Defaults to 4.
+        :type n_jobs: int
+        :param verbose: Verbosity level for the joblib Parallel call. Defaults to 0.
+        :type verbose: int
+        :return: List of dictionaries with standardized SMILES.
+        :rtype: List[Dict[str, str]]
+        """
+        results = Parallel(n_jobs=n_jobs, verbose=verbose)(
+            delayed(Tautomerize.fix_dict)(d, reaction_column) for d in data
+        )
+        return results

synkit/Chem/__init__.py

@@ -0,0 +1 @@
+# from .Reaction import CanonRSMI, AAMValidator

synkit/Chem/utils.py

@@ -0,0 +1,315 @@
+from rdkit import Chem
+from rdkit.Chem.MolStandardize import rdMolStandardize
+from rdkit.Chem import rdChemReactions
+import re
+from typing import List, Optional, Tuple, Union
+
+
+def clean_radical_rsmi(rsmi: str) -> str:
+    """Load each side of a reaction SMILES (rSMI) into RDKit, split into disconnected fragments,
+    remove any fragment that contains an atom with nonzero radical electrons,
+    then reassemble back into a cleaned reaction SMILES.
+
+    :param rsmi: Reaction SMILES string, e.g.
+                 'A>>B.C'
+    :type rsmi: str
+    :return: Cleaned reaction SMILES with radical-containing fragments removed.
+    :rtype: str
+
+    .. rubric:: Examples
+
+    >>> clean_radical_rsmi(
+    ...   'COC(=O)C(CCCCNC(=O)OCc1ccccc1)NC(=O)Nc1cc(OC)cc(C(C)(C)C)c1O'
+    ...   '>>COC(=O)C(CCCCNC(=O)OCc1ccccc1)NC(N)=O.COc1c[c]c(O)c(C(C)(C)C)c1'
+    ... )
+    'COC(=O)C(CCCCNC(=O)OCc1ccccc1)NC(=O)Nc1cc(OC)cc(C(C)(C)C)c1O'
+    '>>COC(=O)C(CCCCNC(=O)OCc1ccccc1)NC(N)=O'
+    """
+    if ">>" not in rsmi:
+        return rsmi
+
+    def _clean_side(side: str) -> str:
+        mol = Chem.MolFromSmiles(side)
+        if mol is None:
+            return ""
+        frags = Chem.GetMolFrags(mol, asMols=True)
+        kept = []
+        for frag in frags:
+            if any(atom.GetNumRadicalElectrons() > 0 for atom in frag.GetAtoms()):
+                continue
+            kept.append(Chem.MolToSmiles(frag, isomericSmiles=True))
+        return ".".join(kept)
+
+    reac, prod = rsmi.split(">>", 1)
+    return f"{_clean_side(reac)}>>{_clean_side(prod)}"
+
+
+def enumerate_tautomers(reaction_smiles: str) -> Optional[List[str]]:
+    """Enumerate possible tautomers of reactants while canonicalizing products.
+
+    :param reaction_smiles: Reaction SMILES in 'reactants>>products'
+        format.
+    :type reaction_smiles: str
+    :return: List of reaction SMILES for each reactant tautomer
+        (including the original), or None on error.
+    :rtype: Optional[List[str]]
+    :raises ValueError: If reactant or product SMILES are invalid.
+    """
+    try:
+        reactants_smiles, products_smiles = reaction_smiles.split(">>")
+        reactants_mol = Chem.MolFromSmiles(reactants_smiles)
+        products_mol = Chem.MolFromSmiles(products_smiles)
+        if reactants_mol is None or products_mol is None:
+            raise ValueError("Invalid reactant or product SMILES.")
+        enumerator = rdMolStandardize.TautomerEnumerator()
+        reactants_tautos = enumerator.Enumerate(reactants_mol) or [reactants_mol]
+        prod_can = Chem.MolToSmiles(products_mol, canonical=True)
+        rsmi_list = [Chem.MolToSmiles(m) + ">>" + prod_can for m in reactants_tautos]
+        rsmi_list.insert(0, reaction_smiles)
+        return rsmi_list
+    except ValueError:
+        raise
+    except Exception:
+        return None
+
+
+def mapping_success_rate(list_mapping_data: List[str]) -> float:
+    """Calculate percentage of entries containing atom‑mapping annotations.
+
+    :param list_mapping_data: List of strings to search for mappings.
+    :type list_mapping_data: List[str]
+    :return: Percentage of entries containing `:<digits>` patterns,
+        rounded to two decimals.
+    :rtype: float
+    :raises ValueError: If input list is empty.
+    """
+    if not list_mapping_data:
+        raise ValueError("The input list is empty, cannot calculate success rate.")
+    pattern = re.compile(r":\d+")
+    success = sum(1 for entry in list_mapping_data if pattern.search(entry))
+    return round(100 * success / len(list_mapping_data), 2)
+
+
+def count_carbons(smiles: str) -> int:
+    """Count the number of carbon atoms in a molecule.
+
+    :param smiles: SMILES string of the molecule.
+    :type smiles: str
+    :return: Number of carbon atoms, or raises ValueError if SMILES
+        invalid.
+    :rtype: int
+    :raises ValueError: If the SMILES string is invalid.
+    """
+    mol = Chem.MolFromSmiles(smiles)
+    if mol is None:
+        raise ValueError(f"Invalid SMILES string: {smiles}")
+    return sum(1 for atom in mol.GetAtoms() if atom.GetSymbol() == "C")
+
+
+def get_max_fragment(smiles: Union[str, List[str]]) -> str:
+    """Return the largest fragment by atom count from SMILES.
+
+    :param smiles: SMILES string(s), possibly with '.' separators.
+    :type smiles: str or List[str]
+    :return: SMILES of the fragment with the most atoms, or empty
+        string if none valid.
+    :rtype: str
+    """
+    if isinstance(smiles, str):
+        fragments = smiles.split(".")
+    else:
+        fragments = [frag for s in smiles for frag in s.split(".")]
+    mols = [Chem.MolFromSmiles(f) for f in fragments if f]
+    mols = [m for m in mols if m]
+    if not mols:
+        return ""
+    max_mol = max(mols, key=lambda m: m.GetNumAtoms())
+    return Chem.MolToSmiles(max_mol)
+
+
+def filter_smiles(smiles_list: List[str], target_smiles: str) -> List[str]:
+    """Filter SMILES list to those containing carbon and not equal to a target.
+
+    :param smiles_list: List of SMILES strings to filter.
+    :type smiles_list: List[str]
+    :param target_smiles: SMILES string to exclude.
+    :type target_smiles: str
+    :return: Filtered list containing SMILES with at least one carbon atom
+              and not matching `target_smiles`.
+    :rtype: List[str]
+    """
+    target_mol = Chem.MolFromSmiles(target_smiles)
+    target_can = Chem.MolToSmiles(target_mol) if target_mol else ""
+    result: List[str] = []
+    for smi in smiles_list:
+        mol = Chem.MolFromSmiles(smi)
+        if mol and any(atom.GetSymbol() == "C" for atom in mol.GetAtoms()):
+            can = Chem.MolToSmiles(mol)
+            if can != target_can:
+                result.append(smi)
+    return result
+
+
+def remove_atom_mappings(mol: Chem.Mol) -> Chem.Mol:
+    """Strip atom‑mapping numbers from a molecule.
+
+    :param mol: RDKit Mol object.
+    :type mol: Chem.Mol
+    :return: The same Mol with all atom‑map numbers set to zero.
+    :rtype: Chem.Mol
+    """
+    for atom in mol.GetAtoms():
+        atom.SetAtomMapNum(0)
+    return mol
+
+
+def get_sanitized_smiles(smiles_list: List[str]) -> List[str]:
+    """Sanitize SMILES list by removing mappings and invalid entries.
+
+    :param smiles_list: List of SMILES strings to sanitize.
+    :type smiles_list: List[str]
+    :return: List of sanitized, isomeric SMILES of the largest
+        fragments only.
+    :rtype: List[str]
+    """
+    sanitized: List[str] = []
+    for smiles in smiles_list:
+        if "->" in smiles:
+            continue
+        mol = Chem.MolFromSmiles(smiles)
+        if not mol:
+            continue
+        mol = remove_atom_mappings(mol)
+        try:
+            Chem.SanitizeMol(mol)
+            sanitized.append(Chem.MolToSmiles(mol, isomericSmiles=True))
+        except Exception:
+            continue
+    # keep only the largest fragment across all
+    if sanitized:
+        sanitized = [get_max_fragment(sanitized)]
+    return sanitized
+
+
+def remove_duplicates(smiles_list: List[str]) -> List[str]:
+    """Remove duplicate strings from a list, preserving first occurrence.
+
+    :param smiles_list: List of strings (e.g., SMILES) possibly with
+        duplicates.
+    :type smiles_list: List[str]
+    :return: List with duplicates removed in original order.
+    :rtype: List[str]
+    """
+    seen = set()
+    unique: List[str] = []
+    for s in smiles_list:
+        if s not in seen:
+            unique.append(s)
+            seen.add(s)
+    return unique
+
+
+def process_smiles_list(smiles_list: List[str]) -> List[str]:
+    """Split dot‑connected SMILES into individual components.
+
+    :param smiles_list: List of SMILES strings, some containing '.'
+        separators.
+    :type smiles_list: List[str]
+    :return: Flattened list of component SMILES strings.
+    :rtype: List[str]
+    """
+    new_list: List[str] = []
+    for smiles in smiles_list:
+        if "." in smiles:
+            new_list.extend(smiles.split("."))
+        else:
+            new_list.append(smiles)
+    return new_list
+
+
+def remove_explicit_H_from_rsmi(rsmi: str) -> str:
+    """Remove explicit H atoms from a reaction SMILES, preserving AAM.
+
+    :param rsmi: Atom‑mapped reaction SMILES with explicit hydrogens.
+    :type rsmi: str
+    :return: Simplified reaction SMILES with implicit hydrogens.
+    :rtype: str
+    """
+    rxn = rdChemReactions.ReactionFromSmarts(rsmi, useSmiles=True)
+
+    def cleaned(mols):
+        return ".".join(
+            Chem.MolToSmiles(Chem.RemoveHs(m), isomericSmiles=True) for m in mols
+        )
+
+    react = cleaned(rxn.GetReactants())
+    prod = cleaned(rxn.GetProducts())
+    return f"{react}>>{prod}"
+
+
+def remove_common_reagents(reaction_smiles: str) -> Tuple[Optional[str], Optional[str]]:
+    """Remove reagents present on both sides of a reaction SMILES.
+
+    :param reaction_smiles: Reaction SMILES 'reactants>>products'.
+    :type reaction_smiles: str
+    :return: Tuple(cleaned_reaction, list_of_removed_reagents or None
+        if none found).
+    :rtype: Tuple[str, Optional[List[str]]]
+    """
+    reactants, products = reaction_smiles.split(">>")
+    reactant_list = reactants.split(".")
+    product_list = products.split(".")
+    common_reagents = set(reactant_list) & set(product_list)
+
+    filtered_reactants = [r for r in reactant_list if r not in common_reagents]
+    filtered_products = [p for p in product_list if p not in common_reagents]
+    cleaned_reaction_smiles = (
+        ".".join(filtered_reactants) + ">>" + ".".join(filtered_products)
+    )
+
+    return cleaned_reaction_smiles
+
+
+def reverse_reaction(rsmi: str) -> str:
+    """Reverse a reaction SMILES.
+
+    :param rsmi: Reaction SMILES 'reactants>>products'.
+    :type rsmi: str
+    :return: Reaction SMILES 'products>>reactants'.
+    :rtype: str
+    """
+    parts = rsmi.split(">>")
+    return f"{parts[1]}>>{parts[0]}" if len(parts) == 2 else rsmi
+
+
+def merge_reaction(rsmi_1: str, rsmi_2: str) -> Optional[str]:
+    """Merge two reaction SMILES into a single combined reaction.
+
+    :param rsmi_1: First reaction SMILES.
+    :type rsmi_1: str
+    :param rsmi_2: Second reaction SMILES.
+    :type rsmi_2: str
+    :return: Merged reaction SMILES or None if inputs invalid.
+    :rtype: Optional[str]
+    """
+    try:
+        r1, p1 = rsmi_1.split(">>")
+        r2, p2 = rsmi_2.split(">>")
+    except ValueError:
+        return None
+    if not all([r1, p1, r2, p2]):
+        return None
+    return f"{r1}.{r2}>>{p1}.{p2}"
+
+
+def find_longest_fragment(input_list: List[str]) -> Optional[str]:
+    """Find the longest string in a list.
+
+    :param input_list: List of strings to search.
+    :type input_list: List[str]
+    :return: Longest string or None if list empty.
+    :rtype: Optional[str]
+    """
+    if not input_list:
+        return None
+    return max(input_list, key=len)

synkit/Data/aldol.json.gz

@@ -0,0 +1 @@
+[{"R-id": "Mech-1", "reaction": "[CH3:1][CH:2]=[O:3].[CH:4]([H:7])([H:8])[CH:5]=[O:6]>>[CH3:1][CH:2]=[CH:4][CH:5]=[O:6].[O:3]([H:7])([H:8])", "mechanisms": [{"mech_name": "Aldol reaction (base cat)", "steps": [{"description": "Base abstracts H from substrate", "smart_string": "[CH:4]([H:7])([H:8])[CH:5]=[O:6].[*-:9]>>[CH-:4]([H:8])[CH:5]=[O:6].[*:9][H:7]", "step": 1, "step_gml": "rule [\n   ruleID \"2\"\n   left [\n   ]\n   context [\n   ]\n   right [\n   ]\n]", "step_dfs": null, "step_smart": ">>", "step_desc": "Base abstracts H from substrate"}, {"description": "Nucleophilic addition fro substrate", "smart_string": "[CH3:1][CH:2]=[O:3].[CH-:4]([H:8])[CH:5]=[O:6]>>[CH3:1][CH:2]([O-:3])[CH:4]([H:8])[CH:5]=[O:6]", "step": 2, "step_gml": "rule [\n   ruleID \"2\"\n   left [\n      edge [ source 1 target 2 label \"=\" ]\n      node [ id 2 label \"O\" ]\n      node [ id 3 label \"C-\" ]\n   ]\n   context [\n      node [ id 1 label \"C\" ]\n   ]\n   right [\n      edge [ source 1 target 2 label \"-\" ]\n      edge [ source 1 target 3 label \"-\" ]\n      node [ id 2 label \"O-\" ]\n      node [ id 3 label \"C\" ]\n   ]\n]", "step_dfs": null, "step_smart": "[CH2:1]=[O:2].[CH3-:3]>>[CH2:1]([O-:2])[CH3:3]", "step_desc": "Nucleophilic addition fro substrate"}, {"description": "Neutralize substrate", "smart_string": "[CH3:1][CH:2]([O-:3])[CH:4]([H:8])[CH:5]=[O:6].[*:9][H:7]>>[CH3:1][CH:2]([O:3][H:7])[CH:4]([H:8])[CH:5]=[O:6].[*-:9]", "step": 3, "step_gml": "rule [\n   ruleID \"2\"\n   left [\n   ]\n   context [\n   ]\n   right [\n   ]\n]", "step_dfs": null, "step_smart": ">>", "step_desc": "Neutralize substrate"}, {"description": "Base abstracts H from substrate", "smart_string": "[CH3:1][CH:2]([O:3][H:7])[CH:4]([H:8])[CH:5]=[O:6].[*-:9]>>[CH3:1][CH:2]([O:3][H:7])[CH-:4][CH:5]=[O:6].[*:9][H:8]", "step": 4, "step_gml": "rule [\n   ruleID \"2\"\n   left [\n   ]\n   context [\n   ]\n   right [\n   ]\n]", "step_dfs": null, "step_smart": ">>", "step_desc": "Base abstracts H from substrate"}, {"description": "Elimination Unimolecular Conjugate Base", "smart_string": "[CH3:1][CH:2]([O:3][H:7])[CH-:4][CH:5]=[O:6]>>[CH3:1][CH:2]=[CH:4][CH:5]=[O:6].[O-:3][H:7]", "step": 5, "step_gml": "rule [\n   ruleID \"2\"\n   left [\n      edge [ source 1 target 2 label \"-\" ]\n      edge [ source 1 target 3 label \"-\" ]\n      node [ id 2 label \"O\" ]\n      node [ id 3 label \"C-\" ]\n   ]\n   context [\n      node [ id 1 label \"C\" ]\n   ]\n   right [\n      edge [ source 1 target 3 label \"=\" ]\n      node [ id 2 label \"O-\" ]\n      node [ id 3 label \"C\" ]\n   ]\n]", "step_dfs": null, "step_smart": "[CH2:1]([OH:2])[CH2-:3]>>[CH2:1]=[CH2:3].[OH-:2]", "step_desc": "Elimination Unimolecular Conjugate Base"}, {"description": "Neutralize Hydroxide", "smart_string": "[O-:3][H:7].[*:9][H:8]>>[O:3]([H:7])([H:8]).[*-:9]", "step": 6, "step_gml": "rule [\n   ruleID \"2\"\n   left [\n   ]\n   context [\n   ]\n   right [\n   ]\n]", "step_dfs": null, "step_smart": ">>", "step_desc": "Neutralize Hydroxide"}], "cat": "[*-]"}, {"mech_name": "Aldol reaction (neutral cat)", "steps": [{"description": "Tautomerization of substrate", "smart_string": "[CH:4]([H:7])([H:8])[CH:5]=[O:6]>>[CH:4]([H:8])=[CH:5][O:6]([H:7])", "step": 1, "step_gml": "rule [\n   ruleID \"2\"\n   left [\n      edge [ source 1 target 2 label \"-\" ]\n      edge [ source 2 target 3 label \"=\" ]\n   ]\n   context [\n      node [ id 1 label \"C\" ]\n      node [ id 2 label \"C\" ]\n      node [ id 3 label \"O\" ]\n   ]\n   right [\n      edge [ source 1 target 2 label \"=\" ]\n      edge [ source 2 target 3 label \"-\" ]\n   ]\n]", "step_dfs": null, "step_smart": "[CH3:1][CH:2]=[O:3]>>[CH2:1]=[CH:2][OH:3]", "step_desc": "Tautomerization of substrate"}, {"description": "Nucleophilic addition from substrate", "smart_string": "[CH3:1][CH:2]=[O:3].[CH:4]([H:8])=[CH:5][O:6]([H:7])>>[CH3:1][CH:2]([O:3][H:7])[CH:4]([H:8])[CH:5]=[O:6]", "step": 2, "step_gml": "rule [\n   ruleID \"2\"\n   left [\n      edge [ source 1 target 2 label \"=\" ]\n      edge [ source 3 target 4 label \"=\" ]\n      edge [ source 4 target 5 label \"-\" ]\n   ]\n   context [\n      node [ id 1 label \"C\" ]\n      node [ id 2 label \"O\" ]\n      node [ id 3 label \"C\" ]\n      node [ id 4 label \"C\" ]\n      node [ id 5 label \"O\" ]\n   ]\n   right [\n      edge [ source 1 target 2 label \"-\" ]\n      edge [ source 1 target 3 label \"-\" ]\n      edge [ source 3 target 4 label \"-\" ]\n      edge [ source 4 target 5 label \"=\" ]\n   ]\n]", "step_dfs": null, "step_smart": "[CH2:1]=[O:2].[CH2:3]=[CH:4][OH:5]>>[CH2:1]([OH:2])[CH2:3][CH:4]=[O:5]", "step_desc": "Nucleophilic addition from substrate"}, {"description": "Tautomerization of substrate", "smart_string": "[CH3:1][CH:2]([O:3][H:7])[CH:4]([H:8])[CH:5]=[O:6]>>[CH3:1][CH:2]([O:3][H:7])[CH:4]=[CH:5][O:6]([H:8])", "step": 3, "step_gml": "rule [\n   ruleID \"2\"\n   left [\n      edge [ source 1 target 2 label \"-\" ]\n      edge [ source 2 target 3 label \"=\" ]\n   ]\n   context [\n      node [ id 1 label \"C\" ]\n      node [ id 2 label \"C\" ]\n      node [ id 3 label \"O\" ]\n   ]\n   right [\n      edge [ source 1 target 2 label \"=\" ]\n      edge [ source 2 target 3 label \"-\" ]\n   ]\n]", "step_dfs": null, "step_smart": "[CH3:1][CH:2]=[O:3]>>[CH2:1]=[CH:2][OH:3]", "step_desc": "Tautomerization of substrate"}, {"description": "Elimination", "smart_string": "[CH3:1][CH:2]([O:3][H:7])[CH:4]=[CH:5][O:6]([H:8])>>[CH3:1][CH:2]=[CH:4][CH:5]=[O:6].[O:3]([H:7])([H:8])", "step": 4, "step_gml": "rule [\n   ruleID \"2\"\n   left [\n      edge [ source 1 target 2 label \"-\" ]\n      edge [ source 1 target 3 label \"-\" ]\n      edge [ source 3 target 4 label \"=\" ]\n      edge [ source 4 target 5 label \"-\" ]\n   ]\n   context [\n      node [ id 1 label \"C\" ]\n      node [ id 2 label \"O\" ]\n      node [ id 3 label \"C\" ]\n      node [ id 4 label \"C\" ]\n      node [ id 5 label \"O\" ]\n   ]\n   right [\n      edge [ source 1 target 3 label \"=\" ]\n      edge [ source 3 target 4 label \"-\" ]\n      edge [ source 4 target 5 label \"=\" ]\n   ]\n]", "step_dfs": null, "step_smart": "[CH2:1]([OH:2])[CH:3]=[CH:4][OH:5]>>[CH2:1]=[CH:3][CH:4]=[O:5].[OH2:2]", "step_desc": "Elimination"}], "cat": ""}, {"mech_name": "Aldol reaction (acid cat)", "steps": [{"description": "Tautomerization of substrate with acid cat", "smart_string": "[CH:4]([H:7])([H:8])[CH:5]=[O:6].[H+:9]>>[CH:4]([H:8])=[CH:5][O:6]([H:9]).[H+:7]", "step": 1}, {"description": "Nucleophilic addition from substrate", "smart_string": "[CH3:1][CH:2]=[O:3].[CH:4]([H:8])=[CH:5][O:6]([H:9]).[H+:7]>>[CH3:1][CH:2]([O:3][H:7])[CH:4]([H:8])[CH:5]=[O:6].[H+:9]", "step": 2}, {"description": "Tautomerization of substrate with acid cat", "smart_string": "[CH3:1][CH:2]([O:3][H:7])[CH:4]([H:8])[CH:5]=[O:6].[H+:9]>>[CH3:1][CH:2]([O:3][H:7])[CH:4]=[CH:5][O:6]([H:9]).[H+:8]", "step": 3}, {"description": "Elimination", "smart_string": "[CH3:1][CH:2]([O:3][H:7])[CH:4]=[CH:5][O:6]([H:9]).[H+:8]>>[CH3:1][CH:2]=[CH:4][CH:5]=[O:6].[H+:9].[O:3]([H:7])([H:8])", "step": 4}], "cat": "[H+]"}]}]

synkit/Data/gen_partial_aam.py

@@ -0,0 +1,147 @@
+from rdkit import Chem
+from typing import Optional
+
+from synkit.IO.graph_to_mol import GraphToMol
+from synkit.Graph.ITS.its_construction import ITSConstruction
+from synkit.Graph.ITS.its_decompose import get_rc
+from synkit.IO.chem_converter import smiles_to_graph
+
+
+def _get_partial_aam(smart: str) -> str:
+    """Generate a partial atom‐atom mapping (AAM) SMILES string from a reactant
+    SMARTS.
+
+    This function:
+      1. Parses the forward (“reactant”) and backward (“product”) halves of `smart`.
+      2. Builds RDKit graphs (with atom_map indices) for each side.
+      3. Constructs the integrated transition state (ITS) graph.
+      4. Identifies the reactant core (rc) subgraph.
+      5. Zeroes out `atom_map` on any atom not in the reactant core.
+      6. Converts the modified graphs to RDKit Mol objects (respecting H‐counts).
+      7. Emits SMILES for the “retained” and “partial” graphs, joined with '>>'.
+
+    :param smart: A reaction SMARTS of the form "R>>P".
+    :type smart: str
+    :return: An unbalanced, partial‐AAM reaction SMILES "retained>>partial".
+    :rtype: str
+    :raises RuntimeError:
+        If graph decomposition, molecule conversion, or SMILES generation fails.
+    """
+    # split into reactant/product SMARTS
+    r_smi, p_smi = smart.split(">>")
+    # build graphs with atom_map indices from the SMILES strings
+    r_graph = smiles_to_graph(r_smi, use_index_as_atom_map=True)
+    p_graph = smiles_to_graph(p_smi, use_index_as_atom_map=True)
+
+    # construct and decompose ITS
+    its = ITSConstruction.ITSGraph(r_graph, p_graph)
+    rc = get_rc(its)
+    rc_nodes = set(rc.nodes())
+
+    # zero out maps for atoms not in the reactant core
+    for node in r_graph.nodes():
+        if node not in rc_nodes:
+            r_graph.nodes[node]["atom_map"] = 0
+    for node in p_graph.nodes():
+        if node not in rc_nodes:
+            p_graph.nodes[node]["atom_map"] = 0
+
+    converter = GraphToMol()
+    try:
+        retained_mol = converter.graph_to_mol(r_graph, use_h_count=True)
+        partial_mol = converter.graph_to_mol(p_graph, use_h_count=True)
+    except Exception as e:
+        raise RuntimeError(f"Error converting graphs to molecules: {e}") from e
+
+    try:
+        retained_smiles = Chem.MolToSmiles(retained_mol)
+        partial_smiles = Chem.MolToSmiles(partial_mol)
+    except Exception as e:
+        raise RuntimeError(f"Error generating SMILES: {e}") from e
+
+    return f"{retained_smiles}>>{partial_smiles}"
+
+
+def _remove_small_smiles(smiles: str) -> str:
+    """Return the canonical SMILES of the largest fragment from an input
+    SMILES.
+
+    This function:
+      1. Parses `smiles` to an RDKit Mol without sanitization.
+      2. Sanitizes the Mol.
+      3. Splits into fragments, picks the one with the most heavy atoms.
+      4. Sanitizes that fragment and returns its canonical SMILES.
+
+    :param smiles: The input SMILES string.
+    :type smiles: str
+    :return: Canonical SMILES of the largest fragment.
+    :rtype: str
+    :raises ValueError:
+        - If `smiles` is invalid.
+        - If sanitization of the whole or fragment fails.
+        - If no fragments are found.
+    """
+    mol: Optional[Chem.Mol] = Chem.MolFromSmiles(smiles, sanitize=False)
+    if mol is None:
+        raise ValueError(f"Invalid SMILES string: '{smiles}'")
+
+    try:
+        Chem.SanitizeMol(mol)
+    except Exception as e:
+        raise ValueError(f"Sanitization failed for '{smiles}': {e}")
+
+    fragments = Chem.GetMolFrags(mol, asMols=True, sanitizeFrags=False)
+    if not fragments:
+        raise ValueError(f"No fragments found for SMILES '{smiles}'")
+
+    largest = max(fragments, key=lambda m: m.GetNumHeavyAtoms())
+
+    try:
+        Chem.SanitizeMol(largest)
+    except Exception as e:
+        raise ValueError(f"Sanitization failed for largest fragment: {e}")
+
+    return Chem.MolToSmiles(largest)
+
+
+def _create_unbalanced_aam(rsmi: str, side: str = "right") -> str:
+    """Produce an unbalanced AAM reaction SMILES by keeping only the largest
+    fragment on the specified side(s) of the reaction.
+
+    :param rsmi: A reaction SMILES "reactant>>product".
+    :type rsmi: str
+    :param side:
+        Which side(s) to process:
+        - "left" : clean only the reactant side,
+        - "right": clean only the product side,
+        - "both" : clean both sides.
+    :type side: str
+    :return: A new reaction SMILES "reactant>>product" with small fragments removed.
+    :rtype: str
+    :raises ValueError:
+      - If `rsmi` doesn’t contain exactly one ">>".
+      - If `side` is not one of "left", "right", "both".
+      - If fragment processing fails on the chosen side(s).
+    """
+    parts = [p.strip() for p in rsmi.split(">>")]
+    if len(parts) != 2:
+        raise ValueError(f"Expected single '>>' in reaction SMILES: '{rsmi}'")
+
+    r_smi, p_smi = parts
+    side_l = side.lower()
+    if side_l not in ("left", "right", "both"):
+        raise ValueError(f"Invalid side '{side}'; must be 'left', 'right', or 'both'")
+
+    if side_l in ("left", "both"):
+        try:
+            r_smi = _remove_small_smiles(r_smi)
+        except Exception as e:
+            raise ValueError(f"Error processing left side: {e}")
+
+    if side_l in ("right", "both"):
+        try:
+            p_smi = _remove_small_smiles(p_smi)
+        except Exception as e:
+            raise ValueError(f"Error processing right side: {e}")
+
+    return f"{r_smi}>>{p_smi}"