from __future__ import annotations import json import math import os import shutil from concurrent.futures import ThreadPoolExecutor, as_completed from dataclasses import asdict, dataclass, field from datetime import UTC, datetime from pathlib import Path from typing import Any try: # pragma: no cover from tqdm import tqdm except Exception: # pragma: no cover tqdm = None # type: ignore[assignment] from .provenance import ( CommandRecord, CommandRunner, RDockPipelineError, fail_if_bad_command, probe_version, require_executable, require_file, resolve_dock_prm_path, resolve_rbt_root, sha256_file, ) from .sdf import best_per_ligand, ligand_id_from_block, parse_rdock_sdf_records, parse_tags, records_to_rows, split_sdf_file, write_rows_csv, write_sdf_blocks, write_sdf_records @dataclass class TargetConfig: receptor: str reference_ligand: str target_dir: str receptor_mol2: str receptor_prm: str cavity_as: str pocket_center: list[float] pocket_radius: float diagnostics: dict[str, Any] @dataclass class RDockRunConfig: n_runs: int = 50 jobs: int | str = "auto" cpu_fraction: float = 0.85 timeout_seconds: int = 3600 chunk_size: int | None = None rbdock_bin: str = "rbdock" rbcavity_bin: str = "rbcavity" obabel_bin: str = "obabel" sdsort_bin: str = "sdsort" sdfilter_bin: str = "sdfilter" sdreport_bin: str = "sdreport" sdrmsd_bin: str = "sdrmsd" sdsplit_bin: str = "sdsplit" dock_prm: str | None = None rbt_root: str | None = None require_reporting_tools: bool = False @dataclass class RunArtifacts: run_dir: str manifest: str config_yaml: str commands_log: str all_poses_sdf: str best_per_ligand_sdf: str scores_long_csv: str best_per_ligand_csv: str report_md: str command_records: list[dict[str, Any]] = field(default_factory=list) best_ligand_poses_sdf: str | None = None def _tail_text(path: Path, limit: int = 2000) -> str: if not path.exists(): return "" try: text = path.read_text(encoding="utf-8", errors="ignore") except Exception: return "" return text[-limit:] def _classify_chunk_failure( rec: CommandRecord | None, out_sd: Path, stdout_log: Path, stderr_log: Path, ) -> str: combined = f"{_tail_text(stdout_log, 4000)}\n{_tail_text(stderr_log, 4000)}".lower() exit_code = int(rec.exit_code) if rec is not None else None if exit_code == 124 or "timeout after" in combined: return "rdock_timeout" if exit_code == -15 or "sigterm" in combined or "terminated" in combined: return "rdock_sigterm" if exit_code == -9 or "sigkill" in combined or "killed" in combined: return "rdock_sigkill" if not out_sd.exists(): if exit_code not in (None, 0): return f"rdock_nonzero_exit_{exit_code}" return "missing_rdock_output_sdf" if "not enough diversity" in combined or "population failure" in combined: return "rdock_population_not_enough_diversity" if "explicit valence" in combined: return "rdkit_or_obabel_explicit_valence" if "2d" in combined and "record" in combined: return "rdock_2d_record" try: records = parse_rdock_sdf_records(out_sd, require_score=False) except Exception: return "rdock_unknown_failure" if not records: return "rdock_no_valid_scored_poses" valid_records = [record for record in records if record.score is not None] if not valid_records: return "rdock_missing_score" return "rdock_unknown_failure" def _write_yaml_like(path: Path, payload: dict[str, Any]) -> None: try: import yaml text = yaml.safe_dump(payload, sort_keys=False) except Exception: text = json.dumps(payload, indent=2) path.write_text(text, encoding="utf-8") def _sanitize_chunk_output_scores(path: Path) -> tuple[list[Any], int]: records = parse_rdock_sdf_records(path, require_score=False) valid_records = [record for record in records if record.score is not None] dropped = len(records) - len(valid_records) if dropped > 0: write_sdf_records(valid_records, path) return valid_records, dropped def _normalize_receptor_prm_paths(prm_path: Path, config_dir: Path, dataset_target_dir: Path) -> bool: if not prm_path.exists(): return False text = prm_path.read_text(encoding="utf-8", errors="ignore") updated_lines: list[str] = [] changed = False receptor_candidate = config_dir / "receptor.mol2" reference_candidates = [ config_dir / "reference_ligand.sdf", dataset_target_dir / "reference_ligand.sdf", ] for line in text.splitlines(): stripped = line.strip() if stripped.startswith("RECEPTOR_FILE ") and receptor_candidate.exists(): new_line = f"RECEPTOR_FILE {receptor_candidate.name}" if line != new_line: line = new_line changed = True elif stripped.startswith("REF_MOL "): for candidate in reference_candidates: if candidate.exists(): new_line = f" REF_MOL {candidate.name}" if line != new_line: line = new_line changed = True break updated_lines.append(line) if changed: prm_path.write_text("\n".join(updated_lines) + "\n", encoding="utf-8") return changed def _coords_from_pdb(path: Path, include_hetatm: bool) -> np.ndarray: coords: list[list[float]] = [] for line in path.read_text(encoding="utf-8", errors="ignore").splitlines(): if not line.startswith(("ATOM", "HETATM")): continue if line.startswith("HETATM") and not include_hetatm: continue try: coords.append([float(line[30:38]), float(line[38:46]), float(line[46:54])]) except Exception: continue return coords # type: ignore[return-value] def _coords_from_mol2(path: Path) -> np.ndarray: coords: list[list[float]] = [] in_atoms = False for line in path.read_text(encoding="utf-8", errors="ignore").splitlines(): if line.startswith("@ATOM"): in_atoms = True continue if line.startswith("@") and in_atoms: break if not in_atoms: continue parts = line.split() if len(parts) >= 5: try: coords.append([float(parts[2]), float(parts[3]), float(parts[4])]) except Exception: continue return coords # type: ignore[return-value] def _coords_from_sdf(path: Path) -> np.ndarray: first = path.read_text(encoding="utf-8", errors="ignore").split("$$$$", 1)[0] lines = first.splitlines() if len(lines) < 4: return [] # type: ignore[return-value] try: atom_count = int(lines[3][0:3]) except Exception: atom_count = 0 coords = [] 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 return coords # type: ignore[return-value] def _coords_for_structure(path: Path, receptor: bool) -> np.ndarray: suffix = path.suffix.lower() if suffix == ".mol2": return _coords_from_mol2(path) if suffix in {".sdf", ".sd"}: return _coords_from_sdf(path) if suffix in {".pdb", ".ent", ".cif", ".mmcif"}: return _coords_from_pdb(path, include_hetatm=not receptor) raise RDockPipelineError(f"Unsupported structure format for coordinate validation: {path}") def _validate_receptor_ligand_geometry(receptor: Path, ligand: Path) -> tuple[list[float], dict[str, Any]]: receptor_coords = _coords_for_structure(receptor, receptor=True) ligand_coords = _coords_for_structure(ligand, receptor=False) if not receptor_coords: raise RDockPipelineError(f"Missing receptor atoms or coordinates in {receptor}") if not ligand_coords: raise RDockPipelineError(f"Missing ligand coordinates in reference ligand {ligand}") n_lig = len(ligand_coords) center = [sum(coord[i] for coord in ligand_coords) / n_lig for i in range(3)] def dist(a: list[float], b: list[float]) -> float: return ((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2 + (a[2] - b[2]) ** 2) ** 0.5 all_dists = [dist(r, l) for r in receptor_coords for l in ligand_coords] min_receptor_ligand_dist = min(all_dists) centroid_to_receptor = min(dist(r, center) for r in receptor_coords) severe_clashes = sum(1 for d in all_dists if d < 1.0) clash_fraction = severe_clashes / float(max(1, len(ligand_coords))) if centroid_to_receptor > 20.0: raise RDockPipelineError( f"Reference ligand centroid is {centroid_to_receptor:.2f} A from the nearest receptor atom; " "check receptor/reference ligand pairing and coordinate frames." ) if clash_fraction > 1.0: raise RDockPipelineError( f"Severe receptor-ligand clashes before docking ({severe_clashes} atom pairs < 1.0 A). " "Check protonation, alternate locations, and coordinate consistency." ) spread = max(dist(l, center) for l in ligand_coords) return [float(center[0]), float(center[1]), float(center[2])], { "receptor_atom_count": int(len(receptor_coords)), "reference_ligand_atom_count": int(len(ligand_coords)), "reference_ligand_centroid": [float(x) for x in center], "reference_ligand_radius": spread, "min_receptor_ligand_distance": min_receptor_ligand_dist, "reference_centroid_to_nearest_receptor_atom": centroid_to_receptor, "severe_clash_pairs_lt_1A": severe_clashes, } class RDockEngine: def __init__(self, config: RDockRunConfig | None = None) -> None: self.config = config or RDockRunConfig() def _env(self) -> dict[str, str]: env: dict[str, str] = {} resolved = resolve_rbt_root(preferred=self.config.rbt_root, executable=self.config.rbdock_bin) if resolved: env["RBT_ROOT"] = resolved env["RBT_HOME"] = resolved return env def _dock_prm(self) -> Path: if self.config.dock_prm: return require_file(self.config.dock_prm, "rDock protocol dock.prm") candidate = resolve_dock_prm_path(preferred_rbt_root=self.config.rbt_root, executable=self.config.rbdock_bin) if candidate is not None: return candidate raise RDockPipelineError( "Could not locate rDock dock.prm. Pass --dock-prm or set RBT_ROOT so " "$RBT_ROOT/data/scripts/dock.prm exists." ) def check_required_tools(self, validation: bool = False) -> dict[str, str]: needed = { "rbdock": self.config.rbdock_bin, "rbcavity": self.config.rbcavity_bin, "obabel": self.config.obabel_bin, } if validation or self.config.require_reporting_tools: needed.update( { "sdsort": self.config.sdsort_bin, "sdfilter": self.config.sdfilter_bin, "sdreport": self.config.sdreport_bin, "sdrmsd": self.config.sdrmsd_bin, } ) return {key: require_executable(bin_name) for key, bin_name in needed.items()} def prepare_target(self, receptor: str | Path, reference_ligand: str | Path, out_dir: str | Path) -> TargetConfig: tools = self.check_required_tools(validation=False) receptor_path = require_file(receptor, "receptor structure") ref_path = require_file(reference_ligand, "reference ligand") out = Path(out_dir) out.mkdir(parents=True, exist_ok=True) command_log = out / "commands.log" runner = CommandRunner(command_log) receptor_copy = out / receptor_path.name reference_copy = out / ref_path.name if receptor_path.resolve() != receptor_copy.resolve(): shutil.copy2(receptor_path, receptor_copy) if ref_path.resolve() != reference_copy.resolve(): shutil.copy2(ref_path, reference_copy) center, diagnostics = _validate_receptor_ligand_geometry(receptor_copy, reference_copy) receptor_mol2 = out / "receptor.mol2" if receptor_copy.suffix.lower() == ".mol2": shutil.copy2(receptor_copy, receptor_mol2) else: rec = runner.run( "prepare_receptor_obabel", [tools["obabel"], str(receptor_copy.resolve()), "-O", str(receptor_mol2.resolve())], cwd=out, stdout_log=out / "prepare_receptor_obabel.stdout.log", stderr_log=out / "prepare_receptor_obabel.stderr.log", timeout=300, env=self._env(), ) fail_if_bad_command(rec, "OpenBabel receptor conversion") require_file(receptor_mol2, "prepared receptor MOL2") prm = out / "receptor.prm" prm.write_text( "\n".join( [ "RBT_PARAMETER_FILE_V1.00", "TITLE rdock_receptor_reference_ligand", f"RECEPTOR_FILE {receptor_mol2.name}", "", "SECTION MAPPER", " SITE_MAPPER RbtLigandSiteMapper", f" REF_MOL {reference_copy.name}", " RADIUS 6.0", " SMALL_SPHERE 1.5", "END_SECTION", "", "SECTION CAVITY", " SCORING_FUNCTION RbtCavityGridSF", "END_SECTION", "", ] ), encoding="utf-8", ) _normalize_receptor_prm_paths(prm, out, out) rec = runner.run( "rbcavity", [tools["rbcavity"], "-r", prm.name, "-was"], cwd=out, stdout_log=out / "rbcavity.stdout.log", stderr_log=out / "rbcavity.stderr.log", timeout=self.config.timeout_seconds, env=self._env(), ) fail_if_bad_command(rec, "rbcavity cavity generation") cavity = out / f"{prm.stem}.as" require_file(cavity, "rDock cavity .as file") if cavity.stat().st_size < 16: raise RDockPipelineError(f"rbcavity produced an invalid tiny cavity file: {cavity}") target_config = TargetConfig( receptor=str(receptor_copy), reference_ligand=str(reference_copy), target_dir=str(out), receptor_mol2=str(receptor_mol2), receptor_prm=str(prm), cavity_as=str(cavity), pocket_center=center, pocket_radius=float(max(6.0, diagnostics["reference_ligand_radius"] + 2.0)), diagnostics=diagnostics, ) _write_yaml_like(out / "target_config.yaml", asdict(target_config)) return target_config def _resolve_jobs(self, requested: int | str | None = None) -> int: value = self.config.jobs if requested is None else requested if isinstance(value, str) and value.lower() == "auto": cpus = os.cpu_count() or 1 reserve = 1 if cpus <= 4 else 2 return max(1, min(cpus - reserve, int(math.floor(cpus * self.config.cpu_fraction)))) return max(1, int(value)) def _split_input_sdf(self, ligands_sdf: Path, split_dir: Path, jobs: int, chunk_size: int | None = None) -> list[Path]: blocks = split_sdf_file(ligands_sdf) if jobs <= 1 or len(blocks) <= 1: target = split_dir / "chunk_000.sdf" write_sdf_blocks(blocks, target) return [target] max_chunk_records = int(chunk_size or 0) if max_chunk_records > 0: chunks = [blocks[idx : idx + max_chunk_records] for idx in range(0, len(blocks), max_chunk_records)] else: chunks = [[] for _ in range(min(jobs, len(blocks)))] for idx, block in enumerate(blocks): chunks[idx % len(chunks)].append(block) paths = [] for idx, chunk in enumerate(chunks): path = split_dir / f"chunk_{idx:03d}.sdf" write_sdf_blocks(chunk, path) paths.append(path) return paths def dock_sdf( self, target_config: TargetConfig, ligands_sdf: str | Path, run_dir: str | Path, n_runs: int | None = None, jobs: int | str | None = None, run_id: str | None = None, validation_labels_csv: str | Path | None = None, resume: bool = False, ) -> RunArtifacts: self.check_required_tools(validation=False) ligands = require_file(ligands_sdf, "ligand SDF") dock_prm = self._dock_prm() run_root = Path(run_dir) run_root.mkdir(parents=True, exist_ok=True) for name in ("target", "ligands", "rdock", "poses", "tables", "metrics"): (run_root / name).mkdir(parents=True, exist_ok=True) commands_log = run_root / "commands.log" runner = CommandRunner(commands_log) progress_log = run_root / "rdock" / "progress.log" def _emit_progress(message: str, payload: dict[str, Any] | None = None) -> None: line = f"[rdock] {message}" print(line, flush=True) progress_log.parent.mkdir(parents=True, exist_ok=True) with progress_log.open("a", encoding="utf-8") as handle: handle.write(line + "\n") if payload is not None: (run_root / "rdock" / "progress.json").write_text(json.dumps(payload, indent=2), encoding="utf-8") target_dir = run_root / "target" for src in (target_config.receptor, target_config.reference_ligand, target_config.receptor_mol2, target_config.receptor_prm, target_config.cavity_as): p = Path(src) if p.exists(): shutil.copy2(p, target_dir / p.name) lig_copy = run_root / "ligands" / ligands.name if ligands.resolve() != lig_copy.resolve(): shutil.copy2(ligands, lig_copy) shutil.copy2(dock_prm, run_root / "rdock" / "dock.prm") resolved_jobs = self._resolve_jobs(jobs) actual_n_runs = int(n_runs if n_runs is not None else self.config.n_runs) chunks = self._split_input_sdf(lig_copy, run_root / "rdock" / "chunks", resolved_jobs, self.config.chunk_size) rbdock = require_executable(self.config.rbdock_bin) failure_policy = os.environ.get("RDOCK_CHUNK_FAILURE_POLICY", "mark_failed").strip().lower() or "mark_failed" if failure_policy not in {"mark_failed", "fail"}: raise RDockPipelineError(f"Unsupported RDOCK_CHUNK_FAILURE_POLICY={failure_policy!r}") local_prm = require_file(target_dir / Path(target_config.receptor_prm).name, "copied receptor.prm for run") _normalize_receptor_prm_paths(local_prm, target_dir, target_dir) out_files: dict[int, Path] = {} failed_chunk_rows: list[dict[str, Any]] = [] failed_ligand_rows: list[dict[str, Any]] = [] records_without_score_dropped_total = 0 _emit_progress( "dock:start", { "run_dir": str(run_root), "jobs": resolved_jobs, "n_runs": actual_n_runs, "chunk_count": len(chunks), "ligands_sdf": str(lig_copy), "failure_policy": failure_policy, }, ) def _run_chunk(idx: int, chunk: Path) -> tuple[int, CommandRecord, Path]: out_prefix = run_root / "rdock" / f"chunk_{idx:03d}_out" out_sd = out_prefix.with_suffix(".sd") if resume and out_sd.exists() and out_sd.stat().st_size > 0: try: expected_ligand_ids = { ligand_id_from_block(block, parse_tags(block), block_idx) for block_idx, block in enumerate(split_sdf_file(chunk)) } valid_records, _ = _sanitize_chunk_output_scores(out_sd) if not valid_records: raise RDockPipelineError(f"Resume chunk {idx} has no valid scored poses after sanitization") observed_ligand_ids = {record.ligand_id for record in valid_records} if not expected_ligand_ids.issubset(observed_ligand_ids): missing = len(expected_ligand_ids - observed_ligand_ids) raise RDockPipelineError(f"Resume chunk {idx} is incomplete; missing scored poses for {missing} input ligands") stdout_log = run_root / "rdock" / f"chunk_{idx:03d}.stdout.log" stderr_log = run_root / "rdock" / f"chunk_{idx:03d}.stderr.log" stdout_log.touch(exist_ok=True) stderr_log.touch(exist_ok=True) rec = CommandRecord( stage=f"rbdock_chunk_{idx:03d}_resume", command=[rbdock, "-r", local_prm.name, "-p", str(dock_prm.resolve()), "-n", str(actual_n_runs), "-i", str(chunk.resolve()), "-o", str(out_prefix.resolve())], cwd=str(target_dir), start_time=datetime.now(UTC).isoformat(), end_time=datetime.now(UTC).isoformat(), exit_code=0, stdout_log=str(stdout_log), stderr_log=str(stderr_log), ) return idx, rec, out_sd except RDockPipelineError: try: out_sd.unlink(missing_ok=True) except Exception: pass rec = runner.run( f"rbdock_chunk_{idx:03d}", [ rbdock, "-r", local_prm.name, "-p", str(dock_prm.resolve()), "-n", str(actual_n_runs), "-i", str(chunk.resolve()), "-o", str(out_prefix.resolve()), ], cwd=target_dir, stdout_log=run_root / "rdock" / f"chunk_{idx:03d}.stdout.log", stderr_log=run_root / "rdock" / f"chunk_{idx:03d}.stderr.log", timeout=self.config.timeout_seconds, env=self._env(), ) return idx, rec, out_sd progress = tqdm(total=len(chunks), desc=f"rDock chunks ({actual_n_runs} runs)", unit="chunk") if tqdm is not None else None with ThreadPoolExecutor(max_workers=min(resolved_jobs, len(chunks))) as pool: futures = [pool.submit(_run_chunk, idx, chunk) for idx, chunk in enumerate(chunks)] completed = 0 for fut in as_completed(futures): idx, rec, out_sd = fut.result() stdout_log = run_root / "rdock" / f"chunk_{idx:03d}.stdout.log" stderr_log = run_root / "rdock" / f"chunk_{idx:03d}.stderr.log" chunk_blocks = split_sdf_file(chunks[idx]) failure_reason = "" dropped_records = 0 try: fail_if_bad_command(rec, f"rbdock chunk {idx}") require_file(out_sd, f"rDock output SDF for chunk {idx}") valid_records, dropped_records = _sanitize_chunk_output_scores(out_sd) if not valid_records: raise RDockPipelineError("rDock output had no valid scored poses") out_files[idx] = out_sd records_without_score_dropped_total += dropped_records except Exception as exc: failure_reason = _classify_chunk_failure(rec, out_sd, stdout_log, stderr_log) failed_chunk_rows.append( { "chunk_id": idx, "input_sdf": str(chunks[idx]), "expected_output_sdf": str(out_sd), "stdout_log": str(stdout_log), "stderr_log": str(stderr_log), "n_input_ligands": len(chunk_blocks), "failure_reason": failure_reason, "exit_code": rec.exit_code, "stdout_tail": _tail_text(stdout_log), "stderr_tail": _tail_text(stderr_log), } ) for block_index, block in enumerate(chunk_blocks): try: tags = parse_tags(block) ligand_id = ligand_id_from_block(block, tags, block_index) except Exception: ligand_id = f"ligand_{block_index:06d}" failed_ligand_rows.append( { "ligand_id": ligand_id, "chunk_id": idx, "failure_reason": failure_reason, "source_input_sdf": str(chunks[idx]), } ) if failure_policy == "fail": raise RDockPipelineError( f"rDock chunk {idx} failed with policy=fail: {failure_reason} ({exc})" ) from exc completed += 1 if progress is not None: progress.update(1) progress.set_postfix(last_chunk=idx, completed=f"{completed}/{len(chunks)}") _emit_progress( "dock:chunk_complete", { "completed_chunks": completed, "total_chunks": len(chunks), "last_chunk": idx, "output": str(out_sd), "records_without_score_dropped": dropped_records, "failure_reason": failure_reason, }, ) if progress is not None: progress.close() all_blocks: list[str] = [] for idx in sorted(out_files): all_blocks.extend(split_sdf_file(out_files[idx])) all_poses = run_root / "poses" / "all_poses.sdf" if all_blocks: write_sdf_blocks(all_blocks, all_poses) records = parse_rdock_sdf_records(all_poses, require_score=True) best = best_per_ligand(records) else: all_poses.write_text("", encoding="utf-8") records = [] best = [] best_sdf = write_sdf_records(best, run_root / "poses" / "best_per_ligand.sdf") best_ligand_poses_sdf: str | None = None if best: top_ligand_id = best[0].ligand_id best_ligand_records = [rec for rec in records if rec.ligand_id == top_ligand_id] best_ligand_path = run_root / "poses" / f"best_ligand_{actual_n_runs}.sdf" write_sdf_records(best_ligand_records, best_ligand_path) best_ligand_poses_sdf = str(best_ligand_path) scores_long = write_rows_csv(records_to_rows(records), run_root / "tables" / "scores_long.csv") best_csv = write_rows_csv(records_to_rows(best), run_root / "tables" / "best_per_ligand.csv") failed_chunks_csv = write_rows_csv(failed_chunk_rows, run_root / "tables" / "failed_chunks.csv") failed_ligands_csv = write_rows_csv(failed_ligand_rows, run_root / "tables" / "failed_ligands.csv") failure_summary = { "failure_policy": failure_policy, "total_chunks": len(chunks), "successful_chunks": len(out_files), "failed_chunks": len(failed_chunk_rows), "failed_ligands": len(failed_ligand_rows), "records_without_score_dropped": records_without_score_dropped_total, } (run_root / "metrics" / "rdock_failure_summary.json").write_text(json.dumps(failure_summary, indent=2), encoding="utf-8") labels_map: dict[str, int] = {} if validation_labels_csv: import pandas as pd label_df = pd.read_csv(validation_labels_csv) labels_map = dict(zip(label_df["ligand_id"].astype(str), label_df["label"].astype(int))) best_rows = records_to_rows(best) for row in best_rows: row["label"] = labels_map.get(str(row["ligand_id"]), 0) best_csv = write_rows_csv(best_rows, best_csv) manifest_path = run_root / "manifest.json" config_yaml = run_root / "config.yaml" report_md = run_root / "report.md" now = datetime.now(UTC).isoformat() file_inputs = { "ligands_sdf": str(lig_copy), "dock_prm": str(run_root / "rdock" / "dock.prm"), "receptor_prm": str(local_prm), "cavity_as": str(target_dir / Path(target_config.cavity_as).name), } manifest = { "run_id": run_id or run_root.name, "created_at": now, "engine": "real-rdock", "n_runs": actual_n_runs, "jobs": resolved_jobs, "input_hashes": {k: sha256_file(v) for k, v in file_inputs.items() if Path(v).exists()}, "rdock_versions": { "rbdock": probe_version(rbdock), "rbcavity": probe_version(require_executable(self.config.rbcavity_bin)), }, "target_config": asdict(target_config), "commands": [r.to_dict() for r in runner.records], "artifacts": { "all_poses_sdf": str(all_poses), "best_per_ligand_sdf": str(best_sdf), "best_ligand_poses_sdf": best_ligand_poses_sdf, "scores_long_csv": str(scores_long), "best_per_ligand_csv": str(best_csv), "failed_chunks_csv": str(failed_chunks_csv), "failed_ligands_csv": str(failed_ligands_csv), "rdock_failure_summary_json": str(run_root / "metrics" / "rdock_failure_summary.json"), "commands_log": str(commands_log), }, "pose_count": len(records), "docked_ligand_count": len(best), "rdock_failure_summary": failure_summary, } manifest_path.write_text(json.dumps(manifest, indent=2), encoding="utf-8") _write_yaml_like(config_yaml, {"rdock": asdict(self.config), "run": {"n_runs": actual_n_runs, "jobs": resolved_jobs}}) report_md.write_text( "\n".join( [ "# rDock Run Report", "", f"- Engine: `real-rdock`", f"- Run ID: `{manifest['run_id']}`", f"- n_runs per ligand: `{actual_n_runs}`", f"- local jobs: `{resolved_jobs}`", f"- poses parsed: `{len(records)}`", f"- docked ligands: `{len(best)}`", f"- failed chunks: `{failure_summary['failed_chunks']}`", f"- failed ligands: `{failure_summary['failed_ligands']}`", f"- all poses: `{all_poses}`", f"- best per ligand: `{best_sdf}`", f"- best ligand all poses: `{best_ligand_poses_sdf or ''}`", f"- command log: `{commands_log}`", "", "No surrogate or undocked ligand is reported as a real rDock hit; hit tables are generated only from parsed rDock SDF records with native SCORE fields.", ] ), encoding="utf-8", ) _emit_progress( "dock:done", { "run_dir": str(run_root), "pose_count": len(records), "docked_ligands": len(best), "all_poses_sdf": str(all_poses), "best_per_ligand_csv": str(best_csv), "failed_chunks": failure_summary["failed_chunks"], "failed_ligands": failure_summary["failed_ligands"], }, ) return RunArtifacts( run_dir=str(run_root), manifest=str(manifest_path), config_yaml=str(config_yaml), commands_log=str(commands_log), all_poses_sdf=str(all_poses), best_per_ligand_sdf=str(best_sdf), scores_long_csv=str(scores_long), best_per_ligand_csv=str(best_csv), report_md=str(report_md), command_records=[r.to_dict() for r in runner.records], best_ligand_poses_sdf=best_ligand_poses_sdf, ) def load_target_config(path: str | Path) -> TargetConfig: source = require_file(path, "target config") try: import yaml data = yaml.safe_load(source.read_text(encoding="utf-8")) except Exception: data = json.loads(source.read_text(encoding="utf-8")) if not isinstance(data, dict): raise RDockPipelineError(f"Invalid target config payload in {source}") config_dir = source.parent.resolve() dataset_target_dir = config_dir.parent.resolve() def _rebase_file(value: object, *candidate_dirs: Path) -> str: text = str(value or "").strip() if not text: return text current = Path(text) if current.exists(): return str(current.resolve()) for base in candidate_dirs: candidate = (base / current.name).resolve() if candidate.exists(): return str(candidate) return text data["target_dir"] = str(config_dir) data["receptor_prm"] = _rebase_file(data.get("receptor_prm", ""), config_dir) data["cavity_as"] = _rebase_file(data.get("cavity_as", ""), config_dir) data["receptor_mol2"] = _rebase_file(data.get("receptor_mol2", ""), config_dir, dataset_target_dir) data["reference_ligand"] = _rebase_file(data.get("reference_ligand", ""), config_dir, dataset_target_dir) data["receptor"] = _rebase_file(data.get("receptor", ""), config_dir, dataset_target_dir) if data.get("receptor_prm"): _normalize_receptor_prm_paths(Path(str(data["receptor_prm"])), config_dir, dataset_target_dir) return TargetConfig(**data)