| |
| """Submit docking-analysis jobs for all configured method/mode combinations.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import shlex |
| import subprocess |
| from pathlib import Path |
| from typing import Any |
|
|
| import yaml |
|
|
|
|
| SCRIPT_DIR = Path(__file__).resolve().parent |
| REPO_ROOT = SCRIPT_DIR.parent |
| ANALYSIS_SCRIPT = SCRIPT_DIR / "analyse_docking.py" |
| DEFAULT_SOFTWARE_SETTINGS = REPO_ROOT / "configs" / "docking" / "software_settings.yaml" |
|
|
|
|
| def load_yaml(path: Path) -> dict[str, Any]: |
| """Load a YAML file and require a mapping at the top level.""" |
| if not path.is_file(): |
| raise FileNotFoundError(f"YAML file not found: {path}") |
| with path.open("r", encoding="utf-8") as handle: |
| data = yaml.safe_load(handle) |
| if not isinstance(data, dict): |
| raise ValueError(f"YAML root must be a mapping: {path}") |
| return data |
|
|
|
|
| def configured_runs(config: dict[str, Any]) -> list[tuple[str, str]]: |
| """Return all method/mode combinations declared by the docking config.""" |
| modes = config.get("modes") |
| methods = config.get("methods") |
| if ( |
| not isinstance(modes, list) |
| or not modes |
| or not all(isinstance(x, str) for x in modes) |
| ): |
| raise ValueError("Docking config 'modes' must be a non-empty list of strings") |
| if not isinstance(methods, dict) or not methods: |
| raise ValueError("Docking config 'methods' must be a non-empty mapping") |
| return [(str(method), mode) for method in methods for mode in modes] |
|
|
|
|
| def cpu_profile(settings: dict[str, Any]) -> dict[str, Any]: |
| """Return the CPU Slurm profile and validate its worker count.""" |
| profiles = settings.get("profiles") |
| if not isinstance(profiles, dict) or not isinstance(profiles.get("cpu"), dict): |
| raise ValueError("Software settings must define profiles.cpu") |
| profile = profiles["cpu"] |
| cpus = profile.get("cpus-per-task") |
| if not isinstance(cpus, int) or cpus < 1: |
| raise ValueError("profiles.cpu.cpus-per-task must be a positive integer") |
| return profile |
|
|
|
|
| def sbatch_command( |
| profile: dict[str, Any], |
| job_name: str, |
| output_log: Path, |
| wrap_command: list[str], |
| ) -> list[str]: |
| """Build one generic ``sbatch`` command from a profile mapping.""" |
| command = ["sbatch"] |
| for key, value in profile.items(): |
| if value in (None, "", False): |
| continue |
| command.append(f"--{key}" if value is True else f"--{key}={value}") |
| command += [ |
| f"--job-name={job_name}", |
| f"--output={output_log}", |
| f"--wrap={shlex.join(wrap_command)}", |
| ] |
| return command |
|
|
|
|
| def build_parser() -> argparse.ArgumentParser: |
| """Build the command-line parser.""" |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument( |
| "docking_dir", |
| type=Path, |
| help="Docking output directory containing method_mode run directories.", |
| ) |
| parser.add_argument( |
| "--config", required=True, type=Path, help="Docking experiment YAML file." |
| ) |
| parser.add_argument( |
| "--software-settings", |
| type=Path, |
| default=DEFAULT_SOFTWARE_SETTINGS, |
| help=f"Software and Slurm YAML (default: {DEFAULT_SOFTWARE_SETTINGS}).", |
| ) |
| parser.add_argument( |
| "--output-dir", |
| type=Path, |
| default=None, |
| help="Analysis root (default: sibling analysis directory).", |
| ) |
| parser.add_argument( |
| "--dry-run", |
| action="store_true", |
| help="Print sbatch commands without submitting.", |
| ) |
| return parser |
|
|
|
|
| def main() -> None: |
| """Submit one analysis job for every available configured docking run.""" |
| args = build_parser().parse_args() |
|
|
| if not ANALYSIS_SCRIPT.is_file(): |
| raise FileNotFoundError(f"Analysis script not found: {ANALYSIS_SCRIPT}") |
|
|
| docking_dir = args.docking_dir.expanduser().resolve() |
| if not docking_dir.is_dir(): |
| raise FileNotFoundError(f"Docking directory not found: {docking_dir}") |
|
|
| config = load_yaml(args.config.expanduser().resolve()) |
| settings = load_yaml(args.software_settings.expanduser().resolve()) |
|
|
| profile = cpu_profile(settings) |
| workers = int(profile["cpus-per-task"]) |
|
|
| analysis_dir = ( |
| args.output_dir.expanduser().resolve() |
| if args.output_dir is not None |
| else docking_dir.parent / "analysis" |
| ) |
|
|
| log_dir = analysis_dir / "logs" |
| log_dir.mkdir(parents=True, exist_ok=True) |
|
|
| runs = configured_runs(config) |
|
|
| available_runs = [] |
| missing_runs = [] |
|
|
| for method, mode in runs: |
| run_dir = docking_dir / f"{method}_{mode}" |
| if run_dir.is_dir(): |
| available_runs.append((method, mode, run_dir)) |
| else: |
| missing_runs.append(run_dir) |
|
|
| if missing_runs: |
| print( |
| "Warning: configured docking run directories are missing " |
| "and will be skipped:", |
| flush=True, |
| ) |
| for run_dir in missing_runs: |
| print(f" {run_dir}", flush=True) |
|
|
| if not available_runs: |
| raise FileNotFoundError("None of the configured docking run directories exist.") |
|
|
| submitted = 0 |
| failed = 0 |
|
|
| for method, mode, run_dir in available_runs: |
| job_name = f"ana_{method}_{mode}" |
|
|
| wrap = [ |
| "python", |
| "-u", |
| str(ANALYSIS_SCRIPT), |
| str(run_dir), |
| "--method", |
| method, |
| "--mode", |
| mode, |
| "--output-dir", |
| str(analysis_dir), |
| "--num-workers", |
| str(workers), |
| ] |
|
|
| command = sbatch_command( |
| profile=profile, |
| job_name=job_name, |
| output_log=log_dir / f"{job_name}-%j.out", |
| wrap_command=wrap, |
| ) |
|
|
| if args.dry_run: |
| print(shlex.join(command)) |
| submitted += 1 |
| continue |
|
|
| try: |
| subprocess.run(command, check=True) |
| except subprocess.CalledProcessError as exc: |
| failed += 1 |
| print( |
| f"Failed to submit {job_name}: {exc}", |
| flush=True, |
| ) |
| else: |
| submitted += 1 |
| print(f"Submitted {job_name}", flush=True) |
|
|
| print() |
|
|
| if args.dry_run: |
| print(f"Analysis jobs to submit: {submitted}") |
| else: |
| print(f"Successfully submitted analysis jobs: {submitted}") |
|
|
| if failed: |
| print(f"Failed submissions: {failed}") |
|
|
| if missing_runs: |
| print(f"Skipped missing runs: {len(missing_runs)}") |
|
|
| if failed: |
| raise SystemExit(1) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
