rdkit-cli 0.1.0__py3-none-any.whl

rdkit_cli/core/descriptors.py

@@ -0,0 +1,248 @@
+"""Molecular descriptor computation engine."""
+
+from dataclasses import dataclass
+from typing import Optional, Any
+
+from rdkit import Chem
+from rdkit.Chem import Descriptors, rdMolDescriptors, QED
+
+from rdkit_cli.io.readers import MoleculeRecord
+
+
+# Descriptor categories
+DESCRIPTOR_CATEGORIES = [
+    "constitutional",
+    "topological",
+    "electronic",
+    "geometric",
+    "molecular",
+]
+
+
+@dataclass
+class DescriptorInfo:
+    """Information about a descriptor."""
+
+    name: str
+    description: str
+    category: str
+
+
+# Build descriptor registry from RDKit
+def _build_descriptor_registry() -> dict[str, tuple[callable, str, str]]:
+    """Build registry of all available descriptors."""
+    registry = {}
+
+    # Get all descriptors from Descriptors module
+    for name, func in Descriptors.descList:
+        # Categorize based on name patterns
+        category = "molecular"
+        lower_name = name.lower()
+
+        if any(x in lower_name for x in ["chi", "kappa", "hall", "balaban", "bertz"]):
+            category = "topological"
+        elif any(x in lower_name for x in ["tpsa", "labute", "peoe", "gasteiger"]):
+            category = "electronic"
+        elif any(x in lower_name for x in ["num", "count", "heavy", "ring", "rotatable"]):
+            category = "constitutional"
+        elif any(x in lower_name for x in ["mol", "exact", "weight", "logp", "mr"]):
+            category = "molecular"
+
+        registry[name] = (func, f"RDKit descriptor: {name}", category)
+
+    return registry
+
+
+DESCRIPTOR_REGISTRY = _build_descriptor_registry()
+
+# Add QED (not in Descriptors.descList)
+DESCRIPTOR_REGISTRY["QED"] = (QED.qed, "Quantitative Estimate of Drug-likeness", "molecular")
+
+
+def compute_lipinski_violations(mol: Chem.Mol) -> int:
+    """
+    Count Lipinski Rule of 5 violations.
+
+    Args:
+        mol: RDKit molecule
+
+    Returns:
+        Number of violations (0-4)
+    """
+    violations = 0
+
+    if Descriptors.MolWt(mol) > 500:
+        violations += 1
+    if Descriptors.MolLogP(mol) > 5:
+        violations += 1
+    if Descriptors.NumHDonors(mol) > 5:
+        violations += 1
+    if Descriptors.NumHAcceptors(mol) > 10:
+        violations += 1
+
+    return violations
+
+
+def list_descriptors(
+    category: Optional[str] = None,
+    verbose: bool = False,
+) -> list[DescriptorInfo]:
+    """
+    List available descriptors.
+
+    Args:
+        category: Filter by category
+        verbose: Include descriptions
+
+    Returns:
+        List of DescriptorInfo objects
+    """
+    result = []
+
+    for name, (func, desc, cat) in sorted(DESCRIPTOR_REGISTRY.items()):
+        if category is None or cat == category:
+            result.append(DescriptorInfo(name=name, description=desc, category=cat))
+
+    return result
+
+
+def compute_descriptor(mol: Chem.Mol, name: str) -> Optional[float]:
+    """
+    Compute a single descriptor for a molecule.
+
+    Args:
+        mol: RDKit molecule
+        name: Descriptor name
+
+    Returns:
+        Descriptor value or None if computation failed
+    """
+    if name not in DESCRIPTOR_REGISTRY:
+        raise ValueError(f"Unknown descriptor: {name}")
+
+    func = DESCRIPTOR_REGISTRY[name][0]
+
+    try:
+        value = func(mol)
+        # Handle NaN and inf
+        if value is None or (isinstance(value, float) and (value != value or abs(value) == float("inf"))):
+            return None
+        return float(value)
+    except Exception:
+        return None
+
+
+class DescriptorCalculator:
+    """Calculator for molecular descriptors."""
+
+    def __init__(
+        self,
+        descriptors: Optional[list[str]] = None,
+        include_smiles: bool = True,
+        include_name: bool = True,
+        precision: int = 4,
+        error_value: str = "NaN",
+    ):
+        """
+        Initialize descriptor calculator.
+
+        Args:
+            descriptors: List of descriptor names (None for all)
+            include_smiles: Include SMILES in output
+            include_name: Include molecule name in output
+            precision: Decimal precision for float values
+            error_value: Value to use for failed calculations
+        """
+        if descriptors is None:
+            self.descriptors = list(DESCRIPTOR_REGISTRY.keys())
+        else:
+            # Validate descriptor names
+            unknown = set(descriptors) - set(DESCRIPTOR_REGISTRY.keys())
+            if unknown:
+                raise ValueError(f"Unknown descriptors: {', '.join(unknown)}")
+            self.descriptors = descriptors
+
+        self.include_smiles = include_smiles
+        self.include_name = include_name
+        self.precision = precision
+        self.error_value = error_value
+
+    def _format_value(self, value: Optional[float]) -> Any:
+        """Format a descriptor value with precision and error handling."""
+        if value is None:
+            return self.error_value
+        if isinstance(value, float):
+            return round(value, self.precision)
+        return value
+
+    def compute(self, record: MoleculeRecord) -> Optional[dict[str, Any]]:
+        """
+        Compute descriptors for a molecule record.
+
+        Args:
+            record: MoleculeRecord to process
+
+        Returns:
+            Dictionary with descriptor values or None if molecule is invalid
+        """
+        if record.mol 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
+
+        for desc_name in self.descriptors:
+            value = compute_descriptor(record.mol, desc_name)
+            result[desc_name] = self._format_value(value)
+
+        return result
+
+    def get_column_names(self) -> list[str]:
+        """Get output column names in order."""
+        cols = []
+        if self.include_smiles:
+            cols.append("smiles")
+        if self.include_name:
+            cols.append("name")
+        cols.extend(self.descriptors)
+        return cols
+
+
+# Common descriptor sets
+COMMON_DESCRIPTORS = [
+    "MolWt",
+    "ExactMolWt",
+    "HeavyAtomCount",
+    "NumHAcceptors",
+    "NumHDonors",
+    "NumRotatableBonds",
+    "NumHeteroatoms",
+    "NumAromaticRings",
+    "RingCount",
+    "TPSA",
+    "MolLogP",
+    "MolMR",
+    "FractionCSP3",
+]
+
+LIPINSKI_DESCRIPTORS = [
+    "MolWt",
+    "MolLogP",
+    "NumHDonors",
+    "NumHAcceptors",
+]
+
+DRUGLIKE_DESCRIPTORS = [
+    "MolWt",
+    "MolLogP",
+    "NumHDonors",
+    "NumHAcceptors",
+    "TPSA",
+    "NumRotatableBonds",
+    "RingCount",
+    "HeavyAtomCount",
+]

rdkit_cli/core/diversity.py

@@ -0,0 +1,174 @@
+"""Molecular diversity analysis engine."""
+
+from typing import Optional, Any
+
+from rdkit import Chem, DataStructs
+from rdkit.Chem import rdMolDescriptors
+from rdkit.SimDivFilters import rdSimDivPickers
+
+
+def get_morgan_fingerprint(mol: Chem.Mol, radius: int = 2, n_bits: int = 2048):
+    """Get Morgan fingerprint for a molecule."""
+    return rdMolDescriptors.GetMorganFingerprintAsBitVect(mol, radius, nBits=n_bits)
+
+
+class DiversityPicker:
+    """Select diverse subset of molecules using MaxMin algorithm."""
+
+    def __init__(
+        self,
+        n_picks: int = 100,
+        seed: Optional[int] = None,
+        radius: int = 2,
+        n_bits: int = 2048,
+        method: str = "maxmin",
+    ):
+        """
+        Initialize diversity picker.
+
+        Args:
+            n_picks: Number of molecules to pick
+            seed: Random seed for reproducibility
+            radius: Morgan fingerprint radius
+            n_bits: Fingerprint bit size
+            method: Picking method ('maxmin' or 'leader')
+        """
+        self.n_picks = n_picks
+        self.seed = seed
+        self.radius = radius
+        self.n_bits = n_bits
+        self.method = method
+
+    def pick(
+        self,
+        mols: list[Chem.Mol],
+        first_picks: Optional[list[int]] = None,
+    ) -> list[int]:
+        """
+        Pick diverse subset of molecules.
+
+        Args:
+            mols: List of molecules
+            first_picks: Indices of molecules that must be included
+
+        Returns:
+            List of selected indices
+        """
+        # Filter None molecules and track indices
+        valid_mols = []
+        valid_indices = []
+        for i, mol in enumerate(mols):
+            if mol is not None:
+                valid_mols.append(mol)
+                valid_indices.append(i)
+
+        if len(valid_mols) == 0:
+            return []
+
+        # Generate fingerprints
+        fps = [get_morgan_fingerprint(mol, self.radius, self.n_bits) for mol in valid_mols]
+
+        # Adjust n_picks if larger than available
+        n_to_pick = min(self.n_picks, len(fps))
+
+        # Create picker
+        if self.method == "maxmin":
+            picker = rdSimDivPickers.MaxMinPicker()
+        else:
+            picker = rdSimDivPickers.LeaderPicker()
+
+        # Define distance function
+        def dist_func(i, j):
+            return 1 - DataStructs.TanimotoSimilarity(fps[i], fps[j])
+
+        # Pick diverse molecules
+        if first_picks:
+            # Map first_picks to valid indices
+            mapped_first = [valid_indices.index(i) for i in first_picks if i in valid_indices]
+            picks = list(picker.LazyBitVectorPick(fps, len(fps), n_to_pick, firstPicks=mapped_first))
+        else:
+            if self.seed is not None:
+                picks = list(picker.LazyBitVectorPick(fps, len(fps), n_to_pick, seed=self.seed))
+            else:
+                picks = list(picker.LazyBitVectorPick(fps, len(fps), n_to_pick))
+
+        # Map back to original indices
+        return [valid_indices[i] for i in picks]
+
+
+class DiversityAnalyzer:
+    """Analyze diversity of a molecule set."""
+
+    def __init__(
+        self,
+        radius: int = 2,
+        n_bits: int = 2048,
+        sample_size: int = 1000,
+    ):
+        """
+        Initialize diversity analyzer.
+
+        Args:
+            radius: Morgan fingerprint radius
+            n_bits: Fingerprint bit size
+            sample_size: Max molecules to sample for analysis
+        """
+        self.radius = radius
+        self.n_bits = n_bits
+        self.sample_size = sample_size
+
+    def analyze(self, mols: list[Chem.Mol]) -> dict[str, Any]:
+        """
+        Analyze diversity of molecule set.
+
+        Args:
+            mols: List of molecules
+
+        Returns:
+            Dictionary with diversity statistics
+        """
+        import random
+
+        # Filter None molecules
+        valid_mols = [mol for mol in mols if mol is not None]
+
+        if len(valid_mols) < 2:
+            return {"error": "Need at least 2 valid molecules"}
+
+        # Sample if too large
+        if len(valid_mols) > self.sample_size:
+            valid_mols = random.sample(valid_mols, self.sample_size)
+
+        # Generate fingerprints
+        fps = [get_morgan_fingerprint(mol, self.radius, self.n_bits) for mol in valid_mols]
+
+        # Compute pairwise similarities
+        similarities = []
+        n = len(fps)
+        for i in range(n):
+            for j in range(i + 1, n):
+                sim = DataStructs.TanimotoSimilarity(fps[i], fps[j])
+                similarities.append(sim)
+
+        if not similarities:
+            return {"error": "Could not compute similarities"}
+
+        # Calculate statistics
+        import statistics
+
+        mean_sim = statistics.mean(similarities)
+        median_sim = statistics.median(similarities)
+        min_sim = min(similarities)
+        max_sim = max(similarities)
+        stdev_sim = statistics.stdev(similarities) if len(similarities) > 1 else 0
+
+        return {
+            "n_molecules": len(valid_mols),
+            "n_pairs": len(similarities),
+            "mean_similarity": round(mean_sim, 4),
+            "median_similarity": round(median_sim, 4),
+            "min_similarity": round(min_sim, 4),
+            "max_similarity": round(max_sim, 4),
+            "stdev_similarity": round(stdev_sim, 4),
+            "diversity_score": round(1 - mean_sim, 4),
+        }

rdkit_cli/core/enumerate.py

@@ -0,0 +1,190 @@
+"""Molecular enumeration engine."""
+
+from typing import Optional, Any
+
+from rdkit import Chem
+from rdkit.Chem import AllChem, EnumerateStereoisomers
+from rdkit.Chem.MolStandardize import rdMolStandardize
+
+from rdkit_cli.io.readers import MoleculeRecord
+
+
+class StereoisomerEnumerator:
+    """Enumerate stereoisomers of molecules."""
+
+    def __init__(
+        self,
+        max_isomers: int = 32,
+        include_given: bool = True,
+        only_unassigned: bool = True,
+        include_smiles: bool = True,
+        include_name: bool = True,
+    ):
+        """
+        Initialize stereoisomer enumerator.
+
+        Args:
+            max_isomers: Maximum stereoisomers to generate
+            include_given: Include the input stereoisomer
+            only_unassigned: Only enumerate unassigned stereocenters
+            include_smiles: Include original SMILES in output
+            include_name: Include molecule name in output
+        """
+        self.max_isomers = max_isomers
+        self.include_given = include_given
+        self.only_unassigned = only_unassigned
+        self.include_smiles = include_smiles
+        self.include_name = include_name
+
+    def enumerate(self, record: MoleculeRecord) -> list[dict[str, Any]]:
+        """
+        Enumerate stereoisomers.
+
+        Args:
+            record: MoleculeRecord to process
+
+        Returns:
+            List of dictionaries with stereoisomer SMILES
+        """
+        if record.mol is None:
+            return []
+
+        try:
+            opts = EnumerateStereoisomers.StereoEnumerationOptions()
+            opts.maxIsomers = self.max_isomers
+            opts.onlyUnassigned = self.only_unassigned
+
+            isomers = list(EnumerateStereoisomers.EnumerateStereoisomers(record.mol, opts))
+
+            results = []
+            for i, iso in enumerate(isomers[:self.max_isomers]):
+                smi = Chem.MolToSmiles(iso, isomericSmiles=True)
+                result: dict[str, Any] = {"smiles": smi}
+
+                if self.include_name and record.name:
+                    result["name"] = f"{record.name}_iso{i}"
+                elif record.name:
+                    result["name"] = record.name
+
+                result["stereoisomer_idx"] = i
+                result["original_smiles"] = record.smiles
+
+                results.append(result)
+
+            return results
+
+        except Exception:
+            return []
+
+
+class TautomerEnumerator:
+    """Enumerate tautomers of molecules."""
+
+    def __init__(
+        self,
+        max_tautomers: int = 50,
+        max_transforms: int = 1000,
+        include_smiles: bool = True,
+        include_name: bool = True,
+    ):
+        """
+        Initialize tautomer enumerator.
+
+        Args:
+            max_tautomers: Maximum tautomers to generate
+            max_transforms: Maximum transforms to apply
+            include_smiles: Include original SMILES in output
+            include_name: Include molecule name in output
+        """
+        self.max_tautomers = max_tautomers
+        self.max_transforms = max_transforms
+        self.include_smiles = include_smiles
+        self.include_name = include_name
+
+        # Create enumerator
+        self._enumerator = rdMolStandardize.TautomerEnumerator()
+        self._enumerator.SetMaxTautomers(max_tautomers)
+        self._enumerator.SetMaxTransforms(max_transforms)
+
+    def enumerate(self, record: MoleculeRecord) -> list[dict[str, Any]]:
+        """
+        Enumerate tautomers.
+
+        Args:
+            record: MoleculeRecord to process
+
+        Returns:
+            List of dictionaries with tautomer SMILES
+        """
+        if record.mol is None:
+            return []
+
+        try:
+            tautomers = list(self._enumerator.Enumerate(record.mol))
+
+            results = []
+            for i, taut in enumerate(tautomers[:self.max_tautomers]):
+                smi = Chem.MolToSmiles(taut, isomericSmiles=True)
+                result: dict[str, Any] = {"smiles": smi}
+
+                if self.include_name and record.name:
+                    result["name"] = f"{record.name}_taut{i}"
+                elif record.name:
+                    result["name"] = record.name
+
+                result["tautomer_idx"] = i
+                result["original_smiles"] = record.smiles
+
+                results.append(result)
+
+            return results
+
+        except Exception:
+            return []
+
+
+class CanonicalTautomerizer:
+    """Get canonical tautomer of molecules."""
+
+    def __init__(
+        self,
+        include_original: bool = False,
+    ):
+        """
+        Initialize canonical tautomerizer.
+
+        Args:
+            include_original: Include original SMILES in output
+        """
+        self.include_original = include_original
+        self._canonicalizer = rdMolStandardize.TautomerEnumerator()
+
+    def canonicalize(self, record: MoleculeRecord) -> Optional[dict[str, Any]]:
+        """
+        Get canonical tautomer.
+
+        Args:
+            record: MoleculeRecord to process
+
+        Returns:
+            Dictionary with canonical tautomer or None
+        """
+        if record.mol is None:
+            return None
+
+        try:
+            canonical = self._canonicalizer.Canonicalize(record.mol)
+            smi = Chem.MolToSmiles(canonical, isomericSmiles=True)
+
+            result: dict[str, Any] = {"smiles": smi}
+
+            if record.name:
+                result["name"] = record.name
+
+            if self.include_original:
+                result["original_smiles"] = record.smiles
+
+            return result
+
+        except Exception:
+            return None