| from __future__ import annotations |
|
|
| import csv |
| import gzip |
| import json |
| import os |
| import re |
| import shutil |
| import tarfile |
| import urllib.request |
| from concurrent.futures import ThreadPoolExecutor, as_completed |
| from dataclasses import asdict, dataclass |
| from pathlib import Path |
| from statistics import median |
| from typing import Iterable |
|
|
| from .metrics import enrichment_rows, validation_metrics_from_rows |
| from .provenance import ( |
| CommandRecord, |
| CommandRunner, |
| RDockPipelineError, |
| fail_if_bad_command, |
| require_executable, |
| require_file, |
| resolve_dock_prm_path, |
| resolve_rbt_root, |
| ) |
| from .reports.plots import plot_astex_outputs, plot_dud_outputs |
| 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 |
|
|
| VALIDATION_URL = "https://rdock.github.io/validation-sets/" |
|
|
|
|
| @dataclass(frozen=True) |
| class ValidationSystem: |
| system_id: str |
| path: str |
| receptor_prm: str |
| dock_prm: str |
| ligand_sdf: str = "" |
| ligprep_sdf: str = "" |
| crystal_sdf: str = "" |
|
|
|
|
| def resolve_jobs(jobs: int | str = "auto", cpu_fraction: float = 0.85) -> int: |
| if str(jobs).lower() == "auto": |
| cpus = os.cpu_count() or 1 |
| reserve = 1 if cpus <= 4 else 2 |
| return max(1, min(cpus - reserve, int(cpus * float(cpu_fraction)))) |
| return max(1, int(jobs)) |
|
|
|
|
| def _rdock_env() -> dict[str, str]: |
| root = resolve_rbt_root(executable="rbdock") |
| if root: |
| return {"RBT_ROOT": root, "RBT_HOME": root} |
| return {} |
|
|
|
|
| def _system_id_from_prm(path: Path) -> str: |
| name = path.stem |
| return re.sub(r"_?rdock$", "", name, flags=re.IGNORECASE) |
|
|
|
|
| def _find_first(candidates: Iterable[Path]) -> Path | None: |
| for p in candidates: |
| if p.exists() and p.is_file() and p.stat().st_size > 0: |
| return p |
| return None |
|
|
|
|
| def _find_dock_prm(system_dir: Path) -> Path | None: |
| candidates = [system_dir / "dock.prm"] + [parent / "dock.prm" for parent in list(system_dir.parents)[:3]] |
| resolved = resolve_dock_prm_path(executable="rbdock") |
| if resolved is not None: |
| candidates.append(resolved) |
| return _find_first(candidates) |
|
|
|
|
| def discover_validation_systems(data_dir: str | Path, set_name: str) -> list[ValidationSystem]: |
| root = Path(data_dir) |
| if not root.exists(): |
| return [] |
| systems: dict[str, ValidationSystem] = {} |
| for prm in sorted(root.rglob("*_rdock.prm")): |
| system_dir = prm.parent |
| system_id = _system_id_from_prm(prm) |
| dock_prm = _find_dock_prm(system_dir) |
| if dock_prm is None: |
| local = list(system_dir.rglob("dock.prm")) |
| dock_prm = local[0] if local else None |
| sdf_files = sorted(list(system_dir.glob("*.sd")) + list(system_dir.glob("*.sdf"))) |
| gz_sdfs = sorted(list(system_dir.glob("*.sd.gz")) + list(system_dir.glob("*.sdf.gz"))) |
| ligand_sdf = _find_first( |
| [ |
| system_dir / f"{system_id}_ligand.sd", |
| system_dir / f"{system_id}_ligand.sdf", |
| system_dir / "ligand.sd", |
| system_dir / "ligand.sdf", |
| ] |
| + [p for p in sdf_files if "ligand" in p.name.lower() or "crystal" in p.name.lower()] |
| + sdf_files |
| ) |
| ligprep_sdf = _find_first( |
| [ |
| system_dir / f"{system_id}_ligprep.sdf", |
| system_dir / f"{system_id}_ligprep.sd", |
| ] |
| + [p for p in sdf_files if "ligprep" in p.name.lower()] |
| + [p for p in gz_sdfs if "ligprep" in p.name.lower()] |
| ) |
| if set_name.lower() == "dud" and ligprep_sdf is None: |
| continue |
| systems[system_id] = ValidationSystem( |
| system_id=system_id, |
| path=str(system_dir), |
| receptor_prm=str(prm), |
| dock_prm=str(dock_prm or ""), |
| ligand_sdf=str(ligand_sdf or ""), |
| ligprep_sdf=str(ligprep_sdf or ""), |
| crystal_sdf=str(ligand_sdf or ""), |
| ) |
| return [systems[k] for k in sorted(systems)] |
|
|
|
|
| def _actionable_missing_system(data_dir: Path, set_name: str, system: str | None) -> RDockPipelineError: |
| expected = data_dir / (system or "<system>") |
| return RDockPipelineError( |
| "Missing rDock validation data.\n" |
| f"Expected path or discoverable system files under: {expected}\n" |
| f"Validation set: {set_name}\n" |
| f"Official validation sets: {VALIDATION_URL}\n" |
| "Use one of:\n" |
| f" python -m docking_pipeline validate-rdock --set {set_name} --data-dir {data_dir} --list-systems\n" |
| f" python -m docking_pipeline validate-rdock --set {set_name} --system {system or '<id>'} --data-dir {data_dir} --out results/benchmarks/{set_name}_{system or '<id>'} --download-url <official_tar.gz> --download-if-missing\n" |
| "or manually download/extract the official rDock validation set and pass its extracted directory via --data-dir." |
| ) |
|
|
|
|
| def download_validation_set(download_url: str, data_dir: str | Path, force: bool = False) -> Path: |
| target = Path(data_dir) |
| if target.exists() and any(target.iterdir()) and not force: |
| return target |
| target.mkdir(parents=True, exist_ok=True) |
| archive = target / Path(download_url).name |
| urllib.request.urlretrieve(download_url, archive) |
| with tarfile.open(archive, "r:*") as tar: |
| tar.extractall(target) |
| return target |
|
|
|
|
| def ensure_validation_data(data_dir: str | Path, set_name: str, download_url: str | None, download_if_missing: bool, force: bool = False) -> Path: |
| root = Path(data_dir) |
| if root.exists() and discover_validation_systems(root, set_name): |
| return root |
| if download_if_missing: |
| if not download_url: |
| raise RDockPipelineError( |
| f"--download-if-missing was set but --download-url was not provided. Official validation sets: {VALIDATION_URL}" |
| ) |
| download_validation_set(download_url, root, force=force) |
| return root |
|
|
|
|
| def resolve_systems( |
| data_dir: str | Path, |
| set_name: str, |
| system: str | None = None, |
| system_list: str | Path | None = None, |
| max_systems: int | None = None, |
| ) -> list[ValidationSystem]: |
| root = Path(data_dir) |
| systems = discover_validation_systems(root, set_name) |
| if not systems: |
| raise _actionable_missing_system(root, set_name, system) |
| wanted: set[str] | None = None |
| if system: |
| wanted = {system} |
| if system_list: |
| ids = [line.strip() for line in Path(system_list).read_text(encoding="utf-8").splitlines() if line.strip()] |
| wanted = (wanted or set()) | set(ids) |
| if wanted is not None: |
| systems = [s for s in systems if s.system_id in wanted] |
| if not systems: |
| raise _actionable_missing_system(root, set_name, system or ",".join(sorted(wanted))) |
| if max_systems is not None: |
| systems = systems[: int(max_systems)] |
| return systems |
|
|
|
|
| def _copy_system(src: Path, out_dir: Path, force: bool) -> Path: |
| dst = out_dir / "rdock" / src.name |
| if dst.exists(): |
| if not force: |
| return dst |
| shutil.rmtree(dst) |
| shutil.copytree(src, dst) |
| return dst |
|
|
|
|
| def _gunzip_if_needed(path: Path) -> Path: |
| if path.exists() and path.suffix != ".gz": |
| return path |
| if path.suffix == ".gz": |
| out = path.with_suffix("") |
| if not out.exists(): |
| with gzip.open(path, "rb") as src, out.open("wb") as dst: |
| shutil.copyfileobj(src, dst) |
| return out |
| gz = path.with_suffix(path.suffix + ".gz") |
| if gz.exists(): |
| return _gunzip_if_needed(gz) |
| return require_file(path, "ligand-prepped SDF") |
|
|
|
|
| def _run_rbdock_parallel( |
| runner: CommandRunner, |
| work: Path, |
| prm: Path, |
| dock_prm: Path, |
| ligand_sdf: Path, |
| out_prefix: str, |
| n_runs: int, |
| jobs: int, |
| ) -> tuple[Path, list[CommandRecord]]: |
| rbdock = require_executable("rbdock") |
| blocks = split_sdf_file(ligand_sdf) |
| chunk_dir = work / "chunks" |
| chunk_dir.mkdir(exist_ok=True) |
| chunk_count = min(max(1, jobs), len(blocks)) |
| chunks: list[Path] = [] |
| for idx in range(chunk_count): |
| chunk_blocks = blocks[idx::chunk_count] |
| chunk = chunk_dir / f"chunk_{idx:03d}.sdf" |
| write_sdf_blocks(chunk_blocks, chunk) |
| chunks.append(chunk) |
|
|
| def run_one(idx: int, chunk: Path) -> tuple[int, CommandRecord, Path]: |
| prefix = work / f"{out_prefix}_chunk_{idx:03d}" |
| rec = runner.run( |
| f"rbdock_chunk_{idx:03d}", |
| [rbdock, "-r", str(prm.name), "-p", str(dock_prm), "-n", str(int(n_runs)), "-i", str(chunk.relative_to(work)), "-o", str(prefix.name)], |
| work, |
| work / f"{out_prefix}_chunk_{idx:03d}.stdout.log", |
| work / f"{out_prefix}_chunk_{idx:03d}.stderr.log", |
| env=_rdock_env(), |
| ) |
| return idx, rec, prefix.with_suffix(".sd") |
|
|
| outputs: dict[int, Path] = {} |
| records: list[CommandRecord] = [] |
| with ThreadPoolExecutor(max_workers=chunk_count) as pool: |
| futures = [pool.submit(run_one, idx, chunk) for idx, chunk in enumerate(chunks)] |
| for fut in as_completed(futures): |
| idx, rec, out_sd = fut.result() |
| fail_if_bad_command(rec, f"rbdock chunk {idx}") |
| require_file(out_sd, f"rDock output chunk {idx}") |
| outputs[idx] = out_sd |
| records.append(rec) |
| merged = work / f"{out_prefix}.sd" |
| all_blocks: list[str] = [] |
| for idx in sorted(outputs): |
| all_blocks.extend(split_sdf_file(outputs[idx])) |
| write_sdf_blocks(all_blocks, merged) |
| return merged, records |
|
|
|
|
| def _parse_rmsd_stdout(text: str) -> list[float]: |
| vals: list[float] = [] |
| for token in re.findall(r"[-+]?(?:\d+\.\d+|\d+)", text): |
| try: |
| value = float(token) |
| except Exception: |
| continue |
| if 0.0 <= value < 100.0: |
| vals.append(value) |
| return vals |
|
|
|
|
| def _sdf_pose_coords(path: Path) -> list[list[list[float]]]: |
| poses: list[list[list[float]]] = [] |
| for block in split_sdf_file(path): |
| lines = block.splitlines() |
| if len(lines) < 4: |
| continue |
| try: |
| atom_count = int(lines[3][0:3]) |
| except Exception: |
| continue |
| coords: list[list[float]] = [] |
| for line in lines[4 : 4 + atom_count]: |
| try: |
| coords.append([float(line[0:10]), float(line[10:20]), float(line[20:30])]) |
| except Exception: |
| parts = line.split() |
| if len(parts) >= 3: |
| try: |
| coords.append([float(parts[0]), float(parts[1]), float(parts[2])]) |
| except Exception: |
| continue |
| if coords: |
| poses.append(coords) |
| return poses |
|
|
|
|
| def _rmsd_same_order(a: list[list[float]], b: list[list[float]]) -> float: |
| n = min(len(a), len(b)) |
| if n == 0: |
| return float("nan") |
| return (sum((a[i][0] - b[i][0]) ** 2 + (a[i][1] - b[i][1]) ** 2 + (a[i][2] - b[i][2]) ** 2 for i in range(n)) / n) ** 0.5 |
|
|
|
|
| def _internal_rmsds(reference_sdf: Path, poses_sdf: Path) -> list[float]: |
| ref = _sdf_pose_coords(reference_sdf) |
| poses = _sdf_pose_coords(poses_sdf) |
| if not ref: |
| return [] |
| return [_rmsd_same_order(ref[0], pose) for pose in poses] |
|
|
|
|
| def _write_csv(path: Path, rows: list[dict[str, object]]) -> None: |
| path.parent.mkdir(parents=True, exist_ok=True) |
| fields: list[str] = [] |
| for row in rows: |
| for k in row: |
| if k not in fields: |
| fields.append(k) |
| with path.open("w", encoding="utf-8", newline="") as handle: |
| writer = csv.DictWriter(handle, fieldnames=fields) |
| writer.writeheader() |
| writer.writerows(rows) |
|
|
|
|
| def _empty_standard_outputs(root: Path) -> None: |
| for name in ("target", "ligands", "rdock", "poses", "tables", "metrics", "plots"): |
| (root / name).mkdir(parents=True, exist_ok=True) |
|
|
|
|
| def _copy_receptor_to_target(work: Path, system: ValidationSystem, root: Path) -> Path | None: |
| target_dir = root / "target" |
| target_dir.mkdir(parents=True, exist_ok=True) |
| prm_stem = Path(system.receptor_prm).stem |
| candidates = [ |
| work / f"{prm_stem}.mol2", |
| work / f"{system.system_id}_rdock.mol2", |
| work / f"{system.system_id}.mol2", |
| ] |
| candidates.extend(sorted(work.glob("*.mol2"))) |
| receptor = _find_first(candidates) |
| if receptor is None: |
| return None |
| dst = target_dir / receptor.name |
| shutil.copy2(receptor, dst) |
| return dst |
|
|
|
|
| def validate_astex_system( |
| system: ValidationSystem, |
| root: Path, |
| n_runs: int, |
| jobs: int, |
| force: bool = False, |
| ) -> dict[str, object]: |
| _empty_standard_outputs(root) |
| work = _copy_system(Path(system.path), root, force=force) |
| _copy_receptor_to_target(work, system, root) |
| runner = CommandRunner(root / "commands.log") |
| for exe in ("rbcavity", "rbdock", "sdsort", "sdrmsd"): |
| require_executable(exe) |
| prm = require_file(work / Path(system.receptor_prm).name, "ASTEX rDock receptor prm") |
| dock_prm = require_file(system.dock_prm, "ASTEX dock.prm") |
| ligand = require_file(work / Path(system.ligand_sdf).name, "ASTEX ligand SDF") |
| rec = runner.run("rbcavity", ["rbcavity", "-r", prm.name, "-was"], work, work / "rbcavity.stdout.log", work / "rbcavity.stderr.log", env=_rdock_env()) |
| fail_if_bad_command(rec, "ASTEX rbcavity") |
| out_sd, _ = _run_rbdock_parallel(runner, work, prm, dock_prm, ligand, f"{system.system_id}_docking_out", n_runs, jobs) |
| rec = runner.run( |
| "sdsort", |
| ["/bin/sh", "-c", f"sdsort -n -f'SCORE' {out_sd.name} > {system.system_id}_docking_out_sorted.sd"], |
| work, |
| work / "sdsort.stdout.log", |
| work / "sdsort.stderr.log", |
| env=_rdock_env(), |
| ) |
| fail_if_bad_command(rec, "ASTEX sdsort") |
| sorted_sd = require_file(work / f"{system.system_id}_docking_out_sorted.sd", "ASTEX sorted SDF") |
| rmsd_source = "sdrmsd" |
| rmsd_diagnostic = "" |
| rec = runner.run("sdrmsd", ["sdrmsd", ligand.name, sorted_sd.name], work, work / "sdrmsd.stdout.log", work / "sdrmsd.stderr.log", env=_rdock_env()) |
| try: |
| fail_if_bad_command(rec, "ASTEX sdrmsd") |
| rmsds = _parse_rmsd_stdout(Path(rec.stdout_log).read_text(encoding="utf-8", errors="ignore")) |
| except RDockPipelineError as exc: |
| rmsd_source = "internal_same_atom_order_sdf_rmsd_after_sdrmsd_failure" |
| rmsd_diagnostic = str(exc) |
| rmsds = _internal_rmsds(ligand, sorted_sd) |
| top1 = rmsds[0] if rmsds else float("nan") |
| best = min(rmsds) if rmsds else float("nan") |
| shutil.copy2(out_sd, root / "poses" / "all_poses.sdf") |
| shutil.copy2(sorted_sd, root / "poses" / "best_per_ligand.sdf") |
| records = parse_rdock_sdf_records(out_sd) |
| sorted_records = parse_rdock_sdf_records(sorted_sd) |
| best_records = best_per_ligand(records) |
| write_rows_csv(records_to_rows(records), root / "tables" / "scores_long.csv") |
| write_rows_csv(records_to_rows(best_records), root / "tables" / "best_per_ligand.csv") |
| top1_score = sorted_records[0].numeric_tags.get("SCORE") if sorted_records else None |
| row = { |
| "system_id": system.system_id, |
| "top1_rmsd": top1, |
| "best_of_n_rmsd": best, |
| "top1_SCORE": top1_score, |
| "success_top1_rmsd_le_2A": bool(top1 <= 2.0), |
| "success_best_rmsd_le_2A": bool(best <= 2.0), |
| "n_poses": len(records), |
| "status": "success", |
| "rmsd_source": rmsd_source, |
| "rmsd_diagnostic": rmsd_diagnostic, |
| } |
| _write_csv(root / "tables" / "astex_system_summary.csv", [row]) |
| metrics = { |
| **row, |
| "median_top1_rmsd": top1, |
| "median_best_rmsd": best, |
| "n_systems_total": 1, |
| "n_systems_successful": 1, |
| "n_systems_failed": 0, |
| "n_poses_total": len(records), |
| } |
| (root / "metrics" / "validation_metrics.json").write_text(json.dumps(metrics, indent=2), encoding="utf-8") |
| (root / "metrics" / "enrichment.csv").write_text("", encoding="utf-8") |
| plots = plot_astex_outputs(root / "tables" / "astex_system_summary.csv", root / "plots") |
| _write_validation_report(root, "ASTEX", [system], runner.records, metrics, plots) |
| return metrics |
|
|
|
|
| def _read_dud_labels(work: Path) -> dict[str, int]: |
| labels: dict[str, int] = {} |
| for name, value in (("ligands.txt", 1), ("actives.txt", 1), ("decoys.txt", 0)): |
| p = work / name |
| if not p.exists(): |
| continue |
| for line in p.read_text(encoding="utf-8", errors="ignore").splitlines(): |
| parts = line.strip().split() |
| if parts: |
| labels[parts[0]] = value |
| return labels |
|
|
|
|
| def validate_dud_system(system: ValidationSystem, root: Path, n_runs: int, jobs: int, force: bool = False) -> dict[str, object]: |
| _empty_standard_outputs(root) |
| work = _copy_system(Path(system.path), root, force=force) |
| _copy_receptor_to_target(work, system, root) |
| runner = CommandRunner(root / "commands.log") |
| for exe in ("rbcavity", "rbdock", "sdsort", "sdfilter", "sdreport"): |
| require_executable(exe) |
| prm = require_file(work / Path(system.receptor_prm).name, "DUD rDock receptor prm") |
| dock_prm = require_file(system.dock_prm, "DUD dock.prm") |
| ligprep = _gunzip_if_needed(work / Path(system.ligprep_sdf).name) |
| labels = _read_dud_labels(work) |
| if not labels: |
| raise RDockPipelineError( |
| "Missing DUD active/decoy label files for enrichment metrics.\n" |
| f"Expected `ligands.txt`/`actives.txt` and `decoys.txt` in: {work}\n" |
| "The official rDock ROC workflow requires these files to assign IsActive labels.\n" |
| "Add the label files for this DUD system, then rerun the same validate-rdock command." |
| ) |
| rec = runner.run("rbcavity", ["rbcavity", "-r", prm.name, "-was"], work, work / "rbcavity.stdout.log", work / "rbcavity.stderr.log", env=_rdock_env()) |
| fail_if_bad_command(rec, "DUD rbcavity") |
| out_sd, _ = _run_rbdock_parallel(runner, work, prm, dock_prm, ligprep, f"{system.system_id}_docking_out", n_runs, jobs) |
| records = parse_rdock_sdf_records(out_sd, require_score=True) |
| best_records = best_per_ligand(records) |
| best_sd = write_sdf_records(best_records, work / f"{system.system_id}_1poseperlig.sd") |
| rows = records_to_rows(best_records) |
| for row in rows: |
| row["label"] = labels.get(str(row["ligand_id"]), 0) |
| duplicate_count = len(records) - len({r.ligand_id for r in records}) |
| metrics = validation_metrics_from_rows(rows) |
| metrics.update( |
| { |
| "active_count": sum(int(row.get("label", 0)) for row in rows), |
| "decoy_count": sum(1 - int(row.get("label", 0)) for row in rows), |
| "attempted_ligands": len(split_sdf_file(ligprep)), |
| "successful_ligands": len(rows), |
| "failed_ligands": max(0, len(split_sdf_file(ligprep)) - len(rows)), |
| "duplicate_ligand_ids": duplicate_count, |
| "missing_SCORE_count": 0, |
| } |
| ) |
| shutil.copy2(out_sd, root / "poses" / "all_poses.sdf") |
| shutil.copy2(best_sd, root / "poses" / "best_per_ligand.sdf") |
| write_rows_csv(records_to_rows(records), root / "tables" / "scores_long.csv") |
| write_rows_csv(rows, root / "tables" / "best_per_ligand.csv") |
| _write_csv(root / "metrics" / "enrichment.csv", enrichment_rows([float(r["SCORE"]) for r in rows], [int(r["label"]) for r in rows])) |
| (root / "metrics" / "validation_metrics.json").write_text(json.dumps(metrics, indent=2), encoding="utf-8") |
| plots = plot_dud_outputs(root / "tables" / "best_per_ligand.csv", root / "metrics" / "enrichment.csv", root / "plots") |
| _write_validation_report(root, "DUD", [system], runner.records, metrics, plots) |
| return metrics |
|
|
|
|
| def plan_validation( |
| set_name: str, |
| data_dir: str | Path, |
| systems: list[ValidationSystem], |
| out_dir: str | Path, |
| n_runs: int, |
| jobs: int | str, |
| cpu_fraction: float, |
| ) -> dict[str, object]: |
| resolved_jobs = resolve_jobs(jobs, cpu_fraction) |
| return { |
| "set": set_name, |
| "data_dir": str(data_dir), |
| "out": str(out_dir), |
| "n_runs": int(n_runs), |
| "jobs": resolved_jobs, |
| "system_count": len(systems), |
| "systems": [asdict(s) for s in systems], |
| "commands": [ |
| f"rbcavity -r <system>_rdock.prm -was", |
| f"rbdock -r <system>_rdock.prm -p dock.prm -n {int(n_runs)} -i <ligands>.sd -o <out>", |
| "sdsort/sdrmsd for ASTEX or best-pose/enrichment reporting for DUD", |
| ], |
| } |
|
|
|
|
| def validate_many( |
| set_name: str, |
| data_dir: str | Path, |
| out_dir: str | Path, |
| system: str | None = None, |
| system_list: str | Path | None = None, |
| max_systems: int | None = None, |
| n_runs: int = 100, |
| jobs: int | str = "auto", |
| cpu_fraction: float = 0.85, |
| download_url: str | None = None, |
| download_if_missing: bool = False, |
| force: bool = False, |
| dry_run: bool = False, |
| plan_only: bool = False, |
| ) -> dict[str, object]: |
| root_data = ensure_validation_data(data_dir, set_name, download_url, download_if_missing, force=force) |
| systems = resolve_systems(root_data, set_name, system, system_list, max_systems) |
| plan = plan_validation(set_name, root_data, systems, out_dir, n_runs, jobs, cpu_fraction) |
| out = Path(out_dir) |
| if dry_run or plan_only: |
| out.mkdir(parents=True, exist_ok=True) |
| (out / "validation_plan.json").write_text(json.dumps(plan, indent=2), encoding="utf-8") |
| return {"dry_run": bool(dry_run), "plan": plan} |
| if out.exists() and force: |
| shutil.rmtree(out) |
| out.mkdir(parents=True, exist_ok=True) |
| resolved_jobs = int(plan["jobs"]) |
| rows: list[dict[str, object]] = [] |
| failures: list[dict[str, object]] = [] |
| metrics_by_system: list[dict[str, object]] = [] |
| per_system_jobs = resolved_jobs if len(systems) == 1 else 1 |
| system_order = {s.system_id: idx for idx, s in enumerate(systems)} |
|
|
| def run_system(s: ValidationSystem) -> tuple[int, ValidationSystem, dict[str, object] | None, dict[str, object], Exception | None]: |
| run_root = out / s.system_id if len(systems) > 1 else out |
| try: |
| if set_name.lower() == "astex": |
| metrics = validate_astex_system(s, run_root, n_runs=n_runs, jobs=per_system_jobs, force=force) |
| row = { |
| "system_id": s.system_id, |
| "top1_rmsd": metrics.get("top1_rmsd"), |
| "best_of_n_rmsd": metrics.get("best_of_n_rmsd"), |
| "top1_SCORE": metrics.get("top1_SCORE"), |
| "success_top1_rmsd_le_2A": metrics.get("success_top1_rmsd_le_2A"), |
| "success_best_rmsd_le_2A": metrics.get("success_best_rmsd_le_2A"), |
| "n_poses": metrics.get("n_poses"), |
| "status": "success", |
| } |
| elif set_name.lower() == "dud": |
| metrics = validate_dud_system(s, run_root, n_runs=n_runs, jobs=per_system_jobs, force=force) |
| row = {"system_id": s.system_id, "status": "success", **metrics} |
| else: |
| raise RDockPipelineError(f"Unsupported validation set: {set_name}") |
| return system_order[s.system_id], s, metrics, row, None |
| except Exception as exc: |
| return system_order[s.system_id], s, None, {"system_id": s.system_id, "status": "failed", "error": str(exc)}, exc |
|
|
| max_system_workers = min(resolved_jobs, len(systems)) |
| results: list[tuple[int, ValidationSystem, dict[str, object] | None, dict[str, object], Exception | None]] = [] |
| if max_system_workers > 1: |
| with ThreadPoolExecutor(max_workers=max_system_workers) as pool: |
| futures = [pool.submit(run_system, s) for s in systems] |
| for fut in as_completed(futures): |
| results.append(fut.result()) |
| else: |
| results = [run_system(s) for s in systems] |
|
|
| for _, s, metrics, row, exc in sorted(results, key=lambda item: item[0]): |
| rows.append(row) |
| if exc is not None: |
| failures.append({"system_id": s.system_id, "error": str(exc)}) |
| continue |
| if metrics is not None: |
| metrics_by_system.append({"system_id": s.system_id, **metrics}) |
|
|
| |
| |
| _empty_standard_outputs(out) |
| _write_csv(out / "tables" / f"{set_name.lower()}_system_summary.csv", rows) |
| if set_name.lower() == "astex": |
| top1 = [float(r["top1_rmsd"]) for r in rows if r.get("status") == "success"] |
| best_vals = [float(r["best_of_n_rmsd"]) for r in rows if r.get("status") == "success"] |
| aggregate = { |
| "n_systems_total": len(systems), |
| "n_systems_successful": len(top1), |
| "n_systems_failed": len(failures), |
| "median_top1_rmsd": median(top1) if top1 else None, |
| "median_best_rmsd": median(best_vals) if best_vals else None, |
| "success_top1_rmsd_le_2A": sum(1 for x in top1 if x <= 2.0), |
| "success_best_rmsd_le_2A": sum(1 for x in best_vals if x <= 2.0), |
| "n_poses_total": sum(int(r.get("n_poses", 0) or 0) for r in rows), |
| "failures": failures, |
| } |
| plots = plot_astex_outputs(out / "tables" / f"{set_name.lower()}_system_summary.csv", out / "plots") |
| else: |
| aggregate = { |
| "n_systems_total": len(systems), |
| "n_systems_successful": len(metrics_by_system), |
| "n_systems_failed": len(failures), |
| "failures": failures, |
| } |
| plots = [] |
| (out / "metrics" / "validation_metrics.json").write_text(json.dumps(aggregate, indent=2), encoding="utf-8") |
| _write_validation_report(out, set_name.upper(), systems, [], aggregate, plots) |
| return {"metrics": aggregate, "systems": rows} |
|
|
|
|
| def validate_astex(data_dir: str | Path, system: str, out_dir: str | Path, n_runs: int = 100, jobs: int | str = 1) -> dict[str, object]: |
| result = validate_many("astex", data_dir, out_dir, system=system, n_runs=n_runs, jobs=jobs) |
| return dict(result.get("metrics", {})) |
|
|
|
|
| def validate_dud(data_dir: str | Path, system: str, out_dir: str | Path, n_runs: int = 100, jobs: int | str = 1) -> dict[str, object]: |
| result = validate_many("dud", data_dir, out_dir, system=system, n_runs=n_runs, jobs=jobs) |
| return dict(result.get("metrics", {})) |
|
|
|
|
| def _write_validation_report( |
| root: Path, |
| set_name: str, |
| systems: list[ValidationSystem], |
| commands: list[CommandRecord], |
| metrics: dict[str, object], |
| plots: list[str], |
| ) -> None: |
| manifest = { |
| "validation_set": set_name, |
| "engine": "real-rdock-official-workflow", |
| "systems": [asdict(s) for s in systems], |
| "commands": [c.to_dict() for c in commands], |
| "metrics": metrics, |
| "plots": plots, |
| "artifacts": { |
| "report": str(root / "report.md"), |
| "manifest": str(root / "manifest.json"), |
| "config": str(root / "config.yaml"), |
| "commands": str(root / "commands.log"), |
| "tables": str(root / "tables"), |
| "metrics": str(root / "metrics"), |
| "plots": str(root / "plots"), |
| }, |
| } |
| (root / "manifest.json").write_text(json.dumps(manifest, indent=2), encoding="utf-8") |
| (root / "config.yaml").write_text(f"validation_set: {set_name}\nsystems: {[s.system_id for s in systems]}\n", encoding="utf-8") |
| top_lines = [] |
| for item in list(metrics.items())[:20]: |
| top_lines.append(f"- {item[0]}: `{item[1]}`") |
| plot_lines = [f"- `{p}`" for p in plots] or ["- No plots generated; see `plots/skipped_plots.json` if present."] |
| (root / "report.md").write_text( |
| "\n".join( |
| [ |
| f"# {set_name} rDock Validation", |
| "", |
| "## Input Summary", |
| f"- Systems: `{', '.join(s.system_id for s in systems)}`", |
| f"- System count: `{len(systems)}`", |
| "", |
| "## Metrics", |
| *top_lines, |
| "", |
| "## Commands", |
| f"- Command log: `{root / 'commands.log'}`", |
| "- Per-system command logs are stored under each system run directory for multi-system runs.", |
| "", |
| "## Plots", |
| *plot_lines, |
| "", |
| "## Skipped Steps", |
| "- Browser bundle export was removed from the production pipeline.", |
| "- No mock docking or surrogate scores are used.", |
| "", |
| "## Diagnostics", |
| f"- Failures: `{json.dumps(metrics.get('failures', []))}`", |
| ] |
| ), |
| encoding="utf-8", |
| ) |
|
|
