docking_pipeline/benchmark_comparable_adaptive.py

from __future__ import annotations

import argparse
import json
import shutil
from argparse import Namespace
from pathlib import Path
from typing import Any

from .benchmark_adaptive import _load_input_block_map, _sample_reference_rows, _stable_json_hash, _write_json, _write_selected_sdf
from .benchmark_triage_strategies import benchmark_triage_strategies
from .dataset import read_ligand_metadata, validate_dataset_dir
from .provenance import RDockPipelineError, require_file
from .sdf import write_rows_csv


def _read_json(path: Path) -> dict[str, Any]:
    return json.loads(path.read_text(encoding="utf-8"))


def filter_ligand_ids_to_prepared_sdf(
    ligand_ids: list[str],
    prepared_ids: set[str],
) -> tuple[list[str], list[str]]:
    filtered: list[str] = []
    missing: list[str] = []
    for ligand_id in ligand_ids:
        if ligand_id in prepared_ids:
            filtered.append(ligand_id)
        else:
            missing.append(ligand_id)
    return filtered, missing


def _filter_rows_to_prepared_sdf(
    rows: list[dict[str, Any]],
    prepared_ids: set[str],
) -> tuple[list[dict[str, Any]], list[str]]:
    ordered_ids = [str(row.get("ligand_id", "")) for row in rows]
    filtered_ids, missing_ids = filter_ligand_ids_to_prepared_sdf(ordered_ids, prepared_ids)
    filtered_id_set = set(filtered_ids)
    filtered_rows = [row for row in rows if str(row.get("ligand_id", "")) in filtered_id_set]
    return filtered_rows, missing_ids


def _subset_dataset(
    dataset_dir: Path,
    out_dir: Path,
    evaluation_universe_size: int,
    evaluation_universe_seed: int,
) -> tuple[Path, list[dict[str, Any]], dict[str, Any]]:
    metadata_rows = read_ligand_metadata(dataset_dir / "ligands" / "ligand_metadata.csv")
    block_map = _load_input_block_map(require_file(dataset_dir / "ligands" / "all_ligands.sdf", "prepared ligands sdf"))
    prepared_ids = set(block_map)
    filtered_metadata_rows, missing_prepared_ids = _filter_rows_to_prepared_sdf(metadata_rows, prepared_ids)
    if evaluation_universe_size <= 0:
        raise RDockPipelineError("evaluation_universe_size must be > 0")
    if missing_prepared_ids:
        print(
            "WARNING: "
            f"Dropping {len(missing_prepared_ids)} ligand IDs absent from prepared SDF before evaluation universe sampling. "
            f"Examples: {missing_prepared_ids[:10]}"
        )
    effective_universe_target = min(evaluation_universe_size, len(filtered_metadata_rows))
    sampled_rows = _sample_reference_rows(
        filtered_metadata_rows,
        effective_universe_target,
        evaluation_universe_seed,
        1,
        50,
    )
    if not sampled_rows:
        raise RDockPipelineError("Evaluation universe sampling produced no ligands")
    subset_dir = out_dir / "evaluation_dataset"
    if subset_dir.exists():
        shutil.rmtree(subset_dir)
    (subset_dir / "ligands").mkdir(parents=True, exist_ok=True)
    (subset_dir / "target").mkdir(parents=True, exist_ok=True)
    (subset_dir / "qc").mkdir(parents=True, exist_ok=True)
    (subset_dir / "logs").mkdir(parents=True, exist_ok=True)
    shutil.copytree(dataset_dir / "target" / "rdock_prm", subset_dir / "target" / "rdock_prm", dirs_exist_ok=True)
    for name in ("target.mol2", "reference_ligand.sdf"):
        src = dataset_dir / "target" / name
        if src.exists():
            shutil.copy2(src, subset_dir / "target" / name)
    for name in ("invalid_ligands.csv", "all_ligands.smi", "ligand_preparation_progress.json"):
        src = dataset_dir / "ligands" / name
        if src.exists():
            shutil.copy2(src, subset_dir / "ligands" / name)
    prep_report = dataset_dir / "qc" / "preparation_report.md"
    if prep_report.exists():
        shutil.copy2(prep_report, subset_dir / "qc" / "preparation_report.md")
    for name in ("pubchem_diagnostics.json", "pubchem_progress.json", "pubchem_progress.log", "commands.log"):
        src = dataset_dir / "logs" / name
        if src.exists():
            shutil.copy2(src, subset_dir / "logs" / name)
    raw_dir = dataset_dir / "raw"
    if raw_dir.exists():
        shutil.copytree(raw_dir, subset_dir / "raw", dirs_exist_ok=True)

    selected_ids = [str(row["ligand_id"]) for row in sampled_rows]
    _write_selected_sdf(block_map, selected_ids, subset_dir / "ligands" / "all_ligands.sdf")
    write_rows_csv(sampled_rows, subset_dir / "ligands" / "ligand_metadata.csv")
    manifest = _read_json(dataset_dir / "dataset_manifest.json")
    manifest["evaluation_universe_size"] = len(sampled_rows)
    manifest["requested_evaluation_universe_size"] = int(evaluation_universe_size)
    manifest["effective_evaluation_universe_size"] = len(sampled_rows)
    manifest["source_dataset_dir"] = str(dataset_dir)
    manifest["ligands_prepared"] = len(sampled_rows)
    manifest["n_prepared_ligands"] = len(sampled_rows)
    manifest["n_unique_parent_ligands"] = len(sampled_rows)
    manifest["evaluation_universe_seed"] = evaluation_universe_seed
    manifest["prepared_sdf_ligand_count"] = len(prepared_ids)
    manifest["metadata_ligand_count"] = len(metadata_rows)
    manifest["missing_prepared_ligands_count"] = len(missing_prepared_ids)
    manifest["missing_prepared_ligands_examples"] = missing_prepared_ids[:10]
    manifest["dropped_missing_prepared_ligands_count"] = len(missing_prepared_ids)
    _write_json(subset_dir / "dataset_manifest.json", manifest)
    diagnostics = {
        "requested_evaluation_universe_size": int(evaluation_universe_size),
        "effective_evaluation_universe_size": len(sampled_rows),
        "prepared_sdf_ligand_count": len(prepared_ids),
        "metadata_ligand_count": len(metadata_rows),
        "missing_prepared_ligands_count": len(missing_prepared_ids),
        "missing_prepared_ligands_examples": missing_prepared_ids[:10],
        "dropped_missing_prepared_ligands_count": len(missing_prepared_ids),
    }
    return subset_dir, sampled_rows, diagnostics


def _cost_balance_status(summary: dict[str, Any], tolerance: float = 0.05) -> tuple[bool, list[str]]:
    by_strategy = dict(summary.get("by_strategy", {}))
    costs = {
        strategy: float(item["median_total_runs_spent"])
        for strategy, item in by_strategy.items()
        if item.get("median_total_runs_spent") is not None
    }
    reasons: list[str] = []
    if not costs:
        return False, ["missing_cost_metrics"]
    baseline = min(costs.values())
    for strategy, value in costs.items():
        if baseline <= 0:
            continue
        if abs(value - baseline) / baseline > tolerance:
            reasons.append(f"cost_imbalance:{strategy}")
    return len(reasons) == 0, reasons


def benchmark_comparable_adaptive(args: argparse.Namespace) -> dict[str, Any]:
    dataset_dir = Path(args.dataset_dir)
    validate_dataset_dir(dataset_dir, check_rdock_tools=False)
    out_dir = Path(args.out)
    if getattr(args, "force", False) and out_dir.exists():
        shutil.rmtree(out_dir)
    out_dir.mkdir(parents=True, exist_ok=True)

    subset_dir, sampled_rows, subset_diagnostics = _subset_dataset(
        dataset_dir,
        out_dir,
        int(args.evaluation_universe_size),
        int(args.evaluation_universe_seed),
    )
    write_rows_csv(sampled_rows, out_dir / "tables" / "evaluation_universe.csv")

    strategy_args = Namespace(
        dataset_dir=str(subset_dir),
        reference_mode=str(args.reference_mode),
        reference_sample_size=int(getattr(args, "reference_sample_size", 0)),
        reference_sample_seed=int(getattr(args, "reference_sample_seed", args.evaluation_universe_seed)),
        strategies=str(args.strategies),
        triage_target_recall=float(getattr(args, "triage_target_recall", 0.95)),
        triage_retain_fraction=float(getattr(args, "triage_retain_fraction", 0.05)),
        calibration_size=int(getattr(args, "calibration_size", 1000)),
        fidelity_validation_size=int(getattr(args, "fidelity_validation_size", 100)),
        cost_budget_runs=int(args.cost_budget_runs),
        fidelity_levels=str(args.fidelity_levels),
        triage_model=str(getattr(args, "triage_model", "classifier")),
        classifier_top_percentile=float(getattr(args, "classifier_top_percentile", 0.05)),
        classifier_threshold_mode=str(getattr(args, "classifier_threshold_mode", "recall_target")),
        classifier_min_positives=int(getattr(args, "classifier_min_positives", 10)),
        classifier_holdout_fraction=float(getattr(args, "classifier_holdout_fraction", 0.25)),
        classifier_fallback=str(getattr(args, "classifier_fallback", "cluster_only")),
        model_fallback_if_worse=str(getattr(args, "model_fallback_if_worse", "none")),
        survivor_combination_policy=str(getattr(args, "survivor_combination_policy", "model_only")),
        adaptive_policy=str(getattr(args, "adaptive_policy", "cluster_bandit")),
        adaptive_policies="",
        regressor_contribution_mode=str(getattr(args, "regressor_contribution_mode", "gate")),
        classifier_weight=float(getattr(args, "classifier_weight", 1.0)),
        regressor_weight=float(getattr(args, "regressor_weight", 0.2)),
        cluster_quality_weight=float(getattr(args, "cluster_quality_weight", 0.4)),
        fixed_score_regressor_name=str(getattr(args, "fixed_score_regressor_name", "fixed_score_regressor_v1")),
        fixed_score_regressor_target=str(getattr(args, "fixed_score_regressor_target", "component_sane_affinity_like")),
        regressor_model_type=str(getattr(args, "regressor_model_type", "extra_trees")),
        promotion_policy=str(getattr(args, "promotion_policy", "quota_ladder")),
        exploration_fraction=float(getattr(args, "exploration_fraction", 0.35)),
        diversity_weight=float(getattr(args, "diversity_weight", 0.75)),
        uncertainty_weight=float(getattr(args, "uncertainty_weight", 0.2)),
        outlier_risk_weight=float(getattr(args, "outlier_risk_weight", 2.0)),
        min_per_cluster=int(getattr(args, "min_per_cluster", 1)),
        max_per_cluster=int(getattr(args, "max_per_cluster", 50)),
        triage_max_survivors=int(getattr(args, "triage_max_survivors", 0)),
        cluster_quota=int(getattr(args, "cluster_quota", 0)),
        promotion_temperature=float(getattr(args, "promotion_temperature", 1.0)),
        diagnostics_level=str(getattr(args, "diagnostics_level", "standard")),
        classifier_gate_fraction=float(getattr(args, "classifier_gate_fraction", 0.15)),
        classifier_max_gate_fraction=float(getattr(args, "classifier_max_gate_fraction", 0.2)),
        seeds=str(getattr(args, "seeds", "1,2,3")),
        jobs=str(args.jobs),
        chunk_size=int(args.chunk_size),
        rdock_timeout_seconds=int(args.rdock_timeout_seconds),
        cpu_fraction=float(args.cpu_fraction),
        out=str(out_dir / "strategy_runs"),
        force=bool(getattr(args, "force", False)),
        resume=bool(getattr(args, "resume", False)),
        model_validation_split=str(getattr(args, "model_validation_split", "cluster")),
    )
    strategy_payload = benchmark_triage_strategies(strategy_args)
    summary = dict(strategy_payload.get("summary", {}))
    comparable, reasons = _cost_balance_status(summary)
    if str(args.reference_mode).lower() == "none":
        comparable = False
        reasons.append("reference_mode_none")
    manifest = {
        "dataset_dir": str(dataset_dir),
        "evaluation_universe_dataset_dir": str(subset_dir),
        "evaluation_universe_size": len(sampled_rows),
        "requested_evaluation_universe_size": subset_diagnostics["requested_evaluation_universe_size"],
        "effective_evaluation_universe_size": subset_diagnostics["effective_evaluation_universe_size"],
        "evaluation_universe_seed": int(args.evaluation_universe_seed),
        "evaluation_universe_hash": _stable_json_hash({"ligand_ids": [str(row["ligand_id"]) for row in sampled_rows]}),
        "prepared_sdf_ligand_count": subset_diagnostics["prepared_sdf_ligand_count"],
        "metadata_ligand_count": subset_diagnostics["metadata_ligand_count"],
        "missing_prepared_ligands_count": subset_diagnostics["missing_prepared_ligands_count"],
        "missing_prepared_ligands_examples": subset_diagnostics["missing_prepared_ligands_examples"],
        "dropped_missing_prepared_ligands_count": subset_diagnostics["dropped_missing_prepared_ligands_count"],
        "reference_mode": str(args.reference_mode),
        "strategies": str(args.strategies).split(","),
        "comparable": comparable,
        "reasons": reasons,
    }
    _write_json(out_dir / "metrics" / "comparable_benchmark_manifest.json", manifest)
    report_lines = [
        "# benchmark-comparable-adaptive",
        "",
        f"- comparable: `{comparable}`",
        f"- reasons: `{','.join(reasons)}`",
        f"- evaluation_universe_size: `{len(sampled_rows)}`",
        f"- requested_evaluation_universe_size: `{subset_diagnostics['requested_evaluation_universe_size']}`",
        f"- effective_evaluation_universe_size: `{subset_diagnostics['effective_evaluation_universe_size']}`",
        f"- prepared_sdf_ligand_count: `{subset_diagnostics['prepared_sdf_ligand_count']}`",
        f"- metadata_ligand_count: `{subset_diagnostics['metadata_ligand_count']}`",
        f"- missing_prepared_ligands_count: `{subset_diagnostics['missing_prepared_ligands_count']}`",
        f"- missing_prepared_ligands_examples: `{subset_diagnostics['missing_prepared_ligands_examples']}`",
        f"- evaluation_universe_dataset_dir: `{subset_dir}`",
        f"- strategy_run_dir: `{out_dir / 'strategy_runs'}`",
    ]
    if comparable:
        report_lines.append(f"- recommended_strategy_final: `{summary.get('recommended_strategy_final')}`")
    else:
        report_lines.append("- gain_reporting: `disabled_until_comparable`")
    (out_dir / "report.md").write_text("\n".join(report_lines) + "\n", encoding="utf-8")
    return {"run_dir": str(out_dir), "strategy_payload": strategy_payload, "manifest": manifest}


def build_arg_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(description="Run a comparable adaptive docking benchmark on a frozen evaluation universe.")
    parser.add_argument("--dataset-dir", required=True)
    parser.add_argument("--evaluation-universe-size", type=int, required=True)
    parser.add_argument("--evaluation-universe-seed", type=int, default=42)
    parser.add_argument("--reference-mode", default="full", choices=["full", "sampled", "none"])
    parser.add_argument("--reference-sample-size", type=int, default=0)
    parser.add_argument("--reference-sample-seed", type=int, default=42)
    parser.add_argument("--strategies", required=True)
    parser.add_argument("--cost-budget-runs", type=int, required=True)
    parser.add_argument("--fidelity-levels", default="5,10,15,30,50")
    parser.add_argument("--promotion-policy", default="quota_ladder")
    parser.add_argument("--min-final-ligands", type=int, default=200)
    parser.add_argument("--triage-target-recall", type=float, default=0.95)
    parser.add_argument("--triage-retain-fraction", type=float, default=0.05)
    parser.add_argument("--calibration-size", type=int, default=1000)
    parser.add_argument("--fidelity-validation-size", type=int, default=100)
    parser.add_argument("--adaptive-policy", default="cluster_bandit")
    parser.add_argument("--regressor-contribution-mode", default="gate")
    parser.add_argument("--classifier-weight", type=float, default=1.0)
    parser.add_argument("--regressor-weight", type=float, default=0.2)
    parser.add_argument("--cluster-quality-weight", type=float, default=0.4)
    parser.add_argument("--diversity-weight", type=float, default=0.75)
    parser.add_argument("--uncertainty-weight", type=float, default=0.2)
    parser.add_argument("--outlier-risk-weight", type=float, default=2.0)
    parser.add_argument("--classifier-top-percentile", type=float, default=0.05)
    parser.add_argument("--classifier-threshold-mode", default="recall_target")
    parser.add_argument("--classifier-min-positives", type=int, default=10)
    parser.add_argument("--classifier-holdout-fraction", type=float, default=0.25)
    parser.add_argument("--classifier-fallback", default="cluster_only")
    parser.add_argument("--model-fallback-if-worse", default="none")
    parser.add_argument("--survivor-combination-policy", default="model_only")
    parser.add_argument("--fixed-score-regressor-name", default="fixed_score_regressor_v1")
    parser.add_argument("--fixed-score-regressor-target", default="component_sane_affinity_like")
    parser.add_argument("--regressor-model-type", default="extra_trees")
    parser.add_argument("--model-validation-split", default="cluster", choices=["random", "cluster"])
    parser.add_argument("--diagnostics-level", default="standard", choices=["minimal", "standard", "full"])
    parser.add_argument("--classifier-gate-fraction", type=float, default=0.15)
    parser.add_argument("--classifier-max-gate-fraction", type=float, default=0.2)
    parser.add_argument("--seeds", default="1,2,3")
    parser.add_argument("--jobs", default="auto")
    parser.add_argument("--chunk-size", type=int, default=10)
    parser.add_argument("--rdock-timeout-seconds", type=int, default=1800)
    parser.add_argument("--cpu-fraction", type=float, default=0.85)
    parser.add_argument("--out", required=True)
    parser.add_argument("--resume", action="store_true")
    parser.add_argument("--force", action="store_true")
    return parser


def run_from_args(args: argparse.Namespace) -> dict[str, Any]:
    return benchmark_comparable_adaptive(args)