| """Validate and execute a YAML-defined doc2harness run. |
| |
| A run must name an executable production backend in ``executor.command`` (or |
| through ``SBH_PRODUCTION_EXECUTOR``); there is no built-in stand-in that would |
| let a misconfigured run look like it scored something. ``--dry-run`` validates |
| the complete plan and writes no model result; without it, each configured model |
| is invoked through the declared executor, respecting the configured concurrency |
| limit. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import os |
| import shlex |
| import subprocess |
| import sys |
| from concurrent.futures import ThreadPoolExecutor, as_completed |
| from pathlib import Path |
| from typing import Any |
|
|
|
|
| class RunConfigError(ValueError): |
| """Raised when a run configuration is incomplete or unsafe.""" |
|
|
|
|
| def _load_yaml(path: Path) -> dict[str, Any]: |
| try: |
| import yaml |
| except ImportError as exc: |
| raise RunConfigError( |
| "PyYAML is required for YAML run configs; install the run requirements" |
| ) from exc |
| try: |
| value = yaml.safe_load(path.read_text(encoding="utf-8")) |
| except (OSError, yaml.YAMLError) as exc: |
| raise RunConfigError(f"cannot read YAML config {path}: {exc}") from exc |
| if not isinstance(value, dict): |
| raise RunConfigError("top-level YAML value must be a mapping") |
| return value |
|
|
|
|
| def _mapping(value: Any, name: str) -> dict[str, Any]: |
| if not isinstance(value, dict): |
| raise RunConfigError(f"{name} must be a mapping") |
| return value |
|
|
|
|
| def _nonempty_string(value: Any, name: str) -> str: |
| if not isinstance(value, str) or not value.strip(): |
| raise RunConfigError(f"{name} must be a non-empty string") |
| return value.strip() |
|
|
|
|
| def _repo_path(repo_root: Path, value: Any, name: str) -> Path: |
| raw = Path(_nonempty_string(value, name)).expanduser() |
| return raw if raw.is_absolute() else repo_root / raw |
|
|
|
|
| def _catalog_ids(repo_root: Path) -> tuple[str, ...]: |
| from doc2harness.benchmark.catalog import ( |
| load_catalog_sources, |
| parse_catalog_root, |
| ) |
|
|
| package = repo_root / "src" / "doc2harness" |
| benchmark = package / "benchmark" |
| root = parse_catalog_root((benchmark / "catalog_root.toml").read_bytes()) |
| resources = { |
| root.taxonomy_resource: (benchmark / "taxonomy.toml").read_bytes(), |
| **{ |
| shard.resource: (package / Path(*shard.resource.segments)).read_bytes() |
| for shard in root.shards |
| }, |
| } |
| definitions = load_catalog_sources( |
| root, |
| resources, |
| lambda module, export: __import__(module, fromlist=[export]).__dict__[export], |
| ) |
| return tuple(item.scenario_id for item in definitions) |
|
|
|
|
| def _expand(value: str) -> str: |
| return os.path.expandvars(value) |
|
|
|
|
| def _command(executor: dict[str, Any], *, allow_missing: bool) -> list[str]: |
| configured = executor.get("command") |
| if configured is None or configured == []: |
| env_command = os.environ.get("SBH_PRODUCTION_EXECUTOR", "").strip() |
| if not env_command: |
| if allow_missing: |
| return [] |
| raise RunConfigError( |
| "executor.command is missing; set a production executor explicitly " |
| "(SBH_PRODUCTION_EXECUTOR may provide one)" |
| ) |
| configured = shlex.split(env_command) |
| if isinstance(configured, str): |
| configured = shlex.split(configured) |
| if not isinstance(configured, list) or not configured or not all( |
| isinstance(item, str) and item.strip() for item in configured |
| ): |
| raise RunConfigError("executor.command must be a non-empty string/list command") |
| return [_expand(item) for item in configured] |
|
|
|
|
| def _validate( |
| repo_root: Path, |
| config_path: Path, |
| document: dict[str, Any], |
| required_models: tuple[str, ...] = (), |
| required_count: int | None = None, |
| ) -> dict[str, Any]: |
| if document.get("schema") != "doc2harness.run-config/1": |
| raise RunConfigError("schema must be doc2harness.run-config/1") |
| run = _mapping(document.get("run"), "run") |
| selection = _mapping(document.get("selection"), "selection") |
| executor = _mapping(document.get("executor"), "executor") |
| models_value = document.get("models") |
| if not isinstance(models_value, list) or not models_value: |
| raise RunConfigError("models must be a non-empty list") |
| catalog = _catalog_ids(repo_root) |
| requested = selection.get("mode", "all") |
| if requested == "all": |
| selected = catalog |
| elif requested == "ids_file": |
| ids_file = _repo_path(repo_root, selection.get("ids_file"), "selection.ids_file") |
| try: |
| selected = tuple( |
| line.strip() |
| for line in ids_file.read_text(encoding="utf-8").splitlines() |
| if line.strip() and not line.lstrip().startswith("#") |
| ) |
| except OSError as exc: |
| raise RunConfigError(f"cannot read selection.ids_file: {ids_file}") from exc |
| else: |
| raise RunConfigError("selection.mode must be all or ids_file") |
| if not selected or len(selected) != len(set(selected)): |
| raise RunConfigError("selection must contain unique non-empty scenario IDs") |
| if required_count is not None and len(selected) != required_count: |
| raise RunConfigError( |
| f"selection must contain exactly {required_count} scenario IDs, found {len(selected)}" |
| ) |
| unknown = sorted(set(selected) - set(catalog)) |
| if unknown: |
| raise RunConfigError(f"selection contains unknown scenario IDs: {unknown[:5]}") |
| if required_models: |
| names = tuple(_nonempty_string(_mapping(item, "model").get("id"), "model.id") for item in models_value) |
| if names != required_models: |
| raise RunConfigError(f"models must be exactly {list(required_models)}, found {list(names)}") |
| command = _command(executor, allow_missing=bool(document.get("_dry_run"))) |
| output_dir = _repo_path(repo_root, run.get("output_dir", "run-results"), "run.output_dir") |
| if not output_dir.is_relative_to(repo_root): |
| raise RunConfigError("run.output_dir must remain inside the repository") |
| concurrency = run.get("concurrency", 1) |
| if type(concurrency) is not int or concurrency < 1: |
| raise RunConfigError("run.concurrency must be a positive integer") |
| return { |
| "repo_root": str(repo_root), |
| "config_path": str(config_path), |
| "run": run, |
| "selection": {"mode": requested, "count": len(selected), "ids": selected}, |
| "models": models_value, |
| "executor": {"command": command, "output_dir": str(output_dir)}, |
| } |
|
|
|
|
| def _execute(plan: dict[str, Any], *, dry_run: bool) -> int: |
| output_dir = Path(plan["executor"]["output_dir"]) |
| output_dir.mkdir(parents=True, exist_ok=True) |
| manifest = output_dir / "run-plan.json" |
| manifest.write_text(json.dumps(plan, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") |
| selection_file = output_dir / "selected-scenarios.txt" |
| selection_file.write_text( |
| "".join(f"{scenario_id}\n" for scenario_id in plan["selection"]["ids"]), |
| encoding="utf-8", |
| ) |
| if dry_run: |
| print(json.dumps({"status": "VALID", "selection_count": plan["selection"]["count"], "models": [item["id"] for item in plan["models"]]}, ensure_ascii=False)) |
| return 0 |
| command = plan["executor"]["command"] |
| if not command: |
| raise RunConfigError( |
| "no production executor configured; set executor.command or " |
| "SBH_PRODUCTION_EXECUTOR before a real run" |
| ) |
| def run_model(model: Any) -> tuple[str, int]: |
| model_map = _mapping(model, "model") |
| model_id = _nonempty_string(model_map.get("id"), "model.id") |
| environment = os.environ.copy() |
| environment.update( |
| { |
| str(key): _expand(str(value)) |
| for key, value in _mapping(model_map.get("env", {}), "model.env").items() |
| } |
| ) |
| environment["SBH_RUN_CONFIG"] = plan["config_path"] |
| environment["SBH_MODEL_ID"] = model_id |
| environment["SBH_SCENARIO_COUNT"] = str(plan["selection"]["count"]) |
| environment["SBH_IDS_FILE"] = str(selection_file) |
| environment["SBH_RUN_OUTPUT_DIR"] = plan["executor"]["output_dir"] |
| environment["SBH_CATALOG_CONCURRENCY"] = str( |
| plan["run"].get("catalog_concurrency", 1) |
| ) |
| environment["SBH_CATALOG_TIMEOUT"] = str( |
| plan["run"].get("catalog_timeout", 900) |
| ) |
| print( |
| f"[doc2harness] starting model={model_id} " |
| f"scenarios={plan['selection']['count']}", |
| flush=True, |
| ) |
| result = subprocess.run(command, cwd=Path(plan["repo_root"]), env=environment, check=False) |
| return model_id, result.returncode |
|
|
| concurrency = min(int(plan["run"].get("concurrency", 1)), len(plan["models"])) |
| with ThreadPoolExecutor(max_workers=concurrency) as pool: |
| futures = [pool.submit(run_model, model) for model in plan["models"]] |
| for future in as_completed(futures): |
| model_id, returncode = future.result() |
| if returncode != 0: |
| print( |
| f"[doc2harness] executor failed model={model_id} rc={returncode}", |
| file=sys.stderr, |
| ) |
| return returncode |
| print(json.dumps({"status": "COMPLETED", "selection_count": plan["selection"]["count"], "models": [item["id"] for item in plan["models"]]}, ensure_ascii=False)) |
| return 0 |
|
|
|
|
| def main() -> int: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--repo-root", type=Path, required=True) |
| parser.add_argument("--config", type=Path, required=True) |
| parser.add_argument("--dry-run", action="store_true") |
| parser.add_argument("--require-models", default="") |
| parser.add_argument("--require-count", type=int) |
| args = parser.parse_args() |
| try: |
| repo_root = args.repo_root.resolve() |
| config_path = args.config.resolve() |
| sys.path.insert(0, str(repo_root / "src")) |
| document = _load_yaml(config_path) |
| document["_dry_run"] = args.dry_run |
| plan = _validate( |
| repo_root, |
| config_path, |
| document, |
| tuple(item for item in args.require_models.split(",") if item), |
| args.require_count, |
| ) |
| return _execute(plan, dry_run=args.dry_run) |
| except (OSError, RunConfigError, ImportError) as exc: |
| print(f"error[SBH-RUN-CONFIG]: {exc}", file=sys.stderr) |
| return 4 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
