docking_pipeline/adaptive.py

from __future__ import annotations

import json
import shutil
from dataclasses import dataclass
from pathlib import Path

from .provenance import RDockPipelineError, require_file
from .rdock import RDockEngine, TargetConfig
from .sdf import best_per_ligand, parse_rdock_sdf_records, records_to_rows, split_sdf_file, write_rows_csv, write_sdf_blocks, write_sdf_records


@dataclass
class ScheduledBatch:
    batch_index: int
    ligand_ids: list[str]


class RealDockingScheduler:
    """Simple explicit scheduler: model ranks candidates, rDock produces ground truth."""

    def __init__(self, ligands: object, budget: int, batch_size: int) -> None:
        if hasattr(ligands, "to_dict"):
            rows = ligands.to_dict(orient="records")  # type: ignore[call-arg]
        else:
            rows = list(ligands)  # type: ignore[arg-type]
        if not rows or "ligand_id" not in rows[0] or "smiles" not in rows[0]:
            raise RDockPipelineError("Adaptive ligand CSV must contain ligand_id and smiles columns")
        self.rows: list[dict[str, object]] = [dict(r) for r in rows]
        self.budget = int(budget)
        self.batch_size = int(batch_size)
        self.completed: set[str] = set()
        for row in self.rows:
            model_score = _float_or_zero(row.get("model_score", 0.0))
            row["model_score"] = model_score
            row["adaptive_priority"] = -model_score
            row["actually_docked"] = False

    def next_batch(self) -> ScheduledBatch | None:
        remaining_budget = self.budget - len(self.completed)
        if remaining_budget <= 0:
            return None
        active = [row for row in self.rows if str(row["ligand_id"]) not in self.completed]
        if not active:
            return None
        active = sorted(active, key=lambda r: (-float(r["adaptive_priority"]), str(r["ligand_id"])))
        ids = [str(row["ligand_id"]) for row in active[: min(self.batch_size, remaining_budget)]]
        return ScheduledBatch(batch_index=len(self.completed) // max(1, self.batch_size), ligand_ids=ids)

    def update(self, docked_scores: object) -> None:
        if hasattr(docked_scores, "to_dict"):
            score_rows = docked_scores.to_dict(orient="records")  # type: ignore[call-arg]
        else:
            score_rows = list(docked_scores)  # type: ignore[arg-type]
        for ligand_id in [str(row["ligand_id"]) for row in score_rows]:
            self.completed.add(ligand_id)
            for row in self.rows:
                if str(row["ligand_id"]) == ligand_id:
                    row["actually_docked"] = True
        if not score_rows:
            return
        scores = sorted(_float_or_zero(row.get("SCORE", 0.0)) for row in score_rows)
        median_score = scores[len(scores) // 2]
        for row in self.rows:
            if str(row["ligand_id"]) not in self.completed:
                row["adaptive_priority"] = float(row["adaptive_priority"]) + (0.001 * -median_score)

    def to_dataframe(self):
        import pandas as pd

        return pd.DataFrame(self.rows)


def _float_or_zero(value: object) -> float:
    try:
        return float(value)
    except Exception:
        return 0.0


def _prepare_batch_sdf(ligands: pd.DataFrame, ligand_ids: list[str], out_sdf: Path) -> Path:
    from libs.docking.prep import prepare_ligand_sdf

    tmp = out_sdf.parent / "prepared"
    tmp.mkdir(parents=True, exist_ok=True)
    blocks: list[str] = []
    by_id = ligands.set_index("ligand_id")
    for ligand_id in ligand_ids:
        smiles = str(by_id.loc[ligand_id, "smiles"])
        sdf = prepare_ligand_sdf(ligand_id, smiles, tmp / f"{ligand_id}.sdf")
        blocks.extend(split_sdf_file(sdf))
    write_sdf_blocks(blocks, out_sdf)
    return out_sdf


def run_adaptive(
    target_config: TargetConfig,
    ligands_csv: str | Path,
    out_dir: str | Path,
    budget: int,
    batch_size: int,
    engine: RDockEngine,
    n_runs: int | None = None,
) -> Path:
    import pandas as pd

    ligands = pd.read_csv(require_file(ligands_csv, "adaptive ligand CSV"))
    scheduler = RealDockingScheduler(ligands, budget=budget, batch_size=batch_size)
    root = Path(out_dir)
    for name in ("target", "ligands", "rdock", "poses", "tables", "metrics"):
        (root / name).mkdir(parents=True, exist_ok=True)
    shutil.copy2(target_config.receptor, root / "target" / Path(target_config.receptor).name)
    shutil.copy2(target_config.reference_ligand, root / "target" / Path(target_config.reference_ligand).name)

    batch_records = []
    all_blocks: list[str] = []
    while True:
        batch = scheduler.next_batch()
        if batch is None:
            break
        batch_dir = root / "rdock" / f"batch_{batch.batch_index:03d}"
        batch_sdf = _prepare_batch_sdf(ligands, batch.ligand_ids, root / "ligands" / f"batch_{batch.batch_index:03d}.sdf")
        artifacts = engine.dock_sdf(target_config, batch_sdf, batch_dir, n_runs=n_runs, jobs=engine.config.jobs, run_id=f"{root.name}_batch_{batch.batch_index:03d}")
        best_df = pd.read_csv(artifacts.best_per_ligand_csv)
        scheduler.update(best_df)
        all_blocks.extend(split_sdf_file(artifacts.all_poses_sdf))
        for ligand_id in batch.ligand_ids:
            batch_records.append({"batch": batch.batch_index, "ligand_id": ligand_id})

    all_poses = root / "poses" / "all_poses.sdf"
    write_sdf_blocks(all_blocks, all_poses)
    if all_blocks:
        records = parse_rdock_sdf_records(all_poses)
        best = best_per_ligand(records)
        write_sdf_records(best, root / "poses" / "best_per_ligand.sdf")
        score_rows = records_to_rows(records)
        best_rows = records_to_rows(best)
    else:
        score_rows = []
        best_rows = []
        (root / "poses" / "best_per_ligand.sdf").write_text("", encoding="utf-8")
    scheduler_df = scheduler.to_dataframe()
    model_cols = scheduler_df[["ligand_id", "model_score", "adaptive_priority", "actually_docked"]]
    if best_rows:
        model_map = model_cols.set_index("ligand_id").to_dict(orient="index")
        for row in best_rows:
            row.update(model_map.get(str(row["ligand_id"]), {}))
    write_rows_csv(score_rows, root / "tables" / "scores_long.csv")
    write_rows_csv(best_rows, root / "tables" / "best_per_ligand.csv")
    scheduler_df.to_csv(root / "tables" / "scheduler_all_ligands.csv", index=False)
    pd.DataFrame(batch_records).to_csv(root / "tables" / "adaptive_batches.csv", index=False)
    (root / "metrics" / "validation_metrics.json").write_text("{}", encoding="utf-8")
    pd.DataFrame().to_csv(root / "metrics" / "enrichment.csv", index=False)
    manifest = {
        "engine": "real-rdock-adaptive",
        "budget": int(budget),
        "batch_size": int(batch_size),
        "docked_ligand_count": int(scheduler_df["actually_docked"].sum()),
        "undocked_ligands_are_hits": False,
        "artifacts": {
            "all_poses_sdf": str(all_poses),
            "best_per_ligand_csv": str(root / "tables" / "best_per_ligand.csv"),
            "scheduler_all_ligands_csv": str(root / "tables" / "scheduler_all_ligands.csv"),
        },
    }
    (root / "manifest.json").write_text(json.dumps(manifest, indent=2), encoding="utf-8")
    (root / "config.yaml").write_text(f"budget: {budget}\nbatch_size: {batch_size}\n", encoding="utf-8")
    (root / "commands.log").write_text("", encoding="utf-8")
    for batch_log in sorted((root / "rdock").glob("batch_*/commands.log")):
        with (root / "commands.log").open("a", encoding="utf-8") as dst:
            dst.write(batch_log.read_text(encoding="utf-8"))
    (root / "report.md").write_text(
        "# Adaptive rDock Run\n\n"
        "Model scores only schedule ligands. `best_per_ligand.csv` is built exclusively from real rDock SDF records with SCORE fields.\n",
        encoding="utf-8",
    )
    return root