rdkit-cli 0.1.0__py3-none-any.whl

rdkit_cli/core/fragment.py

@@ -0,0 +1,237 @@
+"""Molecular fragmentation engine."""
+
+from typing import Optional, Any
+from collections import Counter
+
+from rdkit import Chem
+from rdkit.Chem import BRICS, Recap, AllChem, rdMolDescriptors
+
+from rdkit_cli.io.readers import MoleculeRecord
+
+
+class BRICSFragmenter:
+    """Fragment molecules using BRICS algorithm."""
+
+    def __init__(
+        self,
+        min_fragment_size: int = 1,
+        include_smiles: bool = True,
+        include_name: bool = True,
+    ):
+        """
+        Initialize BRICS fragmenter.
+
+        Args:
+            min_fragment_size: Minimum fragment heavy atom count
+            include_smiles: Include original SMILES in output
+            include_name: Include molecule name in output
+        """
+        self.min_fragment_size = min_fragment_size
+        self.include_smiles = include_smiles
+        self.include_name = include_name
+
+    def fragment(self, record: MoleculeRecord) -> list[dict[str, Any]]:
+        """
+        Fragment a molecule using BRICS.
+
+        Args:
+            record: MoleculeRecord to process
+
+        Returns:
+            List of dictionaries with fragment SMILES
+        """
+        if record.mol is None:
+            return []
+
+        try:
+            fragments = BRICS.BRICSDecompose(record.mol)
+
+            results = []
+            for i, frag_smi in enumerate(fragments):
+                # Parse fragment to check size
+                frag_mol = Chem.MolFromSmiles(frag_smi)
+                if frag_mol is None:
+                    continue
+
+                heavy_atoms = frag_mol.GetNumHeavyAtoms()
+                if heavy_atoms < self.min_fragment_size:
+                    continue
+
+                result: dict[str, Any] = {"fragment_smiles": frag_smi}
+
+                if self.include_smiles:
+                    result["smiles"] = record.smiles
+                if self.include_name and record.name:
+                    result["name"] = record.name
+
+                result["fragment_idx"] = i
+                result["heavy_atom_count"] = heavy_atoms
+
+                results.append(result)
+
+            return results
+
+        except Exception:
+            return []
+
+
+class RECAPFragmenter:
+    """Fragment molecules using RECAP algorithm."""
+
+    def __init__(
+        self,
+        min_fragment_size: int = 1,
+        include_smiles: bool = True,
+        include_name: bool = True,
+    ):
+        """
+        Initialize RECAP fragmenter.
+
+        Args:
+            min_fragment_size: Minimum fragment heavy atom count
+            include_smiles: Include original SMILES in output
+            include_name: Include molecule name in output
+        """
+        self.min_fragment_size = min_fragment_size
+        self.include_smiles = include_smiles
+        self.include_name = include_name
+
+    def fragment(self, record: MoleculeRecord) -> list[dict[str, Any]]:
+        """
+        Fragment a molecule using RECAP.
+
+        Args:
+            record: MoleculeRecord to process
+
+        Returns:
+            List of dictionaries with fragment SMILES
+        """
+        if record.mol is None:
+            return []
+
+        try:
+            recap_tree = Recap.RecapDecompose(record.mol)
+            leaves = recap_tree.GetLeaves()
+
+            results = []
+            for i, (frag_smi, node) in enumerate(leaves.items()):
+                # Parse fragment to check size
+                frag_mol = node.mol
+                if frag_mol is None:
+                    continue
+
+                heavy_atoms = frag_mol.GetNumHeavyAtoms()
+                if heavy_atoms < self.min_fragment_size:
+                    continue
+
+                result: dict[str, Any] = {"fragment_smiles": frag_smi}
+
+                if self.include_smiles:
+                    result["smiles"] = record.smiles
+                if self.include_name and record.name:
+                    result["name"] = record.name
+
+                result["fragment_idx"] = i
+                result["heavy_atom_count"] = heavy_atoms
+
+                results.append(result)
+
+            return results
+
+        except Exception:
+            return []
+
+
+class FunctionalGroupExtractor:
+    """Extract functional groups from molecules."""
+
+    def __init__(
+        self,
+        include_smiles: bool = True,
+        include_name: bool = True,
+    ):
+        """
+        Initialize functional group extractor.
+
+        Args:
+            include_smiles: Include original SMILES in output
+            include_name: Include molecule name in output
+        """
+        self.include_smiles = include_smiles
+        self.include_name = include_name
+        # Use RDKit's functional group hierarchy
+        self._fgs = rdMolDescriptors.GetMorganFingerprint
+
+    def extract(self, record: MoleculeRecord) -> Optional[dict[str, Any]]:
+        """
+        Extract functional groups from a molecule.
+
+        Args:
+            record: MoleculeRecord to process
+
+        Returns:
+            Dictionary with functional group info or None
+        """
+        if record.mol is None:
+            return None
+
+        try:
+            # Get functional groups using SMARTS patterns
+            fg_patterns = {
+                "alcohol": "[OX2H]",
+                "aldehyde": "[CX3H1](=O)[#6]",
+                "ketone": "[#6][CX3](=O)[#6]",
+                "carboxylic_acid": "[CX3](=O)[OX2H1]",
+                "ester": "[#6][CX3](=O)[OX2][#6]",
+                "ether": "[OD2]([#6])[#6]",
+                "amine_primary": "[NX3H2][#6]",
+                "amine_secondary": "[NX3H1]([#6])[#6]",
+                "amine_tertiary": "[NX3]([#6])([#6])[#6]",
+                "amide": "[NX3][CX3](=[OX1])[#6]",
+                "nitro": "[$([NX3](=O)=O),$([NX3+](=O)[O-])]",
+                "nitrile": "[NX1]#[CX2]",
+                "halogen": "[F,Cl,Br,I]",
+                "thiol": "[SX2H]",
+                "sulfide": "[#16X2]([#6])[#6]",
+                "aromatic_ring": "a1aaaaa1",
+            }
+
+            result: dict[str, Any] = {}
+
+            if self.include_smiles:
+                result["smiles"] = record.smiles
+            if self.include_name and record.name:
+                result["name"] = record.name
+
+            for name, smarts in fg_patterns.items():
+                pattern = Chem.MolFromSmarts(smarts)
+                if pattern:
+                    matches = record.mol.GetSubstructMatches(pattern)
+                    result[f"n_{name}"] = len(matches)
+
+            return result
+
+        except Exception:
+            return None
+
+
+def analyze_fragments(fragments: list[str], top_n: int = 20) -> list[tuple[str, int, float]]:
+    """
+    Analyze fragment frequency distribution.
+
+    Args:
+        fragments: List of fragment SMILES
+        top_n: Number of top fragments to return
+
+    Returns:
+        List of (fragment, count, percentage) tuples
+    """
+    total = len(fragments)
+    counter = Counter(fragments)
+
+    results = []
+    for frag, count in counter.most_common(top_n):
+        percentage = (count / total) * 100 if total > 0 else 0
+        results.append((frag, count, round(percentage, 2)))
+
+    return results

rdkit_cli/core/mcs.py

@@ -0,0 +1,128 @@
+"""Maximum Common Substructure engine."""
+
+from typing import Optional, Any
+
+from rdkit import Chem
+from rdkit.Chem import rdFMCS
+
+
+def find_mcs(
+    mols: list[Chem.Mol],
+    timeout: int = 60,
+    threshold: float = 1.0,
+    maximize: str = "atoms",
+    ring_matches_ring_only: bool = True,
+    complete_rings_only: bool = True,
+    match_valences: bool = False,
+    match_chiral_tag: bool = False,
+    atom_compare: str = "elements",
+    bond_compare: str = "order",
+) -> Optional[dict[str, Any]]:
+    """
+    Find Maximum Common Substructure of molecules.
+
+    Args:
+        mols: List of molecules
+        timeout: Maximum time in seconds
+        threshold: Fraction of molecules that must contain MCS
+        maximize: What to maximize ('atoms' or 'bonds')
+        ring_matches_ring_only: Ring atoms only match ring atoms
+        complete_rings_only: Only return complete rings
+        match_valences: Match atom valences
+        match_chiral_tag: Match chirality
+        atom_compare: Atom comparison ('any', 'elements', 'isotopes')
+        bond_compare: Bond comparison ('any', 'order', 'orderexact')
+
+    Returns:
+        Dictionary with MCS results or None
+    """
+    # Filter None molecules
+    valid_mols = [mol for mol in mols if mol is not None]
+
+    if len(valid_mols) < 2:
+        return None
+
+    # Set up atom comparison
+    atom_compare_map = {
+        "any": rdFMCS.AtomCompare.CompareAny,
+        "elements": rdFMCS.AtomCompare.CompareElements,
+        "isotopes": rdFMCS.AtomCompare.CompareIsotopes,
+    }
+
+    # Set up bond comparison
+    bond_compare_map = {
+        "any": rdFMCS.BondCompare.CompareAny,
+        "order": rdFMCS.BondCompare.CompareOrder,
+        "orderexact": rdFMCS.BondCompare.CompareOrderExact,
+    }
+
+    try:
+        result = rdFMCS.FindMCS(
+            valid_mols,
+            timeout=timeout,
+            threshold=threshold,
+            maximizeBonds=(maximize == "bonds"),
+            ringMatchesRingOnly=ring_matches_ring_only,
+            completeRingsOnly=complete_rings_only,
+            matchValences=match_valences,
+            matchChiralTag=match_chiral_tag,
+            atomCompare=atom_compare_map.get(atom_compare, rdFMCS.AtomCompare.CompareElements),
+            bondCompare=bond_compare_map.get(bond_compare, rdFMCS.BondCompare.CompareOrder),
+        )
+
+        if result.canceled:
+            return {"canceled": True, "timeout": timeout}
+
+        if result.numAtoms == 0:
+            return {"smarts": "", "num_atoms": 0, "num_bonds": 0}
+
+        return {
+            "smarts": result.smartsString,
+            "num_atoms": result.numAtoms,
+            "num_bonds": result.numBonds,
+            "canceled": result.canceled,
+        }
+
+    except Exception as e:
+        return {"error": str(e)}
+
+
+class MCSAligner:
+    """Align molecules based on MCS."""
+
+    def __init__(
+        self,
+        reference_smiles: str,
+        timeout: int = 30,
+    ):
+        """
+        Initialize MCS aligner.
+
+        Args:
+            reference_smiles: Reference molecule SMILES
+            timeout: MCS timeout in seconds
+        """
+        self.reference_mol = Chem.MolFromSmiles(reference_smiles)
+        if self.reference_mol is None:
+            raise ValueError(f"Invalid reference SMILES: {reference_smiles}")
+        self.timeout = timeout
+
+    def find_common(self, mol: Chem.Mol) -> Optional[dict[str, Any]]:
+        """
+        Find MCS between reference and query molecule.
+
+        Args:
+            mol: Query molecule
+
+        Returns:
+            Dictionary with MCS info or None
+        """
+        if mol is None:
+            return None
+
+        result = find_mcs(
+            [self.reference_mol, mol],
+            timeout=self.timeout,
+        )
+
+        return result

rdkit_cli/core/reactions.py

@@ -0,0 +1,159 @@
+"""Reaction transformation engine."""
+
+from typing import Optional, Any
+
+from rdkit import Chem
+from rdkit.Chem import AllChem, rdChemReactions
+
+from rdkit_cli.io.readers import MoleculeRecord
+
+
+class ReactionTransformer:
+    """Apply SMIRKS transformations to molecules."""
+
+    def __init__(
+        self,
+        smirks: str,
+        max_products: int = 100,
+    ):
+        """
+        Initialize reaction transformer.
+
+        Args:
+            smirks: SMIRKS reaction pattern
+            max_products: Maximum number of products to generate
+        """
+        self.reaction = AllChem.ReactionFromSmarts(smirks)
+        if self.reaction is None:
+            raise ValueError(f"Invalid SMIRKS pattern: {smirks}")
+
+        self.max_products = max_products
+
+    def transform(self, record: MoleculeRecord) -> Optional[dict[str, Any]]:
+        """
+        Apply transformation to a molecule.
+
+        Args:
+            record: MoleculeRecord to transform
+
+        Returns:
+            Dictionary with products or None if no reaction
+        """
+        if record.mol is None:
+            return None
+
+        try:
+            products = self.reaction.RunReactants((record.mol,))
+
+            if not products:
+                return None
+
+            # Collect unique products
+            unique_smiles = set()
+            for product_set in products[:self.max_products]:
+                for prod in product_set:
+                    try:
+                        Chem.SanitizeMol(prod)
+                        smi = Chem.MolToSmiles(prod)
+                        unique_smiles.add(smi)
+                    except Exception:
+                        continue
+
+            if not unique_smiles:
+                return None
+
+            # Return first product (or could return all)
+            product_smiles = list(unique_smiles)[0]
+
+            result: dict[str, Any] = {
+                "smiles": product_smiles,
+                "reactant": record.smiles,
+                "num_products": len(unique_smiles),
+            }
+
+            if record.name:
+                result["name"] = record.name
+
+            return result
+
+        except Exception:
+            return None
+
+
+class ReactionEnumerator:
+    """Enumerate products from reaction templates."""
+
+    def __init__(
+        self,
+        reaction_smarts: str,
+        max_products: int = 1000,
+    ):
+        """
+        Initialize reaction enumerator.
+
+        Args:
+            reaction_smarts: Reaction SMARTS
+            max_products: Maximum products to generate
+        """
+        self.reaction = AllChem.ReactionFromSmarts(reaction_smarts)
+        if self.reaction is None:
+            raise ValueError(f"Invalid reaction SMARTS: {reaction_smarts}")
+
+        self.max_products = max_products
+        self.num_reactants = self.reaction.GetNumReactantTemplates()
+
+    def enumerate(
+        self,
+        reactant_lists: list[list[Chem.Mol]],
+    ) -> list[dict[str, Any]]:
+        """
+        Enumerate reaction products from lists of reactants.
+
+        Args:
+            reactant_lists: List of reactant lists (one per reactant template)
+
+        Returns:
+            List of product dictionaries
+        """
+        if len(reactant_lists) != self.num_reactants:
+            raise ValueError(
+                f"Expected {self.num_reactants} reactant lists, got {len(reactant_lists)}"
+            )
+
+        results = []
+        unique_products = set()
+
+        # Generate all combinations
+        from itertools import product as iterproduct
+
+        for reactants in iterproduct(*reactant_lists):
+            if len(results) >= self.max_products:
+                break
+
+            try:
+                products = self.reaction.RunReactants(reactants)
+
+                for product_set in products:
+                    for prod in product_set:
+                        try:
+                            Chem.SanitizeMol(prod)
+                            smi = Chem.MolToSmiles(prod)
+
+                            if smi not in unique_products:
+                                unique_products.add(smi)
+                                results.append({
+                                    "smiles": smi,
+                                    "reactants": ".".join(
+                                        Chem.MolToSmiles(r) for r in reactants
+                                    ),
+                                })
+
+                                if len(results) >= self.max_products:
+                                    break
+                        except Exception:
+                            continue
+
+            except Exception:
+                continue
+
+        return results

rdkit_cli/core/scaffold.py

@@ -0,0 +1,174 @@
+"""Scaffold analysis engine."""
+
+from typing import Optional, Any
+from collections import Counter
+
+from rdkit import Chem
+from rdkit.Chem.Scaffolds import MurckoScaffold
+
+from rdkit_cli.io.readers import MoleculeRecord
+
+
+def get_murcko_scaffold(mol: Chem.Mol, generic: bool = False) -> Optional[str]:
+    """
+    Get Murcko scaffold for a molecule.
+
+    Args:
+        mol: RDKit molecule
+        generic: If True, return generic scaffold (element-agnostic)
+
+    Returns:
+        Scaffold SMILES or None if failed
+    """
+    try:
+        core = MurckoScaffold.GetScaffoldForMol(mol)
+
+        if generic:
+            core = MurckoScaffold.MakeScaffoldGeneric(core)
+
+        return Chem.MolToSmiles(core)
+    except Exception:
+        return None
+
+
+def get_side_chains(mol: Chem.Mol) -> list[str]:
+    """
+    Get side chains (R-groups) for a molecule.
+
+    Args:
+        mol: RDKit molecule
+
+    Returns:
+        List of side chain SMILES
+    """
+    try:
+        side_chains = MurckoScaffold.MurckoDecompose(mol)
+        return [Chem.MolToSmiles(sc) for sc in side_chains if sc is not None]
+    except Exception:
+        return []
+
+
+class ScaffoldExtractor:
+    """Extract Murcko scaffolds from molecules."""
+
+    def __init__(
+        self,
+        generic: bool = False,
+        include_smiles: bool = True,
+        include_name: bool = True,
+    ):
+        """
+        Initialize scaffold extractor.
+
+        Args:
+            generic: Generate generic (element-agnostic) scaffolds
+            include_smiles: Include original SMILES in output
+            include_name: Include molecule name in output
+        """
+        self.generic = generic
+        self.include_smiles = include_smiles
+        self.include_name = include_name
+
+    def extract(self, record: MoleculeRecord) -> Optional[dict[str, Any]]:
+        """
+        Extract scaffold from a molecule.
+
+        Args:
+            record: MoleculeRecord to process
+
+        Returns:
+            Dictionary with scaffold info or None if failed
+        """
+        if record.mol is None:
+            return None
+
+        scaffold = get_murcko_scaffold(record.mol, generic=self.generic)
+
+        if scaffold is None:
+            return None
+
+        result: dict[str, Any] = {}
+
+        if self.include_smiles:
+            result["smiles"] = record.smiles
+        if self.include_name and record.name:
+            result["name"] = record.name
+
+        result["scaffold"] = scaffold
+
+        return result
+
+
+class ScaffoldDecomposer:
+    """Decompose molecules into scaffold and side chains."""
+
+    def __init__(
+        self,
+        include_smiles: bool = True,
+        include_name: bool = True,
+    ):
+        """
+        Initialize scaffold decomposer.
+
+        Args:
+            include_smiles: Include original SMILES in output
+            include_name: Include molecule name in output
+        """
+        self.include_smiles = include_smiles
+        self.include_name = include_name
+
+    def decompose(self, record: MoleculeRecord) -> Optional[dict[str, Any]]:
+        """
+        Decompose a molecule into scaffold and side chains.
+
+        Args:
+            record: MoleculeRecord to process
+
+        Returns:
+            Dictionary with decomposition info or None if failed
+        """
+        if record.mol is None:
+            return None
+
+        scaffold = get_murcko_scaffold(record.mol)
+        if scaffold is None:
+            return None
+
+        generic_scaffold = get_murcko_scaffold(record.mol, generic=True)
+
+        result: dict[str, Any] = {}
+
+        if self.include_smiles:
+            result["smiles"] = record.smiles
+        if self.include_name and record.name:
+            result["name"] = record.name
+
+        result["scaffold"] = scaffold
+        result["generic_scaffold"] = generic_scaffold
+
+        return result
+
+
+def analyze_scaffolds(
+    scaffolds: list[str],
+    top_n: int = 20,
+) -> list[tuple[str, int, float]]:
+    """
+    Analyze scaffold frequency distribution.
+
+    Args:
+        scaffolds: List of scaffold SMILES
+        top_n: Number of top scaffolds to return
+
+    Returns:
+        List of (scaffold, count, percentage) tuples
+    """
+    total = len(scaffolds)
+    counter = Counter(scaffolds)
+
+    results = []
+    for scaffold, count in counter.most_common(top_n):
+        percentage = (count / total) * 100 if total > 0 else 0
+        results.append((scaffold, count, round(percentage, 2)))
+
+    return results