from __future__ import annotations import argparse import json import sys import tempfile from pathlib import Path from typing import Any, Dict, List import yaml ROOT_DIR = Path(__file__).resolve().parents[1] if str(ROOT_DIR) not in sys.path: sys.path.insert(0, str(ROOT_DIR)) from libs.benchmark.cleanup import execute_results_cleanup, plan_results_cleanup from libs.benchmark.runtime import AUTO_MINUS_FOUR from libs.utils.config import load_config from pipeline.run_large_benchmark import run_large_benchmark from pipeline.run_fixed_pocket_repair import run_fixed_pocket_repair from pipeline.run_policy_repair_benchmark import run_policy_repair_benchmark from pipeline.run_ppi_sanity_check import run_ppi_sanity_check SUPPORTED_BENCHMARK_TYPES = { "small_molecule", "peptide_like", "policy_repair", "fixed_pocket_repair", } def _parse_bool(text: str) -> bool: v = str(text).strip().lower() if v in {"1", "true", "t", "yes", "y"}: return True if v in {"0", "false", "f", "no", "n"}: return False raise ValueError(f"Invalid boolean value: {text}") def _build_large_config(args: argparse.Namespace) -> Dict[str, Any]: cfg = load_config(args.config_template) cfg.setdefault("run", {}) cfg.setdefault("target", {}) cfg.setdefault("reference", {}) cfg.setdefault("benchmark_dataset", {}) cfg.setdefault("backend", {}) cfg.setdefault("matrix", {}) if args.output_dir: cfg["run"]["output_dir"] = args.output_dir if args.pdb_id: cfg["target"]["docking_reference_pdb"] = str(args.pdb_id) cfg["reference"]["pdb_id"] = str(args.pdb_id) if args.ligand_id: cfg["reference"]["ligand_comp_id"] = str(args.ligand_id) if args.reference_id: cfg["reference"]["reference_id"] = str(args.reference_id) if args.n_ligands is not None: cfg["benchmark_dataset"]["target_size"] = int(args.n_ligands) cfg["run"]["adaptive_budget"] = int(args.n_ligands) cfg["run"]["baseline_budget"] = int(args.n_ligands) cfg["run"]["max_batches"] = max(1, int(args.n_ligands) // max(1, int(cfg["run"].get("batch_size", 32))) + 10) mode_map = { "docking-only": ["docking_only"], "full-feature": ["full_feature"], "both": ["docking_only", "full_feature"], } cfg["matrix"]["modes"] = mode_map[args.mode] strategies = {s.strip().lower() for s in args.strategies} cfg["matrix"]["include_adaptive"] = "adaptive" in strategies cfg["matrix"]["include_naive_random"] = "naive" in strategies cfg["matrix"]["include_cluster_naive"] = "cluster-naive" in strategies cfg["matrix"]["naive_random_seeds"] = [11 + i * 11 for i in range(max(0, int(args.naive_runs)))] cfg["matrix"]["cluster_naive_seeds"] = [101 + i * 101 for i in range(max(0, int(args.cluster_runs)))] if "docking_only" not in cfg["matrix"]["modes"]: cfg["matrix"]["include_adaptive_top1_variant"] = False cfg["backend"]["type"] = args.backend cfg["backend"]["require_real_backend"] = bool(args.require_real_backend) cfg["backend"]["parallel_jobs"] = args.threads cfg["backend"]["pocket_mode"] = str(args.pocket_mode) if args.pocket_center: cfg["backend"]["pocket_center"] = str(args.pocket_center) if args.pocket_box_size: cfg["backend"]["pocket_box_size"] = str(args.pocket_box_size) if args.pocket_radius is not None: cfg["backend"]["pocket_radius"] = float(args.pocket_radius) if args.pocket_reference_ligand_id: cfg["backend"]["pocket_reference_ligand_id"] = str(args.pocket_reference_ligand_id) if args.pocket_relaxation_margin is not None: cfg["backend"]["pocket_relaxation_margin"] = float(args.pocket_relaxation_margin) cfg["run"]["enable_adaptive_early_stop"] = bool(args.enable_early_stop) cfg["run"]["allow_resume"] = bool(args.allow_resume) return cfg def _validate_runner_args(args: argparse.Namespace) -> None: btype = str(args.benchmark_type).strip().lower() if btype not in SUPPORTED_BENCHMARK_TYPES: raise ValueError(f"Unsupported benchmark_type `{args.benchmark_type}`") if btype == "peptide_like": if args.backend != "rdock": raise ValueError("peptide_like mode does not accept --backend overrides; use default architecture-level proxy path") if args.mode != "full-feature": raise ValueError("peptide_like mode does not use docking mode matrix; keep --mode full-feature") if args.strategies != ["adaptive", "naive", "cluster-naive"]: raise ValueError("peptide_like mode does not use small-molecule strategy matrix arguments") def main() -> int: parser = argparse.ArgumentParser(description="Unified production benchmark runner") parser.add_argument("--benchmark-type", default="small_molecule", choices=sorted(SUPPORTED_BENCHMARK_TYPES)) parser.add_argument("--config-template", default="configs/large_benchmark.yaml") parser.add_argument("--pdb-id", default="") parser.add_argument("--ligand-id", default="") parser.add_argument("--reference-id", default="") parser.add_argument("--n-ligands", type=int, default=None) parser.add_argument("--strategies", nargs="+", default=["adaptive", "naive", "cluster-naive"]) parser.add_argument("--naive-runs", type=int, default=5) parser.add_argument("--cluster-runs", type=int, default=5) parser.add_argument("--mode", choices=["docking-only", "full-feature", "both"], default="full-feature") parser.add_argument("--backend", choices=["rdock"], default="rdock") parser.add_argument( "--pocket-mode", choices=["user_fixed_pocket", "reference_complex_pocket", "reference_complex_pocket_relaxed"], default="reference_complex_pocket", ) parser.add_argument("--pocket-center", default="") parser.add_argument("--pocket-box-size", default="") parser.add_argument("--pocket-radius", type=float, default=None) parser.add_argument("--pocket-reference-ligand-id", default="") parser.add_argument("--pocket-relaxation-margin", type=float, default=0.0) parser.add_argument("--require-real-backend", type=_parse_bool, default=True) parser.add_argument("--threads", default=AUTO_MINUS_FOUR) parser.add_argument("--enable-early-stop", type=_parse_bool, default=True) parser.add_argument("--allow-resume", type=_parse_bool, default=True) parser.add_argument("--output-dir", default="") parser.add_argument("--ppi-config", default="configs/ppi_sanity_check.yaml") parser.add_argument("--cleanup-legacy-results", type=_parse_bool, default=False) parser.add_argument("--policy-repair-config", default="configs/policy_repair_benchmark.yaml") args = parser.parse_args() _validate_runner_args(args) outputs: Dict[str, Any] = {} if args.cleanup_legacy_results: plan = plan_results_cleanup(ROOT_DIR / "results") archive_dir = execute_results_cleanup(ROOT_DIR / "results", plan) outputs["cleanup"] = { "items": [str(x.path) for x in plan], "archive_dir": str(archive_dir), } if args.benchmark_type == "small_molecule": large_cfg = _build_large_config(args) with tempfile.TemporaryDirectory() as tmp: cfg_path = Path(tmp) / "run_benchmark.generated.yaml" cfg_path.write_text(yaml.safe_dump(large_cfg, sort_keys=False), encoding="utf-8") outputs["small_molecule"] = run_large_benchmark(cfg_path) elif args.benchmark_type == "policy_repair": outputs["policy_repair"] = run_policy_repair_benchmark(args.policy_repair_config) elif args.benchmark_type == "fixed_pocket_repair": outputs["fixed_pocket_repair"] = run_fixed_pocket_repair() elif args.benchmark_type == "peptide_like": outputs["ppi_sanity"] = run_ppi_sanity_check(args.ppi_config) else: raise NotImplementedError("Unreachable benchmark type state") print(json.dumps(outputs, indent=2)) return 0 if __name__ == "__main__": raise SystemExit(main())