| 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()) |
|
|
