""" DataClaw — Host-side benchmark orchestrator. Runs each task in an isolated Docker container. The host manages container lifecycle, workspace injection, agent execution, LLM-judge grading, and result collection. Usage: python dataclaw/eval/run_batch.py --model openrouter/anthropic/claude-sonnet-4.6 python dataclaw/eval/run_batch.py --model ... --suite task_001,task_002 python dataclaw/eval/run_batch.py --model ... --parallel 4 python dataclaw/eval/run_batch.py --task tasks/task_001_xxx.md """ from __future__ import annotations import argparse import json import logging import os import re import subprocess import sys import tempfile import threading import time import uuid from concurrent.futures import ThreadPoolExecutor, as_completed from datetime import datetime from pathlib import Path from typing import Any, Dict, List, Optional try: from dotenv import load_dotenv load_dotenv() except ImportError: pass # Allow imports from project root sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "..")) from dataclaw.lib_tasks import Task, TaskLoader from dataclaw.utils.docker_utils import ( JUDGE_CUSTOM_API_KEY, JUDGE_CUSTOM_BASE_URL, JUDGE_CUSTOM_MODEL_ID, close_proc_log, collect_output, collect_transcript, detect_transcript_errors, extract_usage_from_jsonl, onboard_openclaw, register_custom_provider, remove_container, set_model, setup_workspace, start_container, start_gateway, ) from dataclaw.utils.grading import GradeResult, grade_task, _run_judge_in_container from dataclaw.utils.process_grading import ( parse_trajectory, compute_efficiency, build_gpr_judge_prompt, parse_gpr_judge_response, compute_tgpr, ) logging.basicConfig( level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s", datefmt="%H:%M:%S", ) logger = logging.getLogger(__name__) # --------------------------------------------------------------------------- # Configuration from environment # --------------------------------------------------------------------------- ROOT_DIR = Path(__file__).resolve().parent.parent.parent TASKS_DIR = ROOT_DIR / os.environ.get("TASKS_SUBDIR", "tasks") ASSETS_DIR = ROOT_DIR / "assets" OUTPUT_DIR = ROOT_DIR / os.environ.get("OUTPUT_SUBDIR", "output") DEFAULT_MODEL = os.environ.get("DEFAULT_MODEL", "") DEFAULT_PARALLEL = int(os.environ.get("DEFAULT_PARALLEL", "1")) DEFAULT_JUDGE_MODEL = os.environ.get("JUDGE_MODEL", "openrouter/anthropic/claude-opus-4.5") TIMEOUT_MULTIPLIER = float(os.environ.get("BENCHMARK_TIMEOUT_MULTIPLIER", "1.0")) BENCHMARK_RUNS = int(os.environ.get("BENCHMARK_RUNS", "1")) TMP_WORKSPACE = os.environ.get("TMP_WORKSPACE", "/tmp_workspace") OPENROUTER_API_KEY = os.environ.get("OPENROUTER_API_KEY", "") # --------------------------------------------------------------------------- # Helpers # --------------------------------------------------------------------------- def _slugify_model(model_id: str) -> str: return re.sub(r"[^a-zA-Z0-9.\-_]", "_", model_id.rsplit("/", 1)[-1]) def _get_git_version() -> str: try: r = subprocess.run( ["git", "rev-parse", "--short", "HEAD"], capture_output=True, text=True, encoding="utf-8", timeout=2, check=False, cwd=ROOT_DIR, ) return r.stdout.strip() if r.returncode == 0 else "" except (subprocess.SubprocessError, FileNotFoundError, OSError): return "" def _validate_openrouter_model(model_id: str) -> bool: """Basic check that the model exists on OpenRouter (skippable).""" if os.environ.get("DATACLAW_SKIP_OPENROUTER_MODEL_VALIDATION", "").strip().lower() in ( "1", "true", "yes", ): return True if os.environ.get("OPENCLAW_CUSTOM_BASE_URL", "").strip(): return True bare = model_id if bare.startswith("openrouter/"): bare = bare[len("openrouter/"):] if bare.startswith("bailian/") or "/" not in bare: return True if not OPENROUTER_API_KEY: logger.warning("OPENROUTER_API_KEY not set, skipping model validation") return True from urllib import error, request as urlreq encoded = bare.replace("/", "%2F") url = f"https://openrouter.ai/api/v1/models/{encoded}" req = urlreq.Request(url, headers={ "Authorization": f"Bearer {OPENROUTER_API_KEY}", "HTTP-Referer": "https://github.com/GTMLLab/DataClaw", "X-Title": "DataClaw", }, method="GET") try: with urlreq.urlopen(req, timeout=10): return True except error.HTTPError as exc: if exc.code == 404: logger.error("Model '%s' not found on OpenRouter", bare) return False return True except (error.URLError, OSError): return True # --------------------------------------------------------------------------- # Progress file helpers (for --resume support) # --------------------------------------------------------------------------- _progress_lock = threading.Lock() def _progress_path(model_slug: str) -> Path: return OUTPUT_DIR / f"progress_{model_slug}.json" def _load_progress(path: Path) -> Optional[Dict[str, Any]]: """Load progress file, returning the parsed dict or None.""" if not path.exists(): return None try: return json.loads(path.read_text(encoding="utf-8")) except (json.JSONDecodeError, OSError) as exc: logger.warning("Failed to read progress file %s: %s", path, exc) return None def _save_progress( path: Path, model: str, suite: str, runs: int, completed: List[Dict[str, Any]], ) -> None: """Atomically write progress file (temp file + os.replace).""" data = { "model": model, "suite": suite, "runs": runs, "completed": completed, } path.parent.mkdir(parents=True, exist_ok=True) tmp_path = path.with_suffix(".tmp") tmp_path.write_text( json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8" ) os.replace(str(tmp_path), str(path)) # --------------------------------------------------------------------------- # Process grading helpers # --------------------------------------------------------------------------- PROCESS_JUDGE_TIMEOUT_SECONDS = 180 def _load_gold_process_data(task: Task) -> Optional[Dict[str, Any]]: """Load gold process fields (steps, milestone, steps_num) from qa_gold.""" gold_file = task.frontmatter.get("gold_file", "") if not gold_file: return None gold_path = ASSETS_DIR / gold_file if not gold_path.exists(): logger.warning("Gold file not found: %s", gold_path) return None try: data = json.loads(gold_path.read_text(encoding="utf-8")) except (json.JSONDecodeError, OSError) as exc: logger.warning("Failed to read gold file %s: %s", gold_path, exc) return None if not data.get("milestone") or not data.get("steps"): return None return data GPR_MAX_ATTEMPTS = 5 def _extract_assistant_text(transcript_path: Path) -> str: """Concatenate all assistant text content from a transcript JSONL. Returns empty string on missing file or read error (callers treat empty result as an L2 failure). """ if not transcript_path.exists(): return "" try: text = transcript_path.read_text(encoding="utf-8", errors="replace") except OSError: return "" out = "" for line in text.splitlines(): line = line.strip() if not line: continue try: entry = json.loads(line) except json.JSONDecodeError: continue if entry.get("type") != "message": continue msg = entry.get("message", {}) if msg.get("role") != "assistant": continue for item in msg.get("content", []) or []: if isinstance(item, dict) and item.get("type") == "text": out += item.get("text", "") or "" return out def _run_process_grading( *, container_id: str, task_id: str, transcript_path: Path, gold_data: Dict[str, Any], outcome_score: float, output_dir: Path, ) -> Dict[str, Any]: """Run process grading conditional on outcome score. Full-score tasks (score >= 1.0) get only Efficiency. Incorrect tasks (score < 1.0) get only GPR (via LLM Judge, with GPR_MAX_ATTEMPTS retries across three layers: runtime / transcript / parse), TGPR and TPE. Raises RuntimeError if the GPR judge fails every attempt. """ milestones = gold_data.get("milestone", {}) gold_steps = gold_data.get("steps", []) steps_num = gold_data.get("steps_num", len(gold_steps)) if outcome_score >= 1.0: # --- Full score: Efficiency only --- steps = parse_trajectory(transcript_path) eff = compute_efficiency(steps, steps_num) process_scores: Dict[str, Any] = {"efficiency": eff.to_dict()} (output_dir / "process_score.json").write_text( json.dumps(process_scores, indent=2, ensure_ascii=False), encoding="utf-8" ) logger.info( "[%s] Process: efficiency=%.2f (full score, GPR/TGPR/TPE skipped)", task_id, eff.efficiency if eff.efficiency is not None else 0.0, ) return process_scores # --- Incorrect: GPR + TGPR + TPE only --- steps = parse_trajectory(transcript_path) gpr_prompt = build_gpr_judge_prompt( steps=steps, milestones=milestones, gold_steps=gold_steps, final_answer_correct=False, ) gpr_result = None last_err: Optional[str] = None for attempt in range(1, GPR_MAX_ATTEMPTS + 1): # Clear previous judge sessions before each attempt subprocess.run( ["docker", "exec", container_id, "/bin/bash", "-c", "rm -rf /root/.openclaw/agents/judge/sessions/*"], capture_output=True, text=True, encoding="utf-8", ) # L1: runtime try: _run_judge_in_container(container_id, gpr_prompt) except RuntimeError as exc: last_err = f"runtime: {exc}" logger.warning("[%s] GPR attempt %d/%d failed — %s", task_id, attempt, GPR_MAX_ATTEMPTS, last_err) continue gpr_transcript = collect_transcript( container_id, output_dir, agent_id="judge", output_filename="judge_process_chat.jsonl", ) # L2: transcript validity if not gpr_transcript.exists(): last_err = "transcript: file missing" logger.warning("[%s] GPR attempt %d/%d failed — %s", task_id, attempt, GPR_MAX_ATTEMPTS, last_err) continue tr_err = detect_transcript_errors(gpr_transcript) if tr_err: last_err = f"transcript: {tr_err}" logger.warning("[%s] GPR attempt %d/%d failed — %s", task_id, attempt, GPR_MAX_ATTEMPTS, last_err) continue gpr_raw_text = _extract_assistant_text(gpr_transcript) if not gpr_raw_text.strip(): last_err = "transcript: empty assistant response" logger.warning("[%s] GPR attempt %d/%d failed — %s", task_id, attempt, GPR_MAX_ATTEMPTS, last_err) continue # L3: format — parse_gpr_judge_response falls back to a sentinel # GPRResult when required fields are missing; detect it explicitly. try: parsed_gpr = parse_gpr_judge_response(gpr_raw_text, milestones) except Exception as exc: last_err = f"format: parse failed: {exc}" logger.warning("[%s] GPR attempt %d/%d failed — %s", task_id, attempt, GPR_MAX_ATTEMPTS, last_err) continue if "could not be parsed" in (parsed_gpr.chain_summary or ""): last_err = "format: judge response missing required fields (milestones)" logger.warning("[%s] GPR attempt %d/%d failed — %s", task_id, attempt, GPR_MAX_ATTEMPTS, last_err) continue gpr_result = parsed_gpr logger.info("[%s] GPR judge succeeded on attempt %d", task_id, attempt) break if gpr_result is None: raise RuntimeError( f"GPR judge failed after {GPR_MAX_ATTEMPTS} attempts: {last_err}" ) tgpr_result = compute_tgpr(gpr_result, s_gold=steps_num) process_scores = { "gpr": gpr_result.to_dict(), "tgpr": tgpr_result.to_dict(), } (output_dir / "process_score.json").write_text( json.dumps(process_scores, indent=2, ensure_ascii=False), encoding="utf-8" ) logger.info( "[%s] Process: GPR=%.2f, TGPR=%.2f, TPE=%.2f (incorrect, efficiency skipped)", task_id, gpr_result.gpr, tgpr_result.tgpr, tgpr_result.tpe, ) return process_scores # --------------------------------------------------------------------------- # Single-task execution # --------------------------------------------------------------------------- def run_single_task( task: Task, model: str, judge_model: str, timeout_multiplier: float, ) -> Dict[str, Any]: """Execute a single task in an isolated container. Thread-safe.""" timestamp = datetime.now().strftime("%Y%m%d_%H%M") run_id = uuid.uuid4().hex[:6] short_model = _slugify_model(model) suffix = f"{short_model}_{timestamp}_{run_id}" container_id = f"{task.task_id}_{suffix}" # Truncate container name to Docker's 128-char limit if len(container_id) > 128: container_id = container_id[:128] output_dir = OUTPUT_DIR / task.task_id / suffix output_dir.mkdir(parents=True, exist_ok=True) result: Dict[str, Any] = { "task_id": task.task_id, "model": model, "scores": {}, "grade": None, "process_grade": None, "usage": {}, "error": None, "elapsed_time": 0.0, } errors: List[str] = [] gateway_proc = None agent_proc = None timeout_seconds = task.timeout_seconds * timeout_multiplier start_time = time.perf_counter() try: # 1. Start container start_container(container_id) # 2. Inject workspace files if task.workspace_files: setup_workspace(container_id, task.workspace_files, ASSETS_DIR) # 3. Onboard OpenClaw onboard_openclaw(container_id) # 3.5 Register judge provider if using a separate endpoint if JUDGE_CUSTOM_BASE_URL and JUDGE_CUSTOM_API_KEY: register_custom_provider( container_id, JUDGE_CUSTOM_BASE_URL, JUDGE_CUSTOM_API_KEY, JUDGE_CUSTOM_MODEL_ID or judge_model, ) # 4. Start gateway gateway_proc = start_gateway(container_id, output_dir / "gateway.log") # 5. Set model set_model(container_id, model) # 6. Run agent — use docker cp to bypass Windows cmd-line limit fd, tmp_path = tempfile.mkstemp(suffix=".txt") with os.fdopen(fd, "w", encoding="utf-8") as f: f.write(task.prompt) subprocess.run( ["docker", "cp", tmp_path, f"{container_id}:/tmp/agent_prompt.txt"], capture_output=True, text=True, encoding="utf-8", ) os.unlink(tmp_path) agent_bash = ( f"prompt=$(cat /tmp/agent_prompt.txt) && " f"cd {TMP_WORKSPACE} && " f"openclaw agent --session-id chat " f"--timeout {int(timeout_seconds)} --message \"$prompt\"" ) log_file = (output_dir / "agent.log").open("w", encoding="utf-8") agent_proc = subprocess.Popen( ["docker", "exec", container_id, "/bin/bash", "-c", agent_bash], stdout=log_file, stderr=subprocess.STDOUT, encoding="utf-8", ) agent_proc._log_file = log_file # type: ignore[attr-defined] logger.info("[%s] Agent running (timeout=%ds)", container_id, int(timeout_seconds)) try: agent_proc.wait(timeout=timeout_seconds) elapsed = time.perf_counter() - start_time logger.info("[%s] Agent finished (%.1fs, exit=%s)", container_id, elapsed, agent_proc.returncode) except subprocess.TimeoutExpired: elapsed = timeout_seconds logger.info("[%s] Agent timed out", container_id) agent_proc.kill() agent_proc.wait() # 7. Collect transcript and compute usage transcript_path = collect_transcript(container_id, output_dir) usage = extract_usage_from_jsonl(transcript_path) usage["elapsed_time"] = round(time.perf_counter() - start_time, 2) result["usage"] = usage (output_dir / "usage.json").write_text( json.dumps(usage, indent=2, ensure_ascii=False), encoding="utf-8" ) # 7.5 Check for API errors in transcript BEFORE grading transcript_err = detect_transcript_errors(transcript_path) if transcript_err: logger.warning("[%s] %s — skipping judge", container_id, transcript_err) errors.append(transcript_err) else: # 8. LLM Judge grading grade = None try: grade = grade_task( container_id=container_id, task_id=task.task_id, task_prompt=task.prompt, expected_behavior=task.expected_behavior, grading_criteria=task.grading_criteria, llm_judge_rubric=task.llm_judge_rubric, agent_transcript_path=transcript_path, output_dir=output_dir, judge_model=judge_model, ) result["grade"] = grade.to_dict() result["scores"] = grade.breakdown score_path = output_dir / "score.json" score_path.write_text( json.dumps(grade.to_dict(), indent=2, ensure_ascii=False), encoding="utf-8" ) logger.info("[%s] Grade: %.2f/%.2f", container_id, grade.score, grade.max_score) except Exception as exc: logger.error("[%s] Grading failed: %s", container_id, exc) errors.append(f"Grading failed: {exc}") # 8.5 Process grading — only if step 8 succeeded if not errors: try: gold_data = _load_gold_process_data(task) if gold_data is not None: outcome_score = grade.score if grade else 0.0 process_scores = _run_process_grading( container_id=container_id, task_id=task.task_id, transcript_path=transcript_path, gold_data=gold_data, outcome_score=outcome_score, output_dir=output_dir, ) result["process_grade"] = process_scores else: logger.info("[%s] No process annotations, skipping process grading", container_id) except Exception as exc: logger.error("[%s] Process grading failed: %s", container_id, exc) errors.append(f"Process grading failed: {exc}") # 9. Collect task output (always attempt — preserve artifacts for debugging) try: collect_output(container_id, output_dir) except Exception as exc: logger.warning("[%s] Output collection failed: %s", container_id, exc) errors.append(f"Output collection failed: {exc}") except Exception as exc: logger.error("[%s] Execution error: %s", container_id, exc) errors.append(f"Execution error: {exc}") finally: result["elapsed_time"] = round(time.perf_counter() - start_time, 2) if errors: result["error"] = "; ".join(errors) if gateway_proc is not None: try: gateway_proc.terminate() except Exception: pass for proc in [gateway_proc, agent_proc]: if proc is not None: try: close_proc_log(proc) except Exception: pass remove_container(container_id) logger.info("[%s] Container cleaned up", container_id) return result # --------------------------------------------------------------------------- # Summary & reporting # --------------------------------------------------------------------------- def _print_summary(results: List[Dict[str, Any]], model_name: str) -> None: print(f"\n{'#' * 60}") print(f" Summary Report — {model_name}") print(f"{'#' * 60}") scored = 0 total_score = 0.0 for r in results: grade = r.get("grade") if r.get("error") or not grade: print(f" X {r['task_id']}: {r.get('error', 'no grade')}") continue scored += 1 total_score += grade.get("score", 0.0) pct = grade["score"] / grade["max_score"] * 100 if grade["max_score"] > 0 else 0 print(f" + {r['task_id']}: {grade['score']:.2f}/{grade['max_score']:.2f} ({pct:.0f}%)") error_count = sum(1 for r in results if r.get("error")) if scored: avg = total_score / scored print(f"\n Scored: {scored}/{len(results)} Average: {avg:.4f}") if error_count: print(f" Errors: {error_count} task(s) skipped due to API errors") else: print("\n No tasks scored successfully") if error_count: print(f" Errors: {error_count} task(s) skipped due to API errors") valid = [r for r in results if not r.get("error")] total_out_tok = sum(r.get("usage", {}).get("output_tokens", 0) or 0 for r in valid) total_cost = sum(r.get("usage", {}).get("cost_usd", 0.0) or 0.0 for r in valid) print(f" Total output tokens: {total_out_tok} Total cost: ${total_cost:.4f}") # Process metrics summary — exclude error tasks proc = [ r["process_grade"] for r in results if r.get("process_grade") and not r.get("error") ] if proc: eff_vals = [p["efficiency"]["efficiency"] for p in proc if p.get("efficiency", {}).get("efficiency") is not None] gpr_vals = [p["gpr"]["gpr"] for p in proc if "gpr" in p] tgpr_vals = [p["tgpr"]["tgpr"] for p in proc if "tgpr" in p] # TPE is added to the same TGPRResult dict; older runs may lack the key. tpe_vals = [p["tgpr"]["tpe"] for p in proc if "tgpr" in p and "tpe" in p["tgpr"]] print(f"\n Process metrics ({len(proc)} tasks):") if eff_vals: print(f" Avg Efficiency: {sum(eff_vals)/len(eff_vals):.4f}") if gpr_vals: print(f" Avg GPR: {sum(gpr_vals)/len(gpr_vals):.4f}") if tgpr_vals: print(f" Avg TGPR: {sum(tgpr_vals)/len(tgpr_vals):.4f}") if tpe_vals: print(f" Avg TPE: {sum(tpe_vals)/len(tpe_vals):.4f}") print("#" * 60) # Errored tasks — listed together for easy review errored = [r for r in results if r.get("error")] if errored: print(f"\n{'#' * 60}") print(f" Errored Tasks ({len(errored)})") print(f"{'#' * 60}") for r in errored: print(f" X {r['task_id']}: {r.get('error')}") print() print(" -> Run with --resume to retry these tasks") print("#" * 60) def _write_global_summary( results: List[Dict[str, Any]], model: str, model_slug: str, suite: str, runs_per_task: int, task_objects: Optional[List[Task]] = None, ) -> Path: task_meta_map: Dict[str, Dict[str, Any]] = {} if task_objects: for t in task_objects: task_meta_map[t.task_id] = t.frontmatter aggregate: Dict[str, Any] = { "model": model, "benchmark_version": _get_git_version(), "timestamp": time.time(), "suite": suite, "runs_per_task": runs_per_task, "tasks": [], } agg_total_tokens = 0 agg_total_cost = 0.0 agg_total_requests = 0 for r in results: grade = r.get("grade") usage = r.get("usage", {}) score = grade.get("score", 0.0) if grade else 0.0 elapsed = r.get("elapsed_time", 0.0) # Only count tokens/cost/requests from non-error tasks if not r.get("error"): agg_total_tokens += usage.get("total_tokens", 0) or 0 agg_total_cost += usage.get("cost_usd", 0.0) or 0.0 agg_total_requests += usage.get("request_count", 0) or 0 entry: Dict[str, Any] = { "task_id": r["task_id"], "frontmatter": task_meta_map.get(r["task_id"], {}), "grade": grade, "process_grade": r.get("process_grade"), "grading": {"mean": score}, "usage": usage, "error": r.get("error"), "elapsed_time": elapsed, "execution_time": elapsed, } aggregate["tasks"].append(entry) # Compute global score — exclude error tasks valid_results = [r for r in results if not r.get("error")] error_count = sum(1 for r in results if r.get("error")) grades = [r["grade"] for r in valid_results if r.get("grade")] if grades: total_score = sum(g["score"] for g in grades) max_score = sum(g["max_score"] for g in grades) overall = round(total_score / max_score, 4) if max_score > 0 else 0.0 aggregate["overall_score"] = overall aggregate["total_score"] = total_score aggregate["max_score"] = max_score else: overall = 0.0 aggregate["overall_score"] = 0 aggregate["error_count"] = error_count aggregate["evaluated_count"] = len(results) - error_count aggregate["efficiency"] = { "total_tokens": agg_total_tokens, "total_cost_usd": round(agg_total_cost, 6), "total_requests": agg_total_requests, } # Aggregate process metrics — exclude error tasks process_results = [ r["process_grade"] for r in results if r.get("process_grade") is not None and not r.get("error") ] if process_results: eff_values = [ p["efficiency"]["efficiency"] for p in process_results if p.get("efficiency", {}).get("efficiency") is not None ] gpr_values = [p["gpr"]["gpr"] for p in process_results if "gpr" in p] tgpr_values = [p["tgpr"]["tgpr"] for p in process_results if "tgpr" in p] aggregate["process_metrics"] = { "tasks_with_process": len(process_results), "avg_efficiency": round(sum(eff_values) / len(eff_values), 4) if eff_values else None, "avg_gpr": round(sum(gpr_values) / len(gpr_values), 4) if gpr_values else None, "avg_tgpr": round(sum(tgpr_values) / len(tgpr_values), 4) if tgpr_values else None, } summary_path = OUTPUT_DIR / f"summary_{model_slug}.json" OUTPUT_DIR.mkdir(parents=True, exist_ok=True) summary_path.write_text( json.dumps(aggregate, indent=2, ensure_ascii=False), encoding="utf-8" ) return summary_path # --------------------------------------------------------------------------- # CLI & main # --------------------------------------------------------------------------- def main() -> None: parser = argparse.ArgumentParser( description="DataClaw — per-task container benchmark orchestrator", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=""" Examples: # Run all tasks python dataclaw/eval/run_batch.py --model openrouter/anthropic/claude-sonnet-4.6 # Run specific tasks python dataclaw/eval/run_batch.py --model ... --suite task_001,task_002 # Run with parallelism python dataclaw/eval/run_batch.py --model ... --parallel 4 # Run a single task file python dataclaw/eval/run_batch.py --task tasks/task_001_xxx.md # Resume an interrupted run python dataclaw/eval/run_batch.py --model ... --suite all --resume """, ) mode = parser.add_mutually_exclusive_group() mode.add_argument("--task", "-t", help="Path to a single task.md file") mode.add_argument( "--suite", "-s", default="all", help='Tasks to run: "all" or comma-separated task IDs (default: all)', ) parser.add_argument( "--model", "-m", default=DEFAULT_MODEL, help=f"Model identifier (default: {DEFAULT_MODEL or 'from .env'})", ) parser.add_argument( "--judge", default=DEFAULT_JUDGE_MODEL, help=f"Judge model identifier (default: {DEFAULT_JUDGE_MODEL})", ) parser.add_argument( "--parallel", "-p", type=int, default=DEFAULT_PARALLEL, metavar="N", help=f"Number of parallel containers (default: {DEFAULT_PARALLEL})", ) parser.add_argument( "--timeout-multiplier", type=float, default=TIMEOUT_MULTIPLIER, help=f"Scale all task timeouts (default: {TIMEOUT_MULTIPLIER})", ) parser.add_argument( "--runs", type=int, default=BENCHMARK_RUNS, help=f"Number of runs per task (default: {BENCHMARK_RUNS})", ) parser.add_argument( "--resume", action="store_true", help="Resume from last interrupted run (skip completed tasks)", ) parser.add_argument( "--verbose", "-v", action="store_true", help="Enable verbose logging", ) args = parser.parse_args() if not args.model: logger.error("--model is required (or set DEFAULT_MODEL in .env)") sys.exit(1) # Validate model if not _validate_openrouter_model(args.model): sys.exit(1) logger.info("DataClaw — per-task container benchmark") logger.info("Model: %s | Judge: %s | Parallel: %d", args.model, args.judge, args.parallel) # Load tasks if args.task: task_file = Path(args.task) if not task_file.exists(): logger.error("File not found: %s", task_file) sys.exit(1) loader = TaskLoader(task_file.parent) task = loader.load_task(task_file) tasks = [task] suite_label = task.task_id else: if not TASKS_DIR.exists(): logger.error("Tasks directory not found: %s", TASKS_DIR) sys.exit(1) loader = TaskLoader(TASKS_DIR) all_tasks = loader.load_all_tasks() if args.suite == "all": tasks = all_tasks suite_label = "all" else: requested = {tid.strip() for tid in args.suite.split(",") if tid.strip()} known = {t.task_id for t in all_tasks} unknown = requested - known if unknown: logger.error("Unknown task IDs: %s", ", ".join(sorted(unknown))) sys.exit(1) tasks = [t for t in all_tasks if t.task_id in requested] suite_label = args.suite if not tasks: logger.error("No tasks to run") sys.exit(1) logger.info("Tasks: %d | Runs per task: %d", len(tasks), args.runs) # Execute all_results: List[Dict[str, Any]] = [] model_slug = _slugify_model(args.model) prog_path = _progress_path(model_slug) # --resume: load previous progress and validate parameters completed_keys: set = set() progress_entries: List[Dict[str, Any]] = [] if args.resume: prog_data = _load_progress(prog_path) if prog_data is not None: mismatches = [] if prog_data.get("model") != args.model: mismatches.append( f"model (progress={prog_data.get('model')}, current={args.model})" ) if prog_data.get("suite") != suite_label: mismatches.append( f"suite (progress={prog_data.get('suite')}, current={suite_label})" ) if prog_data.get("runs") != args.runs: mismatches.append( f"runs (progress={prog_data.get('runs')}, current={args.runs})" ) if mismatches: logger.error( "Resume failed: parameter mismatch — %s. " "Use the same parameters as the original run, or remove %s to start fresh.", "; ".join(mismatches), prog_path, ) sys.exit(1) for entry in prog_data.get("completed", []): completed_keys.add((entry["task_id"], entry["run_index"])) all_results.append(entry["result"]) progress_entries.append(entry) logger.info("Resuming: %d tasks already completed", len(completed_keys)) else: logger.warning( "No progress file found for model '%s', starting from scratch", args.model, ) for run_index in range(args.runs): if args.runs > 1: logger.info("=== Run %d/%d ===", run_index + 1, args.runs) pending_tasks = [ t for t in tasks if (t.task_id, run_index) not in completed_keys ] if not pending_tasks: logger.info("All tasks in run %d already completed, skipping", run_index + 1) continue if completed_keys: skipped = len(tasks) - len(pending_tasks) if skipped: logger.info( "Skipping %d completed task(s), running %d remaining", skipped, len(pending_tasks), ) if args.parallel <= 1: for i, task in enumerate(pending_tasks, 1): logger.info("--- Task %d/%d: %s ---", i, len(pending_tasks), task.task_id) result = run_single_task( task, args.model, args.judge, args.timeout_multiplier, ) all_results.append(result) if result.get("error"): logger.warning( "[%s] Skipping progress save (error: %s) — will retry on resume", task.task_id, result["error"], ) else: with _progress_lock: progress_entries.append({ "task_id": task.task_id, "run_index": run_index, "result": result, }) _save_progress( prog_path, args.model, suite_label, args.runs, progress_entries, ) else: with ThreadPoolExecutor(max_workers=args.parallel) as pool: futures = { pool.submit( run_single_task, task, args.model, args.judge, args.timeout_multiplier, ): (task.task_id, run_index) for task in pending_tasks } for future in as_completed(futures): tid, ridx = futures[future] try: result = future.result() except Exception as exc: logger.error("[%s] Thread exception: %s", tid, exc) result = { "task_id": tid, "model": args.model, "scores": {}, "grade": None, "process_grade": None, "usage": {}, "error": str(exc), "elapsed_time": 0.0, } all_results.append(result) if result.get("error"): logger.warning( "[%s] Skipping progress save (error: %s) — will retry on resume", tid, result["error"], ) else: with _progress_lock: progress_entries.append({ "task_id": tid, "run_index": ridx, "result": result, }) _save_progress( prog_path, args.model, suite_label, args.runs, progress_entries, ) # Summary _print_summary(all_results, args.model) summary_path = _write_global_summary( all_results, args.model, model_slug, suite_label, args.runs, task_objects=tasks, ) logger.info("Summary written to: %s", summary_path) # Clean up progress file only if all tasks succeeded (no errors). # If there are errors, keep progress so --resume can retry just the # errored tasks without re-running the ones that already succeeded. error_count = sum(1 for r in all_results if r.get("error")) if error_count == 0: try: prog_path.unlink(missing_ok=True) except OSError: pass else: logger.info( "%d task(s) had errors — progress file kept for --resume", error_count, ) if __name__ == "__main__": main()