from __future__ import annotations import argparse import csv import json import shutil import urllib.request from pathlib import Path import sys from statistics import mean, median 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 from docking_pipeline.reports.plots import plot_score_outputs EXAMPLES = """Example: python scripts/benchmark_pdb_500_smiles.py \\ --pdb-id 4HG7 \\ --receptor-chain A \\ --reference-ligand-resname NUT \\ --smiles-file data/examples/example_500_smiles.smi \\ --max-ligands 500 \\ --out results/benchmarks/pdb_4hg7_500smiles \\ --n-runs 50 \\ --jobs auto \\ --cpu-fraction 0.85 \\ """ def _download_pdb(pdb_id: str, out_dir: Path) -> Path: out_dir.mkdir(parents=True, exist_ok=True) pdb = out_dir / f"{pdb_id.lower()}.pdb" if pdb.exists() and pdb.stat().st_size > 0: return pdb local_matches = sorted(ROOT.glob(f"data/**/*{pdb_id.lower()}*.pdb")) + sorted(ROOT.glob(f"data/**/*{pdb_id.upper()}*.pdb")) for candidate in local_matches: if candidate.is_file() and candidate.stat().st_size > 0: shutil.copy2(candidate, pdb) return pdb url = f"https://files.rcsb.org/download/{pdb_id.upper()}.pdb" urllib.request.urlretrieve(url, pdb) return require_file(pdb, "downloaded PDB") def _extract_receptor_and_ligand( pdb: Path, receptor_chain: str, ligand_resname: str, ligand_chain: str | None, 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()} ligand_resname = ligand_resname.upper() ligand_chain = (ligand_chain or "").strip() for line in pdb.read_text(encoding="utf-8", errors="ignore").splitlines(): rec = line[:6].strip() chain = line[21:22].strip() resname = line[17:20].strip().upper() if rec == "ATOM" and (not chains or chain in chains): receptor_lines.append(line) if rec == "HETATM" and resname == ligand_resname and (not ligand_chain or chain == ligand_chain): ligand_lines.append(line) if not receptor_lines: raise RDockPipelineError(f"No receptor ATOM records found for chain(s) {receptor_chain} in {pdb}") if not ligand_lines: raise RDockPipelineError( f"No reference ligand HETATM records found for resname={ligand_resname} chain={ligand_chain or '*'} 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 _read_smiles(path: Path, max_ligands: int) -> list[tuple[str, str]]: rows: list[tuple[str, str]] = [] for idx, line in enumerate(path.read_text(encoding="utf-8").splitlines()): text = line.strip() if not text or text.startswith("#"): continue parts = text.replace(",", " ").split() smiles = parts[0] ligand_id = parts[1] if len(parts) > 1 else f"lig_{idx:05d}" rows.append((smiles, ligand_id)) if len(rows) >= max_ligands: break if not rows: raise RDockPipelineError(f"No SMILES records found in {path}") return rows def _write_smi(rows: list[tuple[str, str]], path: Path) -> Path: path.parent.mkdir(parents=True, exist_ok=True) path.write_text("\n".join(f"{smi} {lig}" for smi, lig in rows) + "\n", encoding="utf-8") return path def _convert_with_obabel(input_path: Path, output_path: Path, args: list[str], runner: CommandRunner, stage: str, cwd: Path) -> Path: obabel = require_executable("obabel") rec = runner.run( stage, [obabel, str(input_path.resolve()), *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 for {stage}") def _plan(args: argparse.Namespace) -> dict[str, object]: smiles = _read_smiles(Path(args.smiles_file), args.max_ligands) return { "pdb_id": args.pdb_id, "receptor_chain": args.receptor_chain, "reference_ligand_resname": args.reference_ligand_resname, "reference_ligand_chain": args.reference_ligand_chain or "", "smiles_file": args.smiles_file, "ligand_count": len(smiles), "out": args.out, "n_runs": args.n_runs, "jobs": args.jobs, "cpu_fraction": args.cpu_fraction, "commands": [ "download PDB from RCSB if absent", "extract receptor chain and reference ligand", "obabel reference_ligand.pdb -O reference_ligand.sdf", "obabel ligands.smi --gen3d -O ligands.sdf", "rbcavity -r receptor.prm -was", "rbdock chunked by --jobs", ], } def run(args: argparse.Namespace) -> dict[str, object]: out = Path(args.out) if out.exists() and args.force and not (args.dry_run or args.plan_only): shutil.rmtree(out) out.mkdir(parents=True, exist_ok=True) plan = _plan(args) if args.dry_run or args.plan_only: (out / "benchmark_plan.json").write_text(json.dumps(plan, indent=2), encoding="utf-8") print(json.dumps(plan, indent=2)) return {"dry_run": True, "plan": plan} for tool in ("obabel", "rbcavity", "rbdock"): require_executable(tool) runner = CommandRunner(out / "commands.log") pdb = _download_pdb(args.pdb_id, out / "inputs") receptor, ligand_pdb = _extract_receptor_and_ligand(pdb, args.receptor_chain, args.reference_ligand_resname, args.reference_ligand_chain, out / "target") ligand_sdf = _convert_with_obabel(ligand_pdb, out / "target" / "reference_ligand.sdf", [], runner, "reference_ligand_to_sdf", out) smiles_rows = _read_smiles(Path(args.smiles_file), args.max_ligands) smi = _write_smi(smiles_rows, out / "ligands" / "ligands.smi") ligands_sdf = _convert_with_obabel(smi, out / "ligands" / "ligands.sdf", ["--gen3d", "-h"], runner, "smiles_to_3d_sdf", out) engine = RDockEngine( RDockRunConfig( n_runs=args.n_runs, jobs=args.jobs, cpu_fraction=args.cpu_fraction, dock_prm=args.dock_prm, rbt_root=args.rbt_root, ) ) target_config = engine.prepare_target(receptor, ligand_sdf, out / "target_prepared") artifacts = engine.dock_sdf(target_config, ligands_sdf, out, n_runs=args.n_runs, jobs=args.jobs, run_id=out.name) plots = plot_score_outputs(artifacts.best_per_ligand_csv, out / "plots", title_prefix=f"{args.pdb_id} rDock") best_rows = _read_csv_rows(Path(artifacts.best_per_ligand_csv)) scores = [float(row["SCORE"]) for row in best_rows if row.get("SCORE") not in (None, "")] metrics = { "pdb_id": args.pdb_id, "requested_ligands": len(smiles_rows), "successful_ligands": len(best_rows), "failed_ligands": max(0, len(smiles_rows) - len(best_rows)), "pose_count": sum(1 for _ in _read_csv_rows(Path(artifacts.scores_long_csv))), "n_runs": int(args.n_runs), "jobs": args.jobs, "score_min": min(scores) if scores else None, "score_median": median(scores) if scores else None, "score_mean": mean(scores) if scores else None, "score_max": max(scores) if scores else None, "top_ligand_id": best_rows[0].get("ligand_id") if best_rows else None, "top_SCORE": float(best_rows[0]["SCORE"]) if best_rows and best_rows[0].get("SCORE") else None, } metrics_dir = out / "metrics" metrics_dir.mkdir(parents=True, exist_ok=True) (metrics_dir / "benchmark_metrics.json").write_text(json.dumps(metrics, indent=2), encoding="utf-8") (metrics_dir / "validation_metrics.json").write_text(json.dumps(metrics, indent=2), encoding="utf-8") manifest = json.loads(Path(artifacts.manifest).read_text(encoding="utf-8")) manifest.update( { "benchmark": "pdb_500_smiles", "pdb_id": args.pdb_id, "ligand_count_requested": len(smiles_rows), "metrics": metrics, "metrics_json": str(metrics_dir / "benchmark_metrics.json"), "plots": plots, "executables": {"obabel": probe_version(require_executable("obabel"))}, } ) Path(artifacts.manifest).write_text(json.dumps(manifest, indent=2), encoding="utf-8") _append_benchmark_report(out / "report.md", args, artifacts.best_per_ligand_csv, plots) return {"run_dir": str(out), "manifest": artifacts.manifest} def _read_csv_rows(path: Path) -> list[dict[str, str]]: with path.open("r", encoding="utf-8", newline="") as handle: return list(csv.DictReader(handle)) def _append_benchmark_report(report: Path, args: argparse.Namespace, best_csv: str, plots: list[str]) -> None: top = [] with Path(best_csv).open("r", encoding="utf-8", newline="") as handle: for idx, row in enumerate(csv.DictReader(handle)): if idx >= 20: break top.append(f"- `{row.get('ligand_id')}` SCORE `{row.get('SCORE')}`") with report.open("a", encoding="utf-8") as handle: handle.write("\n\n## PDB Benchmark Summary\n") handle.write(f"- PDB: `{args.pdb_id}`\n") handle.write(f"- Receptor chain: `{args.receptor_chain}`\n") handle.write(f"- Reference ligand: `{args.reference_ligand_resname}`\n") handle.write(f"- SMILES file: `{args.smiles_file}`\n") handle.write("\n## Top 20 Ligands\n") handle.write("\n".join(top) + "\n") handle.write("\n## Plots\n") handle.write("\n".join(f"- `{p}`" for p in plots) + "\n") def main() -> int: parser = argparse.ArgumentParser( description="Run an independent real PDB complex + up to 500 SMILES rDock benchmark.", epilog=EXAMPLES, formatter_class=argparse.RawDescriptionHelpFormatter, ) parser.add_argument("--pdb-id", required=True) parser.add_argument("--receptor-chain", required=True) parser.add_argument("--reference-ligand-resname", required=True) parser.add_argument("--reference-ligand-chain") parser.add_argument("--smiles-file", required=True) parser.add_argument("--max-ligands", type=int, default=500) parser.add_argument("--out", required=True) parser.add_argument("--n-runs", type=int, default=50) parser.add_argument("--jobs", default="auto") parser.add_argument("--cpu-fraction", type=float, default=0.85) parser.add_argument("--ph", type=float, default=7.4) parser.add_argument("--force", action="store_true") parser.add_argument("--dock-prm") parser.add_argument("--rbt-root") parser.add_argument("--dry-run", action="store_true") parser.add_argument("--plan-only", action="store_true") result = run(parser.parse_args()) if not result.get("dry_run"): print(json.dumps(result, indent=2)) return 0 if __name__ == "__main__": raise SystemExit(main())