| |
| """Run one docking method over a prepared OpenBind docking-mode directory.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import shlex |
| import shutil |
| import subprocess |
| import sys |
| import time |
| from pathlib import Path |
|
|
| from rdkit import Chem |
| from rdkit.Chem import rdMolTransforms |
|
|
| from datetime import datetime |
|
|
| Coord3D = tuple[float, float, float] |
| SUPPORTED_ENGINES = {"gnina", "smina", "diffdock"} |
|
|
|
|
| def log(message: str) -> None: |
| """Print a timestamped status message.""" |
| timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") |
| print(f"[{timestamp}] {message}", flush=True) |
|
|
|
|
| def validate_file(path: Path, label: str) -> Path: |
| """Require a non-empty input file.""" |
| if not path.is_file(): |
| raise FileNotFoundError(f"Missing {label}: {path}") |
| if path.stat().st_size == 0: |
| raise ValueError(f"Empty {label}: {path}") |
| return path |
|
|
|
|
| def compute_centroid(sdf_path: Path) -> Coord3D: |
| """Return the centroid of the first conformer in an SDF file.""" |
| mol = Chem.MolFromMolFile(str(sdf_path), removeHs=False) |
| if mol is None or mol.GetNumConformers() == 0: |
| raise ValueError(f"RDKit could not read a 3D ligand from: {sdf_path}") |
| centroid = rdMolTransforms.ComputeCentroid(mol.GetConformer(0)) |
| return float(centroid.x), float(centroid.y), float(centroid.z) |
|
|
|
|
| def reference_complex_dir(mode_dir: Path, complex_id: str) -> Path: |
| """Return the redock directory providing ligand inputs and reference poses.""" |
| root = mode_dir if mode_dir.name == "redock" else mode_dir.parent / "redock" |
| complex_dir = root / complex_id |
| if not complex_dir.is_dir(): |
| raise FileNotFoundError(f"Redock complex directory not found: {complex_dir}") |
| return complex_dir |
|
|
|
|
| def receptor_path( |
| complex_dir: Path, |
| complex_id: str, |
| mode_label: str, |
| ) -> Path: |
| """Resolve the receptor file using the fixed prepared-input naming scheme.""" |
| if mode_label == "redock": |
| return validate_file(complex_dir / f"{complex_id}_prepared.pdb", "receptor") |
| if mode_label == "fragment_crossdock": |
| matches = sorted(complex_dir.glob("fragment_crossdock_*_aligned.pdb")) |
| if len(matches) != 1: |
| raise FileNotFoundError( |
| f"Expected exactly one fragment-crossdock receptor in {complex_dir}; " |
| f"found {len(matches)}" |
| ) |
| return validate_file(matches[0], "receptor") |
| return validate_file( |
| complex_dir / f"{mode_label}_prepared_aligned.pdb", |
| "receptor", |
| ) |
|
|
|
|
| def ligand_input_path(reference_dir: Path, complex_id: str, input_num: int) -> Path: |
| """Return one prepared ligand conformer.""" |
| return validate_file( |
| reference_dir / f"{complex_id}_ligand_prepared_{input_num}.sdf", |
| "ligand input", |
| ) |
|
|
|
|
| def reference_ligand_path(reference_dir: Path, complex_id: str) -> Path: |
| """Return the crystallographic ligand used for docking-box placement.""" |
| return validate_file( |
| reference_dir / f"{complex_id}_reference_ligand.sdf", |
| "reference ligand", |
| ) |
|
|
|
|
| def build_box_args( |
| size: str, |
| reference_ligand: Path, |
| centre: Coord3D | None, |
| ) -> list[str]: |
| """Build GNINA/Smina box arguments.""" |
| if size.startswith("autobox"): |
| parts = size.split("_", maxsplit=1) |
| args = ["--autobox_ligand", str(reference_ligand)] |
| if len(parts) == 2: |
| try: |
| float(parts[1]) |
| except ValueError as exc: |
| raise ValueError(f"Invalid autobox size: {size}") from exc |
| args += ["--autobox_add", parts[1]] |
| return args |
|
|
| try: |
| box_size = float(size) |
| except ValueError as exc: |
| raise ValueError( |
| "--size must be numeric or use the form autobox[_ADD]" |
| ) from exc |
| if box_size <= 0: |
| raise ValueError("--size must be greater than zero") |
|
|
| x, y, z = centre if centre is not None else compute_centroid(reference_ligand) |
| return [ |
| "--center_x", |
| str(x), |
| "--center_y", |
| str(y), |
| "--center_z", |
| str(z), |
| "--size_x", |
| str(box_size), |
| "--size_y", |
| str(box_size), |
| "--size_z", |
| str(box_size), |
| ] |
|
|
|
|
| def add_cnn_model_args(command: list[str], cnn_model: str | None) -> None: |
| """Append GNINA CNN model arguments.""" |
| if cnn_model in (None, "default"): |
| return |
|
|
| path = Path(cnn_model).expanduser().resolve() |
| if path.is_file(): |
| command += ["--cnn_model", str(path)] |
| return |
| if path.is_dir(): |
| models = sorted(path.glob("*.pt")) |
| if not models: |
| raise FileNotFoundError(f"No .pt models found in: {path}") |
| command.extend(["--cnn_model", *map(str, models)]) |
| return |
| raise FileNotFoundError(f"CNN model path not found: {path}") |
|
|
|
|
| def diffdock_complete(poses_dir: Path, num_modes: int) -> bool: |
| """Return whether a DiffDock run already contains the requested pose count.""" |
| poses = sorted(poses_dir.glob("rank*_confidence*.sdf")) |
| return len(poses) >= num_modes and all(path.stat().st_size > 0 for path in poses) |
|
|
|
|
| def run_docking( |
| complex_dir: Path, |
| mode_dir: Path, |
| complex_id: str, |
| engine: str, |
| method: Path, |
| method_label: str, |
| mode_label: str, |
| output_dir: Path, |
| input_num: int, |
| num_modes: int, |
| exhaustiveness: int, |
| size: str, |
| seed: int, |
| scoring: str | None, |
| cnn_model: str | None, |
| centre: Coord3D | None, |
| overwrite: bool, |
| ) -> tuple[int, Path, Path]: |
| """Run one docking task and return the exit code and output paths.""" |
| receptor = receptor_path(complex_dir, complex_id, mode_label) |
| reference_dir = reference_complex_dir(mode_dir, complex_id) |
| ligand_input = ligand_input_path(reference_dir, complex_id, input_num) |
| reference_ligand = reference_ligand_path(reference_dir, complex_id) |
|
|
| setup_label = f"{method_label}_{mode_label}" |
| seed_dir = output_dir / setup_label / complex_id / f"seed_{seed}" |
| poses_dir = seed_dir / "docked_poses" |
| poses_dir.mkdir(parents=True, exist_ok=True) |
| log_file = seed_dir / f"{complex_id}_{input_num}.log" |
|
|
| if engine == "diffdock": |
| if not overwrite and diffdock_complete(poses_dir, num_modes): |
| return 0, poses_dir, log_file |
| command = [ |
| sys.executable, |
| "inference.py", |
| "--config", |
| "default_inference_args.yaml", |
| "--protein_path", |
| str(receptor), |
| "--ligand_description", |
| str(ligand_input), |
| "--out_dir", |
| str(seed_dir), |
| "--complex_name", |
| poses_dir.name, |
| ] |
| cwd = method |
| expected_output: Path | None = None |
| else: |
| expected_output = poses_dir / f"{complex_id}_docked_{input_num}.sdf" |
| if ( |
| not overwrite |
| and expected_output.is_file() |
| and expected_output.stat().st_size > 0 |
| ): |
| return 0, poses_dir, log_file |
| command = [ |
| str(method), |
| "--receptor", |
| str(receptor), |
| "--ligand", |
| str(ligand_input), |
| "--out", |
| str(expected_output), |
| "--exhaustiveness", |
| str(exhaustiveness), |
| "--num_modes", |
| str(num_modes), |
| "--seed", |
| str(seed), |
| *build_box_args(size, reference_ligand, centre), |
| ] |
| if scoring is not None: |
| command += ["--scoring", scoring] |
| if engine == "gnina": |
| add_cnn_model_args(command, cnn_model) |
| cwd = None |
|
|
| with log_file.open("w", encoding="utf-8") as handle: |
| handle.write(shlex.join(command) + "\n\n") |
| handle.flush() |
| result = subprocess.run( |
| command, |
| stdout=handle, |
| stderr=subprocess.STDOUT, |
| cwd=cwd, |
| check=False, |
| ) |
|
|
| if result.returncode == 0 and expected_output is not None: |
| validate_file(expected_output, "docking output") |
| return result.returncode, poses_dir, log_file |
|
|
|
|
| def parse_centre(args: argparse.Namespace) -> Coord3D | None: |
| """Parse an optional explicit docking-box centre.""" |
| values = (args.x_coord, args.y_coord, args.z_coord) |
| if any(value is not None for value in values) and not all( |
| value is not None for value in values |
| ): |
| raise ValueError("Provide all of --x-coord, --y-coord and --z-coord, or none") |
| if values[0] is None: |
| return None |
| return float(values[0]), float(values[1]), float(values[2]) |
|
|
|
|
| def find_complexes(mode_dir: Path, complex_id: str | None) -> list[Path]: |
| """Return selected prepared complex directories.""" |
| if complex_id is not None: |
| path = mode_dir / complex_id |
| if not path.is_dir(): |
| raise FileNotFoundError(f"Complex directory not found: {path}") |
| return [path] |
| complexes = sorted(path for path in mode_dir.iterdir() if path.is_dir()) |
| if not complexes: |
| raise ValueError(f"No complex directories found in {mode_dir}") |
| return complexes |
|
|
|
|
| def validate_method(engine: str, method: Path) -> Path: |
| """Validate the configured docking executable or DiffDock directory.""" |
| path = method.expanduser().resolve() |
| if engine == "diffdock": |
| if not path.is_dir() or not (path / "inference.py").is_file(): |
| raise FileNotFoundError( |
| f"DiffDock directory or inference.py not found: {path}" |
| ) |
| elif not path.is_file(): |
| raise FileNotFoundError(f"Docking executable not found: {path}") |
| return path |
|
|
|
|
| def build_parser() -> argparse.ArgumentParser: |
| """Build the command-line parser.""" |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument( |
| "mode_dir", type=Path, help="Prepared directory for one docking mode." |
| ) |
| parser.add_argument("--engine", required=True, choices=sorted(SUPPORTED_ENGINES)) |
| parser.add_argument( |
| "--method", |
| required=True, |
| type=Path, |
| help="Executable or DiffDock directory.", |
| ) |
| parser.add_argument( |
| "--method-label", required=True, help="Method label used in output paths." |
| ) |
| parser.add_argument( |
| "--mode-label", required=True, help="Prepared mode directory name." |
| ) |
| parser.add_argument( |
| "--output-dir", required=True, type=Path, help="Docking output root." |
| ) |
| parser.add_argument("--exhaustiveness", type=int, default=8) |
| parser.add_argument("--num-inputs", type=int, default=1) |
| parser.add_argument("--num-modes", type=int, default=8) |
| parser.add_argument("--size", default="25", help="Box size or autobox[_ADD].") |
| parser.add_argument("--seed", type=int, default=1) |
| parser.add_argument("--scoring", default=None) |
| parser.add_argument("--cnn-model", default=None) |
| parser.add_argument("--complex-id", default=None, help="Run one complex only.") |
| parser.add_argument("--overwrite", action="store_true") |
| parser.add_argument("--x-coord", type=float, default=None) |
| parser.add_argument("--y-coord", type=float, default=None) |
| parser.add_argument("--z-coord", type=float, default=None) |
| return parser |
|
|
|
|
| def main() -> None: |
| """Run docking across the selected complexes.""" |
| args = build_parser().parse_args() |
| mode_dir = args.mode_dir.expanduser().resolve() |
| if not mode_dir.is_dir(): |
| raise FileNotFoundError(f"Prepared mode directory not found: {mode_dir}") |
| if args.mode_label != mode_dir.name: |
| raise ValueError( |
| f"--mode-label must match the prepared directory name exactly: {mode_dir.name}" |
| ) |
| if args.num_inputs < 1 or args.num_modes < 1 or args.exhaustiveness < 1: |
| raise ValueError( |
| "--num-inputs, --num-modes and --exhaustiveness must be positive" |
| ) |
|
|
| method = validate_method(args.engine, args.method) |
|
|
| output_dir = args.output_dir.expanduser().resolve() |
| centre = parse_centre(args) |
| complexes = find_complexes(mode_dir, args.complex_id) |
| num_inputs = 1 if args.engine == "diffdock" else args.num_inputs |
|
|
| log(f"Prepared mode: {mode_dir}") |
| log(f"Output root: {output_dir}") |
| log(f"Method: {args.method_label} ({args.engine})") |
| log(f"Complexes: {len(complexes)}") |
|
|
| start = time.time() |
| failures: list[tuple[str, str, Path | None]] = [] |
| succeeded = 0 |
| attempted = 0 |
|
|
| for complex_dir in complexes: |
| complex_id = complex_dir.name |
| if args.overwrite: |
| seed_dir = ( |
| output_dir |
| / f"{args.method_label}_{args.mode_label}" |
| / complex_id |
| / f"seed_{args.seed}" |
| ) |
| if seed_dir.exists(): |
| shutil.rmtree(seed_dir) |
|
|
| for input_num in range(1, num_inputs + 1): |
| attempted += 1 |
| task_id = f"{complex_id}_{input_num}" |
| log(f"-> {task_id} ...") |
| try: |
| return_code, poses_dir, log_file = run_docking( |
| complex_dir=complex_dir, |
| mode_dir=mode_dir, |
| complex_id=complex_id, |
| engine=args.engine, |
| method=method, |
| method_label=args.method_label, |
| mode_label=args.mode_label, |
| output_dir=output_dir, |
| input_num=input_num, |
| num_modes=args.num_modes, |
| exhaustiveness=args.exhaustiveness, |
| size=str(args.size), |
| seed=args.seed, |
| scoring=args.scoring, |
| cnn_model=args.cnn_model, |
| centre=centre, |
| overwrite=args.overwrite, |
| ) |
| except Exception as exc: |
| log(f" ERROR: {exc}") |
| failures.append((task_id, str(exc), None)) |
| continue |
|
|
| if return_code == 0: |
| succeeded += 1 |
| log(" OK") |
| else: |
| log(f" FAILED (exit {return_code})") |
| failures.append((task_id, f"exit code {return_code}", log_file)) |
|
|
| elapsed = time.strftime("%H:%M:%S", time.gmtime(time.time() - start)) |
| success_pct = 100.0 * succeeded / attempted if attempted else 0.0 |
| log( |
| f"Summary: complexes={len(complexes)}, tasks={attempted}, " |
| f"succeeded={succeeded} ({success_pct:.1f}%), failed={len(failures)}" |
| ) |
| log(f"Elapsed time: {elapsed}") |
|
|
| if failures: |
| for task_id, error, log_file in failures: |
| log_text = f"; log={log_file}" if log_file is not None else "" |
| log(f" - {task_id}: {error}{log_text}") |
| raise SystemExit(1) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
