Download eval/native_harness/native_bench/runner.py from SLAI-AITP/AscendGYM: direct link, hf CLI and curl.
- Browser
- Download file 17.7 kB
-
https://huggingface.co/datasets/SLAI-AITP/AscendGYM/resolve/main/eval/native_harness/native_bench/runner.py
- Command line
-
hf download hf://datasets/SLAI-AITP/AscendGYM/eval/native_harness/native_bench/runner.py
-
curl -L -o runner.py https://huggingface.co/datasets/SLAI-AITP/AscendGYM/resolve/main/eval/native_harness/native_bench/runner.py
17.7 kB
| import json | |
| import copy | |
| import os | |
| import shlex | |
| import signal | |
| import subprocess | |
| import sys | |
| import threading | |
| import time | |
| import uuid | |
| from pathlib import Path | |
| from core.metrics import compute_metrics | |
| from .adapters import command, probe | |
| from .common import Journal, dump, sha, write_json | |
| from .config import validate_config, candidate_target | |
| from .evaluation import EvaluationGateway, read_files, source_hash | |
| from .usage import UsageLedger | |
| def kill_group(process, sig): | |
| try: | |
| os.killpg(process.pid, sig) | |
| except ProcessLookupError: | |
| pass | |
| class NativeRun: | |
| def __init__(self, config, output): | |
| validate_config(config) | |
| config = copy.deepcopy(config) | |
| config.setdefault("search", {})["candidate_solutions_target"] = candidate_target(config) | |
| self.cfg, self.root = config, Path(output).resolve() | |
| source = Path(config["input"]["source_dir"]).resolve() | |
| if self.root.exists() or self.root == source or source in self.root.parents: | |
| raise ValueError("output must be new and outside input source") | |
| candidates = sorted(source.rglob("*")) | |
| if any(p.is_symlink() for p in candidates): | |
| raise ValueError("symlinks not allowed in input bundle") | |
| names = [p.relative_to(source).as_posix() for p in candidates if p.is_file()] | |
| if not names or len(names) > 256 or any(n == ".bench" or n.startswith(".bench/") for n in names): | |
| raise ValueError("provide a curated source bundle (1..256 files, no .bench/)") | |
| self.initial = read_files(source, names) | |
| if not set(config["input"]["editable_paths"] + config["input"]["test_paths"]) <= self.initial.keys(): | |
| raise ValueError("editable/test file missing from source") | |
| spec = Path(config["input"]["spec_path"]).read_text(encoding="utf-8") | |
| if not spec.strip(): | |
| raise ValueError("operator description is empty") | |
| self.root.mkdir(parents=True) | |
| self.workspace = self.root / "workspace" | |
| for name, content in self.initial.items(): | |
| path = self.workspace / name | |
| path.parent.mkdir(parents=True, exist_ok=True) | |
| path.write_bytes(content.encode()) | |
| if name not in config["input"]["editable_paths"]: | |
| path.chmod(0o444) | |
| self.run_id = str(uuid.uuid4()) | |
| self.journal = Journal(self.root, self.run_id) | |
| self.usage = UsageLedger(config["agent"].get("event_format", config["agent"]["kind"])) | |
| self.gateway = EvaluationGateway(config, self.root, self.initial, self.journal, self.usage) | |
| self.task_dir = self.workspace / ".bench" | |
| self.task_dir.mkdir() | |
| (self.task_dir / "operator_spec.md").write_text(spec) | |
| reference = Path(__file__).resolve().parents[1] / "core/references/metrics_master.md" | |
| self.manifest = {"schema_version": "native-bench-run-v1", "run_id": self.run_id, | |
| "input": {"files": {n: sha(v.encode()) for n, v in self.initial.items()}, | |
| "source_hash": source_hash(self.initial), "spec_sha256": sha(spec.encode())}, | |
| "metrics_master_sha256": sha(reference.read_bytes()) if reference.exists() else None, | |
| "task": config["input"], "agent": config["agent"], "stop": config["stop"], | |
| "search": config["search"], "profiling": config["evaluator"].get("profiling"), | |
| "isolation": config.get("isolation", "process_only"), | |
| "security_note": "Process-only mode is cooperative, NOT an OS security boundary. Use external isolation for untrusted agents.", | |
| "evidence_kind": "synthetic" if config["agent"].get("evidence_kind") == "synthetic" else config["evaluator"]["evidence_kind"]} | |
| package = Path(__file__).resolve().parent | |
| self.manifest["harness_sources_sha256"] = {p.name: sha(p.read_bytes()) | |
| for p in sorted(package.iterdir()) if p.suffix in (".py", ".txt")} | |
| write_json(self.task_dir / "input_manifest.json", self.manifest) | |
| write_json(self.root / "config.resolved.json", config) | |
| self.process = None | |
| def _prompt(self, connection): | |
| base = [sys.executable, str(Path(__file__).with_name("client.py").resolve()), | |
| "--connection", str(connection)] | |
| values = {"op_name": self.cfg["input"].get("op_name", "operator"), "workspace": str(self.workspace), | |
| "spec_path": str(self.task_dir / "operator_spec.md"), "manifest_path": str(self.task_dir / "input_manifest.json"), | |
| "editable_paths": dump(self.cfg["input"]["editable_paths"]), "test_paths": dump(self.cfg["input"]["test_paths"]), | |
| "candidate_evaluations_max": self.cfg["stop"]["candidate_evaluations_max"], | |
| "candidate_solutions_target": candidate_target(self.cfg), | |
| "profiling_protocol": (dump(self.cfg["evaluator"]["profiling"]) | |
| if "profiling" in self.cfg["evaluator"] else "由评测器固定定义;不自行推测采样参数。"), | |
| **{kind + "_command": shlex.join(base + [kind]) for kind in ("baseline", "candidate", "status")}} | |
| prompt = Path(__file__).with_name("prompt.txt").read_text().format(**values) | |
| if self.cfg.get("task_note"): | |
| prompt += "\n任务补充:\n" + self.cfg["task_note"] + "\n" | |
| return prompt | |
| def _read_stream(self, pipe): | |
| with (self.root / "agent.stdout.jsonl").open("wb") as out: | |
| for line_number, line in enumerate(iter(pipe.readline, b""), 1): | |
| out.write(line) | |
| out.flush() | |
| if not line.strip(): | |
| continue | |
| try: | |
| record = json.loads(line) | |
| if not isinstance(record, dict): | |
| raise ValueError("native event is not an object") | |
| self.usage.consume(record) | |
| self.journal.event("native_event", raw_line=line_number, payload=record) | |
| except (ValueError, UnicodeDecodeError) as exc: | |
| self.journal.event("unparsed_stdout", raw_line=line_number, error=str(exc)) | |
| self.usage.stream_errors.append("unparsed native stdout at line " + str(line_number)) | |
| def run(self): | |
| # Preflight before starting any listener: bad CLI/flags must not leak it. | |
| agent = self.cfg["agent"] | |
| if agent["kind"] != "custom": | |
| self.manifest["agent_probe"] = probe(agent["kind"], agent.get("executable")) | |
| if not self.manifest["agent_probe"]["available"]: | |
| write_json(self.root / "manifest.json", self.manifest) | |
| raise ValueError("native CLI unavailable: " + agent["kind"]) | |
| command(agent, "", self.workspace, self.root) | |
| self.usage.reset_meter() | |
| server, server_thread = self.gateway.serve() | |
| connection = self.task_dir / "connection.json" | |
| write_json(connection, {"url": f"http://127.0.0.1:{server.server_port}", "token": self.gateway.token}) | |
| connection.chmod(0o600) | |
| prompt = self._prompt(connection) | |
| (self.root / "prompt.txt").write_text(prompt) | |
| self.manifest["prompt_sha256"] = sha(prompt.encode()) | |
| write_json(self.root / "manifest.json", self.manifest) | |
| argv, stdin = command(agent, prompt, self.workspace, self.root) | |
| write_json(self.root / "launch.json", {"argv": argv, "cwd": str(self.workspace), "stdin": stdin, | |
| "note": "Initial task only; native agent owns the loop and system prompt"}) | |
| environment = os.environ.copy() | |
| # Existing CLI auth is inherited, never copied into artifacts. | |
| # Secrets must not be supplied as argv/config values. | |
| environment["NATIVE_BENCH_CONNECTION"] = str(connection) | |
| environment["NATIVE_BENCH_RUN_ID"] = self.run_id | |
| failure, forced, native_completed = None, False, False | |
| checks, reader = [], None | |
| self.journal.event("agent_started", adapter=agent["kind"]) | |
| try: | |
| with (self.root / "agent.stderr.txt").open("wb") as stderr: | |
| self.process = subprocess.Popen(argv, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=stderr, | |
| cwd=self.workspace, env=environment, start_new_session=True) | |
| reader = threading.Thread(target=self._read_stream, args=(self.process.stdout,), daemon=True) | |
| reader.start() | |
| try: | |
| self.process.stdin.write(stdin.encode()) | |
| self.process.stdin.close() | |
| except BrokenPipeError: | |
| self.process.stdin.close() | |
| closing_since = None | |
| while self.process.poll() is None: | |
| if (self.root / "STOP").exists(): | |
| self.gateway.close_admission("manual_stop") | |
| if self.gateway.stop_ready.is_set(): | |
| if closing_since is None: | |
| closing_since = time.monotonic() | |
| self.journal.event("agent_closing", reason=self.gateway.stop_reason) | |
| # This grace starts ONLY after another stop condition, not | |
| # at run start. It permits a native final usage response. | |
| if time.monotonic() - closing_since >= self.cfg["stop"].get("shutdown_grace_seconds", 20): | |
| forced = True | |
| kill_group(self.process, signal.SIGINT) | |
| try: | |
| self.process.wait(timeout=3) | |
| except subprocess.TimeoutExpired: | |
| kill_group(self.process, signal.SIGTERM) | |
| try: | |
| self.process.wait(timeout=3) | |
| except subprocess.TimeoutExpired: | |
| kill_group(self.process, signal.SIGKILL) | |
| self.process.wait() | |
| time.sleep(.05) | |
| native_completed = self.process.returncode == 0 and not forced | |
| self.gateway.close_admission("agent_finished" if native_completed else "agent_error") | |
| # Reap remaining descendants; no background agent process is allowed | |
| # to continue optimizing after its run is declared ended. | |
| kill_group(self.process, signal.SIGTERM) | |
| reader.join(timeout=5) | |
| if reader.is_alive(): | |
| kill_group(self.process, signal.SIGKILL) | |
| reader.join(timeout=2) | |
| self.usage.stream_errors.append("native stdout remained open after process exit") | |
| self.journal.event("agent_exited", returncode=self.process.returncode, forced=forced) | |
| except KeyboardInterrupt: | |
| self.gateway.close_admission("manual_stop") | |
| forced = True | |
| if self.process is not None: | |
| kill_group(self.process, signal.SIGTERM) | |
| try: | |
| self.process.wait(timeout=5) | |
| except subprocess.TimeoutExpired: | |
| kill_group(self.process, signal.SIGKILL) | |
| self.process.wait() | |
| except Exception as exc: | |
| failure = {"type": type(exc).__name__, "message": str(exc)} | |
| self.gateway.close_admission("agent_error") | |
| if self.process is not None and self.process.poll() is None: | |
| kill_group(self.process, signal.SIGKILL) | |
| self.process.wait() | |
| finally: | |
| server.shutdown() | |
| server.server_close() # Waits for accepted evaluations; they have infrastructure timeouts. | |
| server_thread.join() | |
| if reader is not None: | |
| reader.join(timeout=2) | |
| if self.process is not None: | |
| if self.process.stdin and not self.process.stdin.closed: | |
| self.process.stdin.close() | |
| if self.process.stdout and (reader is None or not reader.is_alive()): | |
| self.process.stdout.close() | |
| if self.usage.kind == "opencode" and self.usage.session_id: | |
| self._opencode_export() | |
| usage = self.usage.report(native_completed) | |
| write_json(self.root / "usage.json", usage) | |
| self.journal.event("usage_finalized", usage=usage) | |
| if failure is None and self.gateway.stop_reason not in ("agent_error", "manual_stop", "gateway_error"): | |
| try: | |
| checks = self.gateway.final_verification(self.cfg["stop"].get("final_reprofile_count", 1)) | |
| except Exception as exc: | |
| failure = {"type": type(exc).__name__, "message": str(exc)} | |
| return self._finalize(usage, checks, failure, forced) | |
| def _opencode_export(self): | |
| agent = self.cfg["agent"] | |
| argv = [agent.get("executable", "opencode"), "export", self.usage.session_id] | |
| try: | |
| # Only a native local export command, never a new model conversation. | |
| p = subprocess.run(argv, cwd=self.workspace, capture_output=True, timeout=60) | |
| (self.root / "opencode.export.json").write_bytes(p.stdout) | |
| (self.root / "opencode.export.stderr.txt").write_bytes(p.stderr) | |
| if p.returncode: | |
| raise ValueError("native export failed") | |
| self.usage.consume_export(json.loads(p.stdout)) | |
| except (OSError, ValueError, subprocess.TimeoutExpired) as exc: | |
| self.journal.event("usage_export_unavailable", error=str(exc)) | |
| def _finalize(self, usage, checks, failure, forced): | |
| reconciled = {(c["kind"], c["as_of_ns"]): c for c in usage.get("completion_checkpoints", [])} | |
| recovered = False | |
| for row in self.gateway.rows: | |
| previous = row.get("completion_usage_checkpoint", {}) | |
| checkpoint = reconciled.get((row["evaluation_kind"], previous.get("as_of_ns"))) | |
| if checkpoint is not None: | |
| if not previous.get("available") and checkpoint["available"]: | |
| recovered = True | |
| self.journal.event("completion_usage_reconciled", evaluation_id=row["evaluation_id"], | |
| cumulative_tokens=checkpoint["cumulative_tokens"], as_of_ns=checkpoint["as_of_ns"]) | |
| row["completion_usage_checkpoint"] = {k: v for k, v in checkpoint.items() if k != "kind"} | |
| row["cumulative_tokens"] = checkpoint["cumulative_tokens"] | |
| rows = [dict(r) for r in self.gateway.rows] | |
| for r in rows: | |
| if not r.get("completion_usage_checkpoint", {}).get("available"): | |
| r["cumulative_tokens"] = None | |
| if recovered and (self.root / "evaluations.jsonl").exists(): | |
| (self.root / "evaluations.jsonl").write_text( | |
| "".join(json.dumps(row, ensure_ascii=False) + "\n" for row in rows), encoding="utf-8") | |
| write_json(self.root / "solutions.json", rows) | |
| final_count = self.cfg["stop"].get("final_reprofile_count", 1) | |
| final_valid = len(checks) == final_count and all(r["status"] == "passed" for r in checks) | |
| try: | |
| original_unchanged = read_files(self.cfg["input"]["source_dir"], self.initial) == self.initial | |
| except (OSError, ValueError): | |
| original_unchanged = False | |
| good_stop = self.gateway.stop_reason in ("agent_finished", "candidate_budget_exhausted") | |
| success = bool(good_stop and self.gateway.baseline and self.gateway.used and final_valid | |
| and failure is None and original_unchanged) | |
| context = {"operational_ok": success, "usage_complete": usage["available"] and usage["submission_checkpoints_usable"], | |
| "candidate_usage_complete": usage["submission_checkpoints_usable"], | |
| "verification_required": final_count > 0, "verification_valid": final_valid} | |
| metrics = compute_metrics(rows, self.cfg.get("metrics", {}), self.manifest["evidence_kind"], context) | |
| if not usage["submission_checkpoints_usable"]: | |
| metrics["STS_token"] = {"status": "unavailable", "reason": usage["checkpoint_limitation"]} | |
| metrics["token_accounting_note"] = "Candidate coordinates use timestamped provider receipts; unavailable session-tail totals do not invalidate proven candidate counts." | |
| metrics["official_ranking_eligible"] = False | |
| write_json(self.root / "metrics.json", metrics) | |
| result = {"schema_version": "native-bench-result-v1", "run_id": self.run_id, "success": success, | |
| "evidence_kind": self.manifest["evidence_kind"], "termination_reason": self.gateway.stop_reason, | |
| "error": failure, "agent_forced_shutdown": forced, "usage": usage, | |
| "candidate_evaluations": self.gateway.used, "profiling_count": len(rows), | |
| "baseline": self.gateway.baseline, "best_verified": self.gateway.best, | |
| "final_verification": {"requested": final_count, "valid": final_valid, "evaluations": checks}, | |
| "original_input_unchanged": original_unchanged, | |
| "elapsed_seconds": time.monotonic() - self.journal.started, | |
| "stopping_policy": "evaluation count / native completion / manual stop / fatal error; no token or run wall-clock caps", | |
| "trace_scope": "Native CLI observable events and provider usage counters, not undisclosed provider prompts or hidden reasoning"} | |
| write_json(self.root / "result.json", result) | |
| self.journal.event("run_finished", success=success, result_ref="result.json") | |
| return result | |