celltype-cli 0.1.0__py3-none-any.whl

ct/tools/_compound_resolver.py

@@ -0,0 +1,297 @@
+"""Compound name resolver — maps drug names to dataset-specific IDs.
+
+The ct datasets use proprietary compound IDs:
+- PRISM/L1000: YU-codes (e.g., YU254653)
+- Proteomics: Cmpd format (e.g., Cmpd18_B10)
+
+This module resolves common drug names (lenalidomide, pomalidomide, etc.)
+to the most structurally similar compound in each dataset via Tanimoto similarity.
+"""
+
+import csv
+import os
+import re
+from functools import lru_cache
+
+# Data file paths
+_DATA_DIR = "/mnt2/bronze/molecular_glue/crews_library"
+_SMILES_CSV = os.path.join(_DATA_DIR, "all_compounds_smiles.csv")
+_PROT_MAPPING_CSV = os.path.join(_DATA_DIR, "proteomics_to_yu_mapping.csv")
+
+# Regex patterns
+_YU_PATTERN = re.compile(r"^YU\d{6}$")
+_CMPD_PATTERN = re.compile(r"^Cmpd\d+")
+
+# Module-level caches (populated on first use)
+_yu_smiles: dict | None = None
+_prot_to_yu: dict | None = None
+_yu_to_prot: dict | None = None
+
+
+def _load_yu_smiles() -> dict:
+    """Load YU compound → SMILES mapping (lazy, cached)."""
+    global _yu_smiles
+    if _yu_smiles is not None:
+        return _yu_smiles
+    _yu_smiles = {}
+    if not os.path.exists(_SMILES_CSV):
+        return _yu_smiles
+    with open(_SMILES_CSV) as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            _yu_smiles[row["compound"]] = row["smiles"]
+    return _yu_smiles
+
+
+def _load_prot_mapping() -> tuple[dict, dict]:
+    """Load proteomics Cmpd ↔ YU mapping (lazy, cached)."""
+    global _prot_to_yu, _yu_to_prot
+    if _prot_to_yu is not None:
+        return _prot_to_yu, _yu_to_prot
+    _prot_to_yu = {}
+    _yu_to_prot = {}
+    if not os.path.exists(_PROT_MAPPING_CSV):
+        return _prot_to_yu, _yu_to_prot
+    with open(_PROT_MAPPING_CSV) as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            _prot_to_yu[row["cmpd_id"]] = row["yu_id"]
+            _yu_to_prot[row["yu_id"]] = row["cmpd_id"]
+    return _prot_to_yu, _yu_to_prot
+
+
+@lru_cache(maxsize=64)
+def _tanimoto_search(smiles: str, candidate_ids: frozenset) -> tuple[str, float] | None:
+    """Find most similar YU compound to a SMILES string by Tanimoto similarity."""
+    try:
+        from rdkit import Chem
+        from rdkit.Chem import AllChem, DataStructs
+    except ImportError:
+        return None
+
+    mol = Chem.MolFromSmiles(smiles)
+    if mol is None:
+        return None
+    query_fp = AllChem.GetMorganFingerprintAsBitVect(mol, 2, nBits=2048)
+
+    yu_smiles = _load_yu_smiles()
+    best_id, best_sim = None, 0.0
+
+    for yu_id in candidate_ids:
+        smi = yu_smiles.get(yu_id)
+        if not smi:
+            continue
+        m = Chem.MolFromSmiles(smi)
+        if m is None:
+            continue
+        fp = AllChem.GetMorganFingerprintAsBitVect(m, 2, nBits=2048)
+        sim = DataStructs.TanimotoSimilarity(query_fp, fp)
+        if sim > best_sim:
+            best_sim = sim
+            best_id = yu_id
+
+    if best_id is None:
+        return None
+    return best_id, round(best_sim, 4)
+
+
+def resolve_to_smiles(name_or_smiles: str) -> str:
+    """Resolve a compound name or SMILES string to a canonical SMILES string.
+
+    Resolution order:
+    1. Try parsing as SMILES with RDKit (if installed)
+    2. Try PubChem lookup via API
+    3. Try ChEMBL lookup via API
+    4. Raise ValueError if all methods fail
+
+    Parameters
+    ----------
+    name_or_smiles : str
+        Drug name (e.g. "lenalidomide") or SMILES string.
+
+    Returns
+    -------
+    str
+        Canonical SMILES string.
+
+    Raises
+    ------
+    ValueError
+        If the input cannot be resolved to a SMILES string.
+    """
+    if not name_or_smiles or not isinstance(name_or_smiles, str):
+        raise ValueError(f"Invalid input: {name_or_smiles}")
+
+    name_or_smiles = name_or_smiles.strip()
+    if not name_or_smiles:
+        raise ValueError("Empty input")
+
+    # 1. Try RDKit parse — is it already a valid SMILES?
+    try:
+        from rdkit import Chem
+
+        mol = Chem.MolFromSmiles(name_or_smiles)
+        if mol is not None:
+            return name_or_smiles
+    except ImportError:
+        # No RDKit — heuristic: if it has typical SMILES characters, assume it's SMILES
+        if any(c in name_or_smiles for c in "=#()[]"):
+            return name_or_smiles
+
+    # 2. Try PubChem lookup
+    try:
+        from ct.tools.chemistry import pubchem_lookup
+
+        result = pubchem_lookup(name_or_smiles, query_type="name")
+        smiles = (result.get("properties") or {}).get("canonical_smiles")
+        if smiles:
+            return smiles
+    except Exception:
+        pass
+
+    # 3. Try ChEMBL lookup
+    try:
+        from ct.tools.literature import chembl_query
+
+        result = chembl_query(name_or_smiles, query_type="molecule", max_results=1)
+        molecules = result.get("molecules", [])
+        if molecules and molecules[0].get("smiles"):
+            return molecules[0]["smiles"]
+    except Exception:
+        pass
+
+    raise ValueError(
+        f"Could not resolve '{name_or_smiles}' to a SMILES string. "
+        "Tried: RDKit SMILES parse, PubChem, ChEMBL."
+    )
+
+
+def resolve_compound(name_or_id: str, dataset: str = "prism") -> str:
+    """Resolve a compound name or ID to a dataset-specific ID.
+
+    Parameters
+    ----------
+    name_or_id : str
+        Drug name (e.g. "lenalidomide"), YU code, or Cmpd ID.
+    dataset : str
+        Target dataset: "prism", "l1000", or "proteomics".
+
+    Returns
+    -------
+    str
+        Resolved compound ID for the target dataset.
+        For L1000 with compound-named index, returns the compound name directly.
+        For proteomics, returns the full Cmpd_well ID if possible.
+        Falls back to the original input if resolution fails.
+    """
+    if not name_or_id or not isinstance(name_or_id, str):
+        return name_or_id
+
+    name_or_id = name_or_id.strip()
+
+    # For L1000: check if the index uses compound names (new format) vs YU codes (legacy)
+    if dataset == "l1000":
+        try:
+            from ct.data.loaders import load_l1000
+            l1000 = load_l1000()
+            sample_idx = str(l1000.index[0]) if len(l1000) > 0 else ""
+            if not _YU_PATTERN.match(sample_idx):
+                # New compound-named index: case-insensitive lookup
+                name_lower = name_or_id.lower().strip()
+                idx_lower = {c.lower(): c for c in l1000.index}
+                if name_lower in idx_lower:
+                    return idx_lower[name_lower]
+                # Try partial match
+                for key, original in idx_lower.items():
+                    if name_lower in key or key in name_lower:
+                        return original
+                return name_or_id
+        except (FileNotFoundError, ImportError):
+            pass
+
+    # Already a YU code — return as-is for PRISM/L1000, convert for proteomics
+    if _YU_PATTERN.match(name_or_id):
+        if dataset == "proteomics":
+            return _yu_to_proteomics_col(name_or_id) or name_or_id
+        return name_or_id
+
+    # Already a Cmpd ID — return as-is for proteomics, convert for PRISM/L1000
+    if _CMPD_PATTERN.match(name_or_id):
+        if dataset == "proteomics":
+            return name_or_id
+        prot_to_yu, _ = _load_prot_mapping()
+        base = name_or_id.split("_")[0]
+        yu_id = prot_to_yu.get(base)
+        return yu_id if yu_id else name_or_id
+
+    # Drug name — try to resolve SMILES via API, then find closest match in dataset
+    try:
+        drug_smi = resolve_to_smiles(name_or_id)
+    except ValueError:
+        return name_or_id  # Cannot resolve to SMILES, return as-is
+
+    # Dynamic SMILES-based resolution (cached)
+    # Get candidate compounds from the target dataset
+    candidates = _get_dataset_compounds(dataset)
+    if not candidates:
+        return name_or_id
+
+    result = _tanimoto_search(drug_smi, frozenset(candidates))
+    if result is None:
+        return name_or_id
+
+    yu_id, sim = result
+    # Low-similarity proxies produce misleading data — return the original
+    # name so the tool reports "not found" and synthesis uses LLM knowledge
+    if sim < 0.65:
+        return name_or_id
+    if dataset == "proteomics":
+        return _yu_to_proteomics_col(yu_id) or yu_id
+    return yu_id
+
+
+def resolve_proteomics_id(yu_id: str) -> str | None:
+    """Convert a YU compound ID to the proteomics Cmpd_well column name.
+
+    Returns None if no mapping exists.
+    """
+    return _yu_to_proteomics_col(yu_id)
+
+
+def _yu_to_proteomics_col(yu_id: str) -> str | None:
+    """Map YU ID → full proteomics column name (Cmpd##_well)."""
+    _, yu_to_prot = _load_prot_mapping()
+    base_cmpd = yu_to_prot.get(yu_id)
+    if base_cmpd is None:
+        return None
+
+    # Find the full column name in proteomics data
+    try:
+        from ct.data.loaders import load_proteomics
+        prot = load_proteomics()
+        for col in prot.columns:
+            if col.startswith(base_cmpd + "_"):
+                return col
+    except (FileNotFoundError, ImportError):
+        pass
+
+    return base_cmpd
+
+
+def _get_dataset_compounds(dataset: str) -> set:
+    """Get the set of YU compound IDs available in a dataset."""
+    try:
+        if dataset == "prism":
+            from ct.data.loaders import load_prism
+            prism = load_prism()
+            return set(prism["pert_name"].unique())
+        elif dataset == "l1000":
+            from ct.data.loaders import load_l1000
+            l1000 = load_l1000()
+            return set(l1000.index.tolist())
+        elif dataset == "proteomics":
+            _, yu_to_prot = _load_prot_mapping()
+            return set(yu_to_prot.keys())
+    except (FileNotFoundError, ImportError):
+        pass
+    return set()

ct/tools/biomarker.py

@@ -0,0 +1,368 @@
+"""
+Biomarker tools: mutation sensitivity, resistance profiling, dependency validation.
+"""
+
+import pandas as pd
+import numpy as np
+from scipy import stats
+from ct.tools import registry
+
+
+@registry.register(
+    name="biomarker.mutation_sensitivity",
+    description="Test whether specific mutations sensitize or confer resistance to a compound",
+    category="biomarker",
+    parameters={"compound_id": "Compound YU ID", "gene": "Gene to test (or 'all' for genome-wide)"},
+    requires_data=["prism", "depmap_mutations", "depmap_model"],
+    usage_guide="You want to find predictive biomarkers — which mutations make cells more or less sensitive to a compound. Use for patient stratification and clinical trial design.",
+)
+def mutation_sensitivity(compound_id: str, gene: str = "all", **kwargs) -> dict:
+    """Test mutation-sensitivity associations."""
+    from ct.data.loaders import load_prism, load_mutations, load_model_metadata
+    from ct.tools._compound_resolver import resolve_compound
+
+    compound_id = resolve_compound(compound_id, dataset="prism")
+
+    prism = load_prism()
+    mutations = load_mutations()
+    model = load_model_metadata()
+
+    # Map PRISM cell lines to DepMap ModelIDs
+    ccle_to_model = {}
+    for _, row in model.iterrows():
+        ccle = row.get("CCLEName", "")
+        mid = row.get("ModelID", "")
+        if pd.notna(ccle) and pd.notna(mid):
+            ccle_to_model[ccle] = mid
+
+    # Get compound sensitivity at highest dose
+    cpd = prism[prism["pert_name"] == compound_id]
+    if len(cpd) == 0:
+        return {"error": f"Compound {compound_id} not in PRISM", "summary": f"Compound {compound_id} not found in PRISM data"}
+
+    max_dose = cpd["pert_dose"].max()
+    cpd_hd = cpd[cpd["pert_dose"] == max_dose].groupby("ccle_name")["LFC"].mean()
+
+    # Map to ModelIDs
+    sensitivity = {}
+    for ccle, lfc in cpd_hd.items():
+        mid = ccle_to_model.get(ccle)
+        if mid and mid in mutations.index:
+            sensitivity[mid] = lfc
+
+    if len(sensitivity) < 20:
+        return {"error": f"Insufficient overlap: only {len(sensitivity)} cell lines mapped", "summary": f"Insufficient cell line overlap ({len(sensitivity)} < 20 required)"}
+
+    # Test genes
+    genes_to_test = [gene] if gene != "all" else [g for g in mutations.columns if mutations[g].sum() >= 3]
+    model_ids = list(sensitivity.keys())
+    lfc_values = pd.Series(sensitivity)
+
+    results = []
+    for g in genes_to_test:
+        if g not in mutations.columns:
+            continue
+
+        mut_status = mutations.loc[model_ids, g].reindex(model_ids).fillna(0)
+        mutant_ids = [m for m in model_ids if mut_status.loc[m] > 0]
+        wt_ids = [m for m in model_ids if mut_status.loc[m] == 0]
+
+        if len(mutant_ids) < 3 or len(wt_ids) < 3:
+            continue
+
+        mut_lfc = lfc_values[mutant_ids]
+        wt_lfc = lfc_values[wt_ids]
+        stat, pval = stats.mannwhitneyu(mut_lfc, wt_lfc, alternative="two-sided")
+
+        results.append({
+            "gene": g,
+            "mut_mean_lfc": round(float(mut_lfc.mean()), 3),
+            "wt_mean_lfc": round(float(wt_lfc.mean()), 3),
+            "delta": round(float(mut_lfc.mean() - wt_lfc.mean()), 3),
+            "direction": "sensitizing" if mut_lfc.mean() < wt_lfc.mean() else "resistance",
+            "pval": float(pval),
+            "n_mutant": len(mutant_ids),
+            "n_wt": len(wt_ids),
+        })
+
+    if not results:
+        return {
+            "summary": (
+                f"Mutation sensitivity for {compound_id}: {len(genes_to_test)} genes tested, "
+                f"0 significant (p<0.05). No genes met minimum sample size (3 mutant, 3 WT)."
+            ),
+            "compound": compound_id,
+            "significant_mutations": [],
+            "n_tested": 0,
+        }
+
+    df = pd.DataFrame(results).sort_values("pval")
+    if len(df) > 0:
+        # Benjamini-Hochberg FDR: p * m / rank (monotonicity enforced)
+        ranks = df["pval"].rank(method="first")
+        df["fdr"] = (df["pval"] * len(df) / ranks).clip(upper=1.0)
+        # Enforce monotonicity: walk backwards to ensure FDR is non-decreasing with p-value
+        fdr_arr = df["fdr"].values.copy()
+        for i in range(len(fdr_arr) - 2, -1, -1):
+            fdr_arr[i] = min(fdr_arr[i], fdr_arr[i + 1])
+        df["fdr"] = fdr_arr
+
+    sig = df[df["pval"] < 0.05]
+
+    return {
+        "summary": (
+            f"Mutation sensitivity for {compound_id}: {len(genes_to_test)} genes tested, "
+            f"{len(sig)} significant (p<0.05)"
+        ),
+        "compound": compound_id,
+        "significant_mutations": sig.head(20).to_dict("records") if len(sig) > 0 else [],
+        "n_tested": len(results),
+    }
+
+
+@registry.register(
+    name="biomarker.resistance_profile",
+    description="Profile resistance mechanisms for a compound (lineage, mutation, dependency enrichment)",
+    category="biomarker",
+    parameters={"compound_id": "Compound YU ID"},
+    requires_data=["prism", "depmap_crispr", "depmap_mutations", "depmap_model"],
+    usage_guide="You want to understand why some cell lines resist a compound — lineage effects, specific mutations, or dependency patterns. Use to anticipate clinical resistance mechanisms.",
+)
+def resistance_profile(compound_id: str, **kwargs) -> dict:
+    """Comprehensive resistance profiling for a compound."""
+    from ct.data.loaders import load_prism, load_model_metadata
+    from ct.tools._compound_resolver import resolve_compound
+
+    compound_id = resolve_compound(compound_id, dataset="prism")
+
+    prism = load_prism()
+    model = load_model_metadata()
+
+    cpd = prism[prism["pert_name"] == compound_id]
+    if len(cpd) == 0:
+        return {"error": f"Compound {compound_id} not in PRISM", "summary": f"Compound {compound_id} not found in PRISM data"}
+
+    max_dose = cpd["pert_dose"].max()
+    cpd_hd = cpd[cpd["pert_dose"] == max_dose].groupby("ccle_name")["LFC"].mean()
+
+    n_sensitive = (cpd_hd < -0.5).sum()
+    n_resistant = (cpd_hd > -0.1).sum()
+    n_intermediate = len(cpd_hd) - n_sensitive - n_resistant
+
+    # Lineage enrichment
+    ccle_to_lineage = {}
+    for _, row in model.iterrows():
+        ccle = row.get("CCLEName", "")
+        lin = row.get("OncotreeLineage", "Unknown")
+        if pd.notna(ccle) and pd.notna(lin):
+            ccle_to_lineage[ccle] = lin
+
+    sens_lineages = [ccle_to_lineage.get(c, "Unknown") for c in cpd_hd[cpd_hd < -0.5].index]
+    res_lineages = [ccle_to_lineage.get(c, "Unknown") for c in cpd_hd[cpd_hd > -0.1].index]
+
+    lineage_counts = {}
+    for lin in set(sens_lineages + res_lineages):
+        if lin == "Unknown":
+            continue
+        s = sens_lineages.count(lin)
+        r = res_lineages.count(lin)
+        if s + r >= 3:
+            lineage_counts[lin] = {"sensitive": s, "resistant": r, "total": s + r}
+
+    return {
+        "summary": (
+            f"Resistance profile for {compound_id}:\n"
+            f"  Sensitive: {n_sensitive}, Intermediate: {n_intermediate}, Resistant: {n_resistant}\n"
+            f"  {len(lineage_counts)} lineages profiled"
+        ),
+        "compound": compound_id,
+        "n_sensitive": int(n_sensitive),
+        "n_resistant": int(n_resistant),
+        "n_intermediate": int(n_intermediate),
+        "lineage_profiles": lineage_counts,
+    }
+
+
+@registry.register(
+    name="biomarker.panel_select",
+    description="ML-based biomarker panel selection: identify top predictive mutations for compound sensitivity",
+    category="biomarker",
+    parameters={
+        "compound_id": "Compound ID (PRISM pert_name)",
+        "n_features": "Number of top biomarker features to return (default 10)",
+        "method": "Feature selection method: 'mutual_info', 'lasso', or 'random_forest' (default 'mutual_info')",
+    },
+    requires_data=["prism", "depmap_mutations", "depmap_model"],
+    usage_guide="You want to select the best biomarker panel for predicting compound response — "
+                "which mutations best predict sensitivity. Use for patient stratification, companion "
+                "diagnostic design, and clinical trial enrichment. Methods: mutual_info (fast, nonlinear), "
+                "lasso (sparse linear), random_forest (handles interactions).",
+)
+def panel_select(
+    compound_id: str,
+    n_features: int = 10,
+    method: str = "mutual_info",
+    **kwargs,
+) -> dict:
+    """ML-based biomarker panel selection using sklearn.
+
+    Uses PRISM sensitivity as target (LFC < -0.5 = sensitive) and the DepMap
+    mutation matrix as features. Supports three methods:
+    - mutual_info: mutual information classification (fast, captures nonlinear)
+    - lasso: LassoCV with L1 regularization (sparse, linear)
+    - random_forest: random forest feature importances (handles interactions)
+
+    Returns ranked list of biomarker genes with importance scores and
+    cross-validation AUC.
+    """
+    from ct.data.loaders import load_prism, load_mutations, load_model_metadata
+    from ct.tools._compound_resolver import resolve_compound
+
+    compound_id = resolve_compound(compound_id, dataset="prism")
+
+    valid_methods = ("mutual_info", "lasso", "random_forest")
+    if method not in valid_methods:
+        return {"error": f"Unknown method '{method}'. Choose from: {', '.join(valid_methods)}", "summary": f"Unknown method '{method}'. Choose from: {', '.join(valid_methods)}"}
+    prism = load_prism()
+    mutations = load_mutations()
+    model = load_model_metadata()
+
+    # --- Map PRISM cell lines to DepMap ModelIDs ---
+    ccle_to_model = {}
+    for _, row in model.iterrows():
+        ccle = row.get("CCLEName", "")
+        mid = row.get("ModelID", "")
+        if pd.notna(ccle) and pd.notna(mid):
+            ccle_to_model[ccle] = mid
+
+    # --- Get compound sensitivity at highest dose ---
+    cpd = prism[prism["pert_name"] == compound_id]
+    if len(cpd) == 0:
+        return {"error": f"Compound {compound_id} not found in PRISM data", "summary": f"Compound {compound_id} not found in PRISM data"}
+    max_dose = cpd["pert_dose"].max()
+    cpd_hd = cpd[cpd["pert_dose"] == max_dose].groupby("ccle_name")["LFC"].mean()
+
+    # Map to ModelIDs and build target vector
+    sensitivity = {}
+    for ccle, lfc in cpd_hd.items():
+        mid = ccle_to_model.get(ccle)
+        if mid and mid in mutations.index:
+            sensitivity[mid] = lfc
+
+    if len(sensitivity) < 20:
+        return {
+            "error": f"Insufficient overlap: only {len(sensitivity)} cell lines mapped between PRISM and mutation data (need >=20)",
+        }
+
+    common_ids = list(sensitivity.keys())
+    y_lfc = np.array([sensitivity[mid] for mid in common_ids])
+    y_binary = (y_lfc < -0.5).astype(int)  # 1 = sensitive
+
+    n_sensitive = int(y_binary.sum())
+    n_resistant = int(len(y_binary) - n_sensitive)
+
+    if n_sensitive < 3 or n_resistant < 3:
+        return {
+            "error": f"Insufficient class balance: {n_sensitive} sensitive, {n_resistant} resistant (need >=3 each)",
+        }
+
+    # --- Build feature matrix (mutation status) ---
+    # Filter to genes with at least 3 mutated samples
+    X_full = mutations.loc[common_ids].fillna(0)
+    gene_counts = (X_full > 0).sum()
+    usable_genes = gene_counts[(gene_counts >= 3) & (gene_counts <= len(common_ids) - 3)].index.tolist()
+
+    if len(usable_genes) < 3:
+        return {
+            "error": f"Only {len(usable_genes)} genes with sufficient mutation frequency for feature selection",
+        }
+
+    X = X_full[usable_genes].values
+    feature_names = usable_genes
+
+    # --- Feature selection ---
+    importances = np.zeros(len(feature_names))
+
+    if method == "mutual_info":
+        from sklearn.feature_selection import mutual_info_classif
+        importances = mutual_info_classif(X, y_binary, random_state=42)
+
+    elif method == "lasso":
+        from sklearn.linear_model import LassoCV
+        from sklearn.preprocessing import StandardScaler
+
+        scaler = StandardScaler()
+        X_scaled = scaler.fit_transform(X)
+        lasso = LassoCV(cv=min(5, n_sensitive, n_resistant), random_state=42, max_iter=5000)
+        lasso.fit(X_scaled, y_lfc)  # Use continuous LFC for lasso
+        importances = np.abs(lasso.coef_)
+
+    elif method == "random_forest":
+        from sklearn.ensemble import RandomForestClassifier
+        rf = RandomForestClassifier(
+            n_estimators=100,
+            max_depth=5,
+            random_state=42,
+            class_weight="balanced",
+        )
+        rf.fit(X, y_binary)
+        importances = rf.feature_importances_
+
+    # --- Rank features ---
+    ranked_idx = np.argsort(importances)[::-1]
+    top_idx = ranked_idx[:n_features]
+
+    biomarkers = []
+    for i in top_idx:
+        gene_name = feature_names[i]
+        imp = float(importances[i])
+        if imp <= 0 and method != "lasso":
+            continue  # Skip zero-importance features
+        n_mut = int((X[:, i] > 0).sum())
+        biomarkers.append({
+            "gene": gene_name,
+            "importance": round(imp, 6),
+            "n_mutated": n_mut,
+            "mutation_frequency": round(n_mut / len(common_ids), 4),
+        })
+
+    # --- Cross-validation AUC using top features ---
+    cv_auc = None
+    if biomarkers:
+        from sklearn.model_selection import cross_val_score
+        from sklearn.ensemble import RandomForestClassifier as RFC
+
+        top_gene_idx = [feature_names.index(b["gene"]) for b in biomarkers if b["gene"] in feature_names]
+        if len(top_gene_idx) >= 1:
+            X_top = X[:, top_gene_idx]
+            cv_folds = min(5, n_sensitive, n_resistant)
+            if cv_folds >= 2:
+                clf = RFC(n_estimators=50, max_depth=3, random_state=42, class_weight="balanced")
+                try:
+                    scores = cross_val_score(clf, X_top, y_binary, cv=cv_folds, scoring="roc_auc")
+                    cv_auc = round(float(scores.mean()), 4)
+                except ValueError:
+                    cv_auc = None
+
+    # --- Summary ---
+    top_genes_str = ", ".join(
+        f"{b['gene']}({b['importance']:.4f})" for b in biomarkers[:5]
+    )
+    auc_str = f", CV-AUC={cv_auc:.3f}" if cv_auc is not None else ""
+    summary = (
+        f"Biomarker panel for {compound_id} ({method}): "
+        f"{len(biomarkers)} features selected from {len(usable_genes)} candidates. "
+        f"Top: {top_genes_str}{auc_str}"
+    )
+
+    return {
+        "summary": summary,
+        "compound": compound_id,
+        "method": method,
+        "n_cell_lines": len(common_ids),
+        "n_sensitive": n_sensitive,
+        "n_resistant": n_resistant,
+        "n_features_tested": len(usable_genes),
+        "biomarkers": biomarkers,
+        "cv_auc": cv_auc,
+    }