from __future__ import annotations import argparse import csv import json import random import shutil import sys import time from pathlib import Path from typing import Any ROOT = Path(__file__).resolve().parents[1] if str(ROOT) not in sys.path: sys.path.insert(0, str(ROOT)) from docking_pipeline.provenance import CommandRunner, RDockPipelineError, fail_if_bad_command, probe_version, require_executable, require_file from docking_pipeline.rdock import RDockEngine, RDockRunConfig, TargetConfig from docking_pipeline.reports.plots import plot_adaptive_benchmark_outputs, plot_score_outputs from docking_pipeline.sdf import ligand_id_from_block, parse_tags, split_sdf_file, write_rows_csv, write_sdf_blocks def _read_rows(path: str | Path) -> list[dict[str, str]]: with Path(path).open("r", encoding="utf-8", newline="") as handle: return list(csv.DictReader(handle)) def _float(value: object, default: float = 0.0) -> float: try: text = str(value).strip() if not text: return default return float(text) except Exception: return default def _boolish(value: object) -> bool: return str(value).strip().lower() in {"1", "true", "yes", "y"} def _write_json(path: Path, payload: dict[str, Any] | list[dict[str, Any]]) -> None: path.parent.mkdir(parents=True, exist_ok=True) path.write_text(json.dumps(payload, indent=2), encoding="utf-8") def _load_targets(path: Path) -> list[dict[str, str]]: text = require_file(path, "benchmark targets config").read_text(encoding="utf-8") payload = json.loads(text) targets = payload.get("targets", []) if not isinstance(targets, list) or not targets: raise RDockPipelineError(f"No targets defined in {path}") return [dict(item) for item in targets] def _extract_receptor_and_ligand( pdb: Path, receptor_chain: str, ligand_resname: str, ligand_chain: str, out_dir: Path, ) -> tuple[Path, Path]: out_dir.mkdir(parents=True, exist_ok=True) receptor = out_dir / "receptor.pdb" ligand_pdb = out_dir / "reference_ligand.pdb" receptor_lines: list[str] = [] ligand_lines: list[str] = [] chains = {c.strip() for c in receptor_chain.split(",") if c.strip()} wanted_resname = ligand_resname.upper().strip() wanted_chain = ligand_chain.strip() for line in pdb.read_text(encoding="utf-8", errors="ignore").splitlines(): record = line[:6].strip() chain = line[21:22].strip() resname = line[17:20].strip().upper() if record == "ATOM" and (not chains or chain in chains): receptor_lines.append(line) if record == "HETATM" and resname == wanted_resname and (not wanted_chain or chain == wanted_chain): ligand_lines.append(line) if not receptor_lines: raise RDockPipelineError(f"No receptor atoms found in {pdb} for chain(s) {receptor_chain}") if not ligand_lines: raise RDockPipelineError(f"No reference ligand {wanted_resname} chain {wanted_chain or '*'} found in {pdb}") receptor.write_text("\n".join(receptor_lines + ["END", ""]), encoding="utf-8") ligand_pdb.write_text("\n".join(ligand_lines + ["END", ""]), encoding="utf-8") return receptor, ligand_pdb def _obabel_convert(runner: CommandRunner, stage: str, input_path: Path, output_path: Path, extra_args: list[str], cwd: Path) -> Path: obabel = require_executable("obabel") rec = runner.run( stage, [obabel, str(input_path.resolve()), *extra_args, "-O", str(output_path.resolve())], cwd, cwd / f"{stage}.stdout.log", cwd / f"{stage}.stderr.log", ) fail_if_bad_command(rec, f"OpenBabel {stage}") return require_file(output_path, f"OpenBabel output {stage}") def _count_sdf(path: Path) -> int: return len(split_sdf_file(path)) def _write_ligand_smi(rows: list[dict[str, str]], out_path: Path, count: int) -> Path: selected = rows[:count] if len(selected) != count: raise RDockPipelineError(f"Requested {count} ligands but only found {len(selected)} rows in {out_path.parent}") out_path.parent.mkdir(parents=True, exist_ok=True) out_path.write_text("".join(f"{row['smiles']} {row['ligand_id']}\n" for row in selected), encoding="utf-8") return out_path def _load_input_block_map(sdf_path: Path) -> dict[str, str]: block_map: dict[str, str] = {} for idx, block in enumerate(split_sdf_file(sdf_path)): tags = parse_tags(block) ligand_id = ligand_id_from_block(block, tags, idx) block_map[ligand_id] = block return block_map def _write_selected_sdf(block_map: dict[str, str], ligand_ids: list[str], out_path: Path) -> Path: missing = [ligand_id for ligand_id in ligand_ids if ligand_id not in block_map] if missing: raise RDockPipelineError(f"Missing {len(missing)} ligand IDs in prepared SDF: {missing[:10]}") write_sdf_blocks([block_map[ligand_id] for ligand_id in ligand_ids], out_path) return out_path def _prepare_library( runner: CommandRunner, ligands_csv: Path, ligand_count: int, out_dir: Path, resume: bool, ) -> tuple[list[dict[str, str]], Path]: rows = _read_rows(ligands_csv) if len(rows) < ligand_count: raise RDockPipelineError(f"{ligands_csv} contains {len(rows)} ligands, expected at least {ligand_count}") selected = rows[:ligand_count] smi = out_dir / "ligands" / "all_ligands.smi" sdf = out_dir / "ligands" / "all_ligands.sdf" if not (resume and sdf.exists() and _count_sdf(sdf) == ligand_count): _write_ligand_smi(selected, smi, ligand_count) _obabel_convert(runner, "smiles_to_all_ligands_sdf", smi, sdf, ["--gen3d", "-h"], out_dir) if _count_sdf(sdf) != ligand_count: raise RDockPipelineError(f"{sdf} does not contain exactly {ligand_count} ligands") return selected, sdf def _build_model_rows(rows: list[dict[str, str]]) -> list[dict[str, Any]]: numeric_keys = [ "reference_similarity", "molecular_weight", "xlogp", "tpsa", "hbd", "hba", "rotatable_bonds", "heavy_atom_count", ] features: dict[str, list[float]] = {key: [] for key in numeric_keys} parsed: list[dict[str, Any]] = [] for row in rows: item: dict[str, Any] = dict(row) item["scaffold_match_num"] = 1.0 if _boolish(row.get("scaffold_match", "")) else 0.0 item["is_reference_num"] = 1.0 if _boolish(row.get("is_reference", "")) else 0.0 sim = _float(row.get("reference_similarity"), 0.0) item["model_score"] = sim + 0.1 * item["scaffold_match_num"] + 0.05 * item["is_reference_num"] for key in numeric_keys: value = _float(row.get(key), 0.0) item[key] = value features[key].append(value) parsed.append(item) means = {key: (sum(vals) / len(vals) if vals else 0.0) for key, vals in features.items()} stdevs = {} for key, vals in features.items(): if not vals: stdevs[key] = 1.0 continue mean = means[key] var = sum((value - mean) ** 2 for value in vals) / max(1, len(vals)) stdevs[key] = var**0.5 or 1.0 for item in parsed: item["feature_vector"] = [ (float(item[key]) - means[key]) / stdevs[key] for key in numeric_keys ] + [float(item["scaffold_match_num"]), float(item["is_reference_num"])] item["adaptive_priority"] = float(item["model_score"]) item["actually_docked"] = False return parsed def _distance(a: list[float], b: list[float]) -> float: return sum((x - y) ** 2 for x, y in zip(a, b)) ** 0.5 class AdaptiveSurrogateScheduler: def __init__(self, rows: list[dict[str, Any]], budget: int, batch_size: int) -> None: self.rows = [dict(row) for row in rows] self.by_id = {str(row["ligand_id"]): row for row in self.rows} self.budget = int(budget) self.batch_size = int(batch_size) self.completed: list[str] = [] self.observed_scores: dict[str, float] = {} self.attempted: set[str] = set() def next_batch(self) -> list[str]: remaining = [row for row in self.rows if str(row["ligand_id"]) not in self.attempted] remaining_budget = self.budget - len(self.attempted) if remaining_budget <= 0 or not remaining: return [] ordered = sorted( remaining, key=lambda row: (-float(row["adaptive_priority"]), -float(row["model_score"]), str(row["ligand_id"])), ) batch = [str(row["ligand_id"]) for row in ordered[: min(self.batch_size, remaining_budget)]] return batch def update(self, selected_ids: list[str], best_rows: list[dict[str, str]]) -> float: start = time.time() for ligand_id in selected_ids: self.attempted.add(str(ligand_id)) for row in best_rows: ligand_id = str(row["ligand_id"]) score = _float(row.get("SCORE"), 0.0) self.observed_scores[ligand_id] = score self.by_id[ligand_id]["actually_docked"] = True self.completed.append(ligand_id) docked_ids = list(self.observed_scores) if not docked_ids: return 0.0 for row in self.rows: ligand_id = str(row["ligand_id"]) if ligand_id in self.observed_scores: row["adaptive_priority"] = 1e9 - self.observed_scores[ligand_id] continue neighbors: list[tuple[float, float]] = [] for docked_id in docked_ids: docked_row = self.by_id[docked_id] dist = _distance(row["feature_vector"], docked_row["feature_vector"]) neighbors.append((dist, self.observed_scores[docked_id])) neighbors.sort(key=lambda item: item[0]) top = neighbors[: min(12, len(neighbors))] weights = [1.0 / (1.0 + dist) for dist, _ in top] total_weight = sum(weights) or 1.0 predicted = sum(weight * score for weight, (_, score) in zip(weights, top)) / total_weight prior = -10.0 * float(row["model_score"]) uncertainty = sum(dist for dist, _ in top) / max(1, len(top)) blended = (0.7 * predicted) + (0.3 * prior) row["adaptive_priority"] = -blended + (0.05 * uncertainty) return time.time() - start def _read_result_rows(path: Path) -> list[dict[str, str]]: return _read_rows(path) if path.exists() else [] def _augment_full_rows(rows: list[dict[str, str]]) -> list[dict[str, Any]]: ordered = sorted(rows, key=lambda row: (_float(row.get("SCORE"), float("inf")), str(row.get("ligand_id", "")))) total = max(1, len(ordered)) enriched: list[dict[str, Any]] = [] for idx, row in enumerate(ordered, start=1): item: dict[str, Any] = dict(row) item["full_rank"] = idx item["full_percentile"] = 100.0 if total == 1 else 100.0 * (1.0 - ((idx - 1) / (total - 1))) enriched.append(item) return enriched def _percentile_from_rank(rank: int, total: int) -> float: if total <= 1: return 100.0 return 100.0 * (1.0 - ((rank - 1) / (total - 1))) def _append_rank_metrics(rows: list[dict[str, Any]], full_rank_map: dict[str, int], total: int) -> list[dict[str, Any]]: enriched: list[dict[str, Any]] = [] for row in rows: item = dict(row) ligand_id = str(item["ligand_id"]) rank = full_rank_map.get(ligand_id) item["full_rank"] = rank if rank is not None else "" item["full_percentile"] = _percentile_from_rank(rank, total) if rank is not None else "" enriched.append(item) return enriched def _top_overlap(full_rows: list[dict[str, Any]], sample_rows: list[dict[str, Any]], n: int) -> int: full_top = {str(row["ligand_id"]) for row in full_rows[:n]} sample_top = {str(row["ligand_id"]) for row in sorted(sample_rows, key=lambda row: _float(row.get("SCORE"), float("inf")))[:n]} return len(full_top & sample_top) def _copy_full_aliases(root: Path, target_config: TargetConfig, full_rows: list[dict[str, Any]], n_runs: int) -> None: target_dir = root / "target" target_dir.mkdir(parents=True, exist_ok=True) shutil.copy2(require_file(target_config.receptor_mol2, "target mol2"), target_dir / "target.mol2") shutil.copy2(require_file(target_config.reference_ligand, "reference ligand"), target_dir / "reference_ligand.sdf") shutil.copy2(require_file(target_config.receptor_prm, "target prm"), target_dir / "target.prm") shutil.copy2(require_file(target_config.cavity_as, "cavity"), target_dir / Path(target_config.cavity_as).name) best_path = root / "poses" / f"best_ligand_{n_runs}.sdf" require_file(best_path, f"best_ligand_{n_runs}.sdf") if not full_rows: raise RDockPipelineError(f"No full docking rows found in {root}") def _target_complete(root: Path, ligand_count: int, budget: int, n_runs: int) -> bool: required = [ root / "ligands" / "all_ligands.sdf", root / "tables" / "full_docking_scores.csv", root / "tables" / "adaptive_scores.csv", root / "tables" / "random_baseline_scores.csv", root / "metrics" / "adaptive_benchmark_metrics.json", root / "metrics" / "rdock_metrics.json", root / "poses" / f"best_ligand_{n_runs}.sdf", ] if not all(path.exists() for path in required): return False if _count_sdf(root / "ligands" / "all_ligands.sdf") != ligand_count: return False adaptive_rows = _read_result_rows(root / "tables" / "adaptive_scores.csv") random_rows = _read_result_rows(root / "tables" / "random_baseline_scores.csv") return len(adaptive_rows) >= budget and len(random_rows) >= budget def _run_full_docking( engine: RDockEngine, target_config: TargetConfig, all_ligands_sdf: Path, target_root: Path, n_runs: int, jobs: str, resume: bool, ) -> tuple[dict[str, Any], list[dict[str, Any]], float]: start = time.time() artifacts = engine.dock_sdf(target_config, all_ligands_sdf, target_root, n_runs=n_runs, jobs=jobs, run_id=target_root.name, resume=resume) elapsed = time.time() - start full_rows = _augment_full_rows(_read_rows(artifacts.best_per_ligand_csv)) write_rows_csv(full_rows, target_root / "tables" / "best_per_ligand.csv") write_rows_csv(full_rows, target_root / "tables" / "full_docking_scores.csv") metrics = { "library_size": len(full_rows), "successful_ligands": len(full_rows), "failed_ligands": max(0, _count_sdf(all_ligands_sdf) - len(full_rows)), "pose_count": _count_sdf(Path(artifacts.all_poses_sdf)), "best_SCORE": _float(full_rows[0]["SCORE"]) if full_rows else None, "full_docking_seconds": elapsed, "n_runs": int(n_runs), "best_ligand_id": full_rows[0]["ligand_id"] if full_rows else None, } _write_json(target_root / "metrics" / "rdock_metrics.json", metrics) return metrics, full_rows, elapsed def _run_random_baseline( engine: RDockEngine, target_config: TargetConfig, target_root: Path, all_blocks: dict[str, str], rows: list[dict[str, Any]], budget: int, n_runs: int, jobs: str, resume: bool, seed: int = 42, ) -> tuple[list[dict[str, Any]], float]: random_root = target_root / "random_run" existing = _read_result_rows(random_root / "tables" / "best_per_ligand.csv") if resume and len(existing) >= budget: return [dict(row) for row in existing[:budget]], 0.0 random_root.mkdir(parents=True, exist_ok=True) population = [str(row["ligand_id"]) for row in rows] selected_ids = random.Random(seed).sample(population, budget) _write_json(random_root / "selection.json", {"seed": seed, "ligand_ids": selected_ids}) baseline_sdf = random_root / "ligands" / "random_baseline.sdf" _write_selected_sdf(all_blocks, selected_ids, baseline_sdf) start = time.time() engine.dock_sdf(target_config, baseline_sdf, random_root, n_runs=n_runs, jobs=jobs, run_id=f"{target_root.name}_random", resume=resume) elapsed = time.time() - start random_rows = [] selected_map = {ligand_id: idx + 1 for idx, ligand_id in enumerate(selected_ids)} for row in _read_rows(random_root / "tables" / "best_per_ligand.csv"): item: dict[str, Any] = dict(row) item["selection_order"] = selected_map.get(str(item["ligand_id"]), "") item["strategy"] = "random" random_rows.append(item) random_rows.sort(key=lambda row: int(row.get("selection_order", 0) or 0)) write_rows_csv(random_rows, target_root / "tables" / "random_baseline_scores.csv") return random_rows, elapsed def _run_adaptive_benchmark( engine: RDockEngine, target_config: TargetConfig, target_root: Path, all_blocks: dict[str, str], rows: list[dict[str, Any]], budget: int, batch_size: int, n_runs: int, jobs: str, resume: bool, ) -> tuple[list[dict[str, Any]], list[dict[str, Any]], float, float]: adaptive_root = target_root / "adaptive_run" adaptive_root.mkdir(parents=True, exist_ok=True) scheduler = AdaptiveSurrogateScheduler(rows, budget=budget, batch_size=batch_size) adaptive_rows: list[dict[str, Any]] = [] batch_metrics: list[dict[str, Any]] = [] docking_seconds = 0.0 model_seconds = 0.0 batch_index = 0 while True: batch_ids = scheduler.next_batch() if not batch_ids: break batch_dir = adaptive_root / "rdock" / f"batch_{batch_index:03d}" selection_path = batch_dir / "selection.json" if resume and selection_path.exists(): payload = json.loads(selection_path.read_text(encoding="utf-8")) batch_ids = [str(x) for x in payload.get("ligand_ids", batch_ids)] else: batch_dir.mkdir(parents=True, exist_ok=True) selection_payload = { "batch_index": batch_index, "ligand_ids": batch_ids, "selection_state": [ { "ligand_id": ligand_id, "model_score": scheduler.by_id[ligand_id]["model_score"], "adaptive_priority": scheduler.by_id[ligand_id]["adaptive_priority"], } for ligand_id in batch_ids ], } _write_json(selection_path, selection_payload) batch_sdf = adaptive_root / "ligands" / f"batch_{batch_index:03d}.sdf" if not (resume and batch_sdf.exists() and _count_sdf(batch_sdf) == len(batch_ids)): _write_selected_sdf(all_blocks, batch_ids, batch_sdf) batch_start = time.time() engine.dock_sdf(target_config, batch_sdf, batch_dir, n_runs=n_runs, jobs=jobs, run_id=f"{target_root.name}_adaptive_batch_{batch_index:03d}", resume=resume) batch_docking_seconds = time.time() - batch_start docking_seconds += batch_docking_seconds batch_best = _read_rows(batch_dir / "tables" / "best_per_ligand.csv") selection_meta = json.loads(selection_path.read_text(encoding="utf-8")) selection_lookup = {str(item["ligand_id"]): item for item in selection_meta.get("selection_state", [])} batch_rows: list[dict[str, Any]] = [] for local_index, row in enumerate(batch_best, start=1): ligand_id = str(row["ligand_id"]) selection_item = selection_lookup.get(ligand_id, {}) item: dict[str, Any] = dict(row) item["batch"] = batch_index item["selection_order"] = (batch_index * batch_size) + local_index item["model_score"] = selection_item.get("model_score", scheduler.by_id[ligand_id]["model_score"]) item["adaptive_priority"] = selection_item.get("adaptive_priority", scheduler.by_id[ligand_id]["adaptive_priority"]) item["strategy"] = "adaptive" batch_rows.append(item) adaptive_rows.extend(batch_rows) update_seconds = scheduler.update(batch_ids, batch_best) model_seconds += update_seconds batch_metrics.append( { "batch": batch_index, "selected_count": len(batch_ids), "successful_count": len(batch_best), "failed_count": max(0, len(batch_ids) - len(batch_best)), "docking_seconds": batch_docking_seconds, "model_seconds": update_seconds, "best_score_after_batch": min(_float(row.get("SCORE"), float("inf")) for row in adaptive_rows) if adaptive_rows else "", } ) batch_index += 1 write_rows_csv(adaptive_rows, target_root / "tables" / "adaptive_scores.csv") write_rows_csv(batch_metrics, target_root / "tables" / "adaptive_batches.csv") return adaptive_rows, batch_metrics, docking_seconds, model_seconds def _build_metrics( target_id: str, library_size: int, full_rows: list[dict[str, Any]], adaptive_rows: list[dict[str, Any]], random_rows: list[dict[str, Any]], full_seconds: float, adaptive_docking_seconds: float, adaptive_model_seconds: float, random_seconds: float, ) -> dict[str, Any]: full_rank_map = {str(row["ligand_id"]): int(row["full_rank"]) for row in full_rows} adaptive_ranked = _append_rank_metrics(adaptive_rows, full_rank_map, len(full_rows)) random_ranked = _append_rank_metrics(random_rows, full_rank_map, len(full_rows)) adaptive_best = min(adaptive_ranked, key=lambda row: _float(row.get("SCORE"), float("inf"))) if adaptive_ranked else None random_best = min(random_ranked, key=lambda row: _float(row.get("SCORE"), float("inf"))) if random_ranked else None full_best = full_rows[0] if full_rows else None failed = max(0, library_size - len(full_rows)) return { "target_id": target_id, "total_candidate_library_size": library_size, "full_success_count": len(full_rows), "adaptive_success_count": len(adaptive_ranked), "random_success_count": len(random_ranked), "failed_docking_count": failed, "success_rate": (len(full_rows) / library_size) if library_size else 0.0, "best_full_SCORE": _float(full_best.get("SCORE")) if full_best else None, "best_adaptive_SCORE": _float(adaptive_best.get("SCORE")) if adaptive_best else None, "best_random_SCORE": _float(random_best.get("SCORE")) if random_best else None, "full_best_percentile_of_full": 100.0 if full_best else None, "adaptive_best_percentile_of_full": _float(adaptive_best.get("full_percentile")) if adaptive_best else None, "random_best_percentile_of_full": _float(random_best.get("full_percentile")) if random_best else None, "adaptive_over_random_best_score_delta": (_float(random_best.get("SCORE")) - _float(adaptive_best.get("SCORE"))) if adaptive_best and random_best else None, "adaptive_over_random_percentile_delta": (_float(adaptive_best.get("full_percentile")) - _float(random_best.get("full_percentile"))) if adaptive_best and random_best else None, "top1_overlap_with_full": _top_overlap(full_rows, adaptive_ranked, 1), "top5_overlap_with_full": _top_overlap(full_rows, adaptive_ranked, 5), "top10_overlap_with_full": _top_overlap(full_rows, adaptive_ranked, 10), "random_top1_overlap_with_full": _top_overlap(full_rows, random_ranked, 1), "random_top5_overlap_with_full": _top_overlap(full_rows, random_ranked, 5), "random_top10_overlap_with_full": _top_overlap(full_rows, random_ranked, 10), "full_docking_seconds": full_seconds, "adaptive_docking_seconds": adaptive_docking_seconds, "adaptive_model_seconds": adaptive_model_seconds, "random_docking_seconds": random_seconds, "ligands_docked_by_adaptive": len(adaptive_ranked), "ligands_docked_by_random": len(random_ranked), } def _merge_commands(target_root: Path) -> None: dst = target_root / "commands.log" existing = dst.read_text(encoding="utf-8", errors="ignore") if dst.exists() else "" with dst.open("w", encoding="utf-8") as out: if existing: out.write(existing) for candidate in [ target_root / "prep_commands.log", target_root / "adaptive_run" / "commands.log", target_root / "random_run" / "commands.log", ]: if candidate.exists(): out.write(candidate.read_text(encoding="utf-8", errors="ignore")) if not dst.exists(): dst.write_text("", encoding="utf-8") def _write_target_report(target_root: Path, target: dict[str, str], metrics: dict[str, Any], plots: list[str], notes: list[str]) -> None: report = [ f"# Adaptive + rDock Benchmark: {target['target_id']}", "", "## Input Summary", f"- PDB: `{target['pdb_id']}`", f"- Receptor chain: `{target['receptor_chain']}`", f"- Reference ligand: `{target['reference_ligand_resname']}` chain `{target['reference_ligand_chain']}`", f"- Ligand CSV: `{target['ligands_csv']}`", f"- Library size: `{metrics['total_candidate_library_size']}`", "", "## Metrics", ] for key in [ "best_full_SCORE", "best_adaptive_SCORE", "best_random_SCORE", "adaptive_best_percentile_of_full", "random_best_percentile_of_full", "adaptive_over_random_best_score_delta", "adaptive_over_random_percentile_delta", "full_docking_seconds", "adaptive_docking_seconds", "adaptive_model_seconds", "random_docking_seconds", "ligands_docked_by_adaptive", "ligands_docked_by_random", "failed_docking_count", "success_rate", ]: report.append(f"- {key}: `{metrics.get(key)}`") report.extend(["", "## Plots"]) report.extend([f"- `{path}`" for path in plots] or ["- No plots generated"]) report.extend(["", "## Notes"]) report.extend([f"- {note}" for note in notes] or ["- No extra notes"]) (target_root / "report.md").write_text("\n".join(report) + "\n", encoding="utf-8") def _sanity_checks(target_root: Path, ligand_count: int, budget: int, n_runs: int) -> list[str]: checks: list[str] = [] all_ligands = target_root / "ligands" / "all_ligands.sdf" if _count_sdf(all_ligands) != ligand_count: raise RDockPipelineError(f"{all_ligands} does not contain {ligand_count} ligands") checks.append(f"all_ligands.sdf has {ligand_count} ligands") full_rows = _read_rows(target_root / "tables" / "full_docking_scores.csv") if len(full_rows) != ligand_count: checks.append(f"full docking deviation: expected {ligand_count}, got {len(full_rows)}") else: checks.append("full docking returned expected ligand count") best_ligand = require_file(target_root / "poses" / f"best_ligand_{n_runs}.sdf", f"best_ligand_{n_runs}.sdf") if _count_sdf(best_ligand) != n_runs: checks.append(f"best_ligand_{n_runs}.sdf deviation: expected {n_runs}, got {_count_sdf(best_ligand)}") else: checks.append(f"best_ligand_{n_runs}.sdf contains {n_runs} poses") adaptive_rows = _read_rows(target_root / "tables" / "adaptive_scores.csv") random_rows = _read_rows(target_root / "tables" / "random_baseline_scores.csv") if len(adaptive_rows) < budget: checks.append(f"adaptive deviation: budget {budget}, successful {len(adaptive_rows)}") if len(random_rows) < budget: checks.append(f"random deviation: budget {budget}, successful {len(random_rows)}") if len(adaptive_rows) >= budget and len(random_rows) >= budget: checks.append("adaptive and random produced budget-sized result tables") return checks def run_target(target: dict[str, str], args: argparse.Namespace, out_root: Path) -> dict[str, Any]: target_root = out_root / target["target_id"] if args.resume and _target_complete(target_root, args.ligands_per_target, args.adaptive_budget, args.n_runs): metrics = json.loads((target_root / "metrics" / "adaptive_benchmark_metrics.json").read_text(encoding="utf-8")) return {"target_id": target["target_id"], "status": "resumed_complete", "metrics": metrics, "run_dir": str(target_root)} if target_root.exists() and args.force and not args.resume: shutil.rmtree(target_root) target_root.mkdir(parents=True, exist_ok=True) runner = CommandRunner(target_root / "prep_commands.log") pdb = require_file(target["pdb_path"], f"PDB file for {target['target_id']}") receptor, ligand_pdb = _extract_receptor_and_ligand( pdb, target["receptor_chain"], target["reference_ligand_resname"], target["reference_ligand_chain"], target_root / "target_inputs", ) reference_ligand_sdf = target_root / "target_inputs" / "reference_ligand.sdf" if not (args.resume and reference_ligand_sdf.exists()): _obabel_convert(runner, "reference_ligand_to_sdf", ligand_pdb, reference_ligand_sdf, [], target_root) engine = RDockEngine( RDockRunConfig( n_runs=args.n_runs, jobs=args.jobs, cpu_fraction=args.cpu_fraction, timeout_seconds=3600, ) ) prepared_root = target_root / "target_prepared" if args.resume and (prepared_root / "target_config.yaml").exists(): from docking_pipeline.rdock import load_target_config target_config = load_target_config(prepared_root / "target_config.yaml") else: target_config = engine.prepare_target(receptor, reference_ligand_sdf, prepared_root) rows, all_ligands_sdf = _prepare_library(runner, Path(target["ligands_csv"]), args.ligands_per_target, target_root, args.resume) all_block_map = _load_input_block_map(all_ligands_sdf) model_rows = _build_model_rows(rows) rdock_metrics, full_rows, full_seconds = _run_full_docking(engine, target_config, all_ligands_sdf, target_root, args.n_runs, args.jobs, args.resume) _copy_full_aliases(target_root, target_config, full_rows, args.n_runs) adaptive_rows, batch_rows, adaptive_docking_seconds, adaptive_model_seconds = _run_adaptive_benchmark( engine, target_config, target_root, all_block_map, model_rows, args.adaptive_budget, args.batch_size, args.n_runs, args.jobs, args.resume, ) random_rows, random_seconds = _run_random_baseline( engine, target_config, target_root, all_block_map, model_rows, args.adaptive_budget, args.n_runs, args.jobs, args.resume, ) full_rank_map = {str(row["ligand_id"]): int(row["full_rank"]) for row in full_rows} adaptive_ranked = _append_rank_metrics(adaptive_rows, full_rank_map, len(full_rows)) random_ranked = _append_rank_metrics(random_rows, full_rank_map, len(full_rows)) write_rows_csv(adaptive_ranked, target_root / "tables" / "adaptive_scores.csv") write_rows_csv(random_ranked, target_root / "tables" / "random_baseline_scores.csv") write_rows_csv(batch_rows, target_root / "tables" / "adaptive_batches.csv") metrics = _build_metrics( target["target_id"], args.ligands_per_target, full_rows, adaptive_ranked, random_ranked, full_seconds, adaptive_docking_seconds, adaptive_model_seconds, random_seconds, ) _write_json(target_root / "metrics" / "adaptive_benchmark_metrics.json", metrics) _write_json(target_root / "metrics" / "validation_metrics.json", metrics) plots = [] plots.extend(plot_score_outputs(target_root / "tables" / "full_docking_scores.csv", target_root / "plots", title_prefix=f"{target['target_id']} full")) plots.extend( plot_adaptive_benchmark_outputs( target_root / "tables" / "full_docking_scores.csv", target_root / "tables" / "adaptive_scores.csv", target_root / "tables" / "random_baseline_scores.csv", target_root / "metrics" / "adaptive_benchmark_metrics.json", target_root / "plots", ) ) checks = _sanity_checks(target_root, args.ligands_per_target, args.adaptive_budget, args.n_runs) _merge_commands(target_root) manifest = { "target_id": target["target_id"], "engine": "adaptive-plus-rdock", "target": target, "rdock_metrics": rdock_metrics, "adaptive_metrics": metrics, "plots": plots, "artifacts": { "target_dir": str(target_root / "target"), "ligands_sdf": str(target_root / "ligands" / "all_ligands.sdf"), "all_poses_sdf": str(target_root / "poses" / "all_poses.sdf"), "best_per_ligand_sdf": str(target_root / "poses" / "best_per_ligand.sdf"), "best_ligand_all_poses_sdf": str(target_root / "poses" / f"best_ligand_{args.n_runs}.sdf"), "full_scores": str(target_root / "tables" / "full_docking_scores.csv"), "adaptive_scores": str(target_root / "tables" / "adaptive_scores.csv"), "random_scores": str(target_root / "tables" / "random_baseline_scores.csv"), "report": str(target_root / "report.md"), "commands_log": str(target_root / "commands.log"), }, "sanity_checks": checks, "executables": { "rbdock": probe_version(require_executable("rbdock")), "rbcavity": probe_version(require_executable("rbcavity")), "obabel": probe_version(require_executable("obabel")), }, } _write_json(target_root / "manifest.json", manifest) notes = [ f"Prepared target from {target['pdb_path']}.", f"Library source: {target['ligands_csv']}.", f"Resume mode: {args.resume}.", ] _write_target_report(target_root, target, metrics, plots, notes) return {"target_id": target["target_id"], "status": "completed", "metrics": metrics, "run_dir": str(target_root), "sanity_checks": checks} def _write_aggregate_report(out_root: Path, results: list[dict[str, Any]], args: argparse.Namespace) -> None: lines = [ "# Adaptive + rDock Benchmark on 3 Targets", "", "## Command", f"- targets: `{args.targets}`", f"- ligands_per_target: `{args.ligands_per_target}`", f"- n_runs: `{args.n_runs}`", f"- adaptive_budget: `{args.adaptive_budget}`", f"- batch_size: `{args.batch_size}`", f"- jobs: `{args.jobs}`", f"- cpu_fraction: `{args.cpu_fraction}`", f"- resume: `{args.resume}`", "", "## Target Status", ] for result in results: metrics = result.get("metrics", {}) lines.extend( [ f"- {result['target_id']}: `{result['status']}`", f" best full SCORE `{metrics.get('best_full_SCORE')}`, adaptive `{metrics.get('best_adaptive_SCORE')}`, random `{metrics.get('best_random_SCORE')}`", f" adaptive percentile `{metrics.get('adaptive_best_percentile_of_full')}`, random percentile `{metrics.get('random_best_percentile_of_full')}`", f" full seconds `{metrics.get('full_docking_seconds')}`, adaptive docking `{metrics.get('adaptive_docking_seconds')}`, random `{metrics.get('random_docking_seconds')}`", f" run dir `{result.get('run_dir')}`", ] ) (out_root / "report.md").write_text("\n".join(lines) + "\n", encoding="utf-8") _write_json(out_root / "manifest.json", {"results": results}) def main() -> int: parser = argparse.ArgumentParser(description="Production adaptive + rDock benchmark on 3 PDB targets with 1000 ligands each.") parser.add_argument("--targets", required=True) parser.add_argument("--ligands-per-target", type=int, default=1000) parser.add_argument("--n-runs", type=int, default=50) parser.add_argument("--adaptive-budget", type=int, default=250) parser.add_argument("--batch-size", type=int, default=50) parser.add_argument("--jobs", default="auto") 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") args = parser.parse_args() if args.ligands_per_target != 1000: raise RDockPipelineError("This production benchmark is configured for 1000 ligands per target; do not reduce without explicit approval.") out_root = Path(args.out) out_root.mkdir(parents=True, exist_ok=True) targets = _load_targets(Path(args.targets)) results = [] for target in targets: results.append(run_target(target, args, out_root)) _write_aggregate_report(out_root, results, args) print(json.dumps({"results": results, "out": str(out_root)}, indent=2)) return 0 if __name__ == "__main__": raise SystemExit(main())