| #!/bin/bash
|
| set -euo pipefail
|
|
|
| SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
|
| PROJECT_ROOT="${PROJECT_ROOT:-/root/task}"
|
| LOG_DIR="${HARBOR_LOG_DIR:-/logs/verifier}"
|
| PYTHON_BIN="${PYTHON_BIN:-python3}"
|
|
|
| mkdir -p "$LOG_DIR"
|
| export SCRIPT_DIR PROJECT_ROOT LOG_DIR
|
|
|
| "$PYTHON_BIN" -m pip install --break-system-packages --no-cache-dir pytest==8.3.5 pytest-json-report==1.5.0 PyYAML==6.0.2 >/dev/null 2>&1 || \
|
| "$PYTHON_BIN" -m pip install --no-cache-dir pytest==8.3.5 pytest-json-report==1.5.0 PyYAML==6.0.2 >/dev/null
|
|
|
| "$PYTHON_BIN" - <<'PY'
|
| from __future__ import annotations
|
|
|
| import importlib.util
|
| import json
|
| import os
|
| import shutil
|
| import subprocess
|
| import sys
|
| import tempfile
|
| from pathlib import Path
|
|
|
| SCRIPT_DIR = Path(os.environ["SCRIPT_DIR"]).resolve()
|
| PROJECT_ROOT = Path(os.environ.get("PROJECT_ROOT", "/root/task")).resolve()
|
| LOG_DIR = Path(os.environ.get("LOG_DIR", "/logs/verifier")).resolve()
|
|
|
|
|
| def _copy_test_tree(src: Path, dst: Path) -> None:
|
| shutil.copytree(src, dst)
|
| test_sh = dst / "test.sh"
|
| if test_sh.exists():
|
| test_sh.unlink()
|
|
|
|
|
| def _write_runtime_support(base: Path) -> Path:
|
| pkg = base / "verifier_lib"
|
| pkg.mkdir(parents=True, exist_ok=True)
|
| (pkg / "__init__.py").write_text("", encoding="utf-8")
|
| runtime_text = '''from __future__ import annotations
|
|
|
| import importlib.util
|
| import json
|
| import subprocess
|
| from pathlib import Path
|
|
|
|
|
| def emit_report(task_id, public, hidden, notes=None):
|
| return {
|
| "task_id": task_id,
|
| "public": public,
|
| "hidden": hidden,
|
| "notes": notes or [],
|
| }
|
|
|
|
|
| def print_report(report):
|
| print(json.dumps(report, ensure_ascii=True))
|
|
|
|
|
| def read_text(path):
|
| return Path(path).read_text(encoding="utf-8")
|
|
|
|
|
| def run_subprocess(command, cwd):
|
| return subprocess.run(command, cwd=str(cwd), capture_output=True, text=True)
|
|
|
|
|
| def load_module(name, path):
|
| spec = importlib.util.spec_from_file_location(name, path)
|
| module = importlib.util.module_from_spec(spec)
|
| assert spec and spec.loader
|
| spec.loader.exec_module(module)
|
| return module
|
|
|
|
|
| def run_checks(section, checks):
|
| results = []
|
| for name, fn in checks:
|
| try:
|
| detail = fn()
|
| passed = detail is not False
|
| error = None
|
| except AssertionError as exc:
|
| detail = None
|
| passed = False
|
| error = str(exc)
|
| except Exception as exc:
|
| detail = None
|
| passed = False
|
| error = f"{type(exc).__name__}: {exc}"
|
| results.append({
|
| "name": name,
|
| "passed": passed,
|
| "detail": detail,
|
| "error": error,
|
| })
|
| return {
|
| "section": section,
|
| "results": results,
|
| "passed": sum(1 for item in results if item["passed"]),
|
| "total": len(results),
|
| }
|
| '''
|
| (pkg / "runtime.py").write_text(runtime_text, encoding="utf-8")
|
| yaml_text = '''from __future__ import annotations
|
|
|
|
|
| def _parse_scalar(value: str):
|
| if value in {"true", "True"}:
|
| return True
|
| if value in {"false", "False"}:
|
| return False
|
| if value in {"null", "Null", "~"}:
|
| return None
|
| if value.startswith('"') and value.endswith('"'):
|
| return value[1:-1]
|
| if value.startswith("'") and value.endswith("'"):
|
| return value[1:-1]
|
| try:
|
| if any(ch in value for ch in [".", "e", "E"]):
|
| return float(value)
|
| return int(value)
|
| except ValueError:
|
| return value
|
|
|
|
|
| def safe_load(stream):
|
| text = stream.read() if hasattr(stream, "read") else str(stream)
|
| raw_lines = []
|
| for line in text.splitlines():
|
| if not line.strip() or line.lstrip().startswith("#"):
|
| continue
|
| raw_lines.append(line.rstrip())
|
|
|
| index = 0
|
|
|
| def parse_block(indent: int):
|
| nonlocal index
|
| mapping = {}
|
| sequence = []
|
| mode = None
|
| while index < len(raw_lines):
|
| line = raw_lines[index]
|
| current_indent = len(line) - len(line.lstrip(" "))
|
| if current_indent < indent:
|
| break
|
| if current_indent > indent:
|
| break
|
|
|
| stripped = line.strip()
|
| if stripped.startswith("- "):
|
| mode = mode or "list"
|
| item_text = stripped[2:].strip()
|
| index += 1
|
| if ":" in item_text:
|
| key, value = item_text.split(":", 1)
|
| item = {key.strip(): _parse_scalar(value.strip()) if value.strip() else None}
|
| if index < len(raw_lines):
|
| next_indent = len(raw_lines[index]) - len(raw_lines[index].lstrip(" "))
|
| if next_indent > current_indent:
|
| nested = parse_block(current_indent + 2)
|
| if isinstance(nested, dict):
|
| item.update(nested)
|
| sequence.append(item)
|
| elif item_text:
|
| sequence.append(_parse_scalar(item_text))
|
| else:
|
| sequence.append(parse_block(current_indent + 2))
|
| continue
|
|
|
| mode = mode or "dict"
|
| key, value = stripped.split(":", 1)
|
| key = key.strip()
|
| value = value.strip()
|
| index += 1
|
| if value:
|
| mapping[key] = _parse_scalar(value)
|
| else:
|
| mapping[key] = parse_block(current_indent + 2)
|
|
|
| return sequence if mode == "list" else mapping
|
|
|
| return parse_block(0)
|
| '''
|
| (base / "yaml.py").write_text(yaml_text, encoding="utf-8")
|
| return base
|
|
|
|
|
| def _run_pytest(target: Path, report_path: Path, cwd: Path, pytest_config: Path | None) -> int:
|
| command = [
|
| sys.executable,
|
| "-m",
|
| "pytest",
|
| str(target),
|
| "-rA",
|
| "-v",
|
| "--json-report",
|
| f"--json-report-file={report_path}",
|
| ]
|
| if pytest_config is not None:
|
| command.extend(["-c", str(pytest_config)])
|
| result = subprocess.run(command, cwd=cwd, check=False, env=os.environ.copy())
|
| return result.returncode
|
|
|
|
|
| def _load_pytest_results(path: Path) -> dict[str, bool]:
|
| data = json.loads(path.read_text(encoding="utf-8"))
|
| return {test["nodeid"]: test["outcome"] == "passed" for test in data.get("tests", [])}
|
|
|
|
|
| def _generic_pytest_score(outcome_path: Path, process_path: Path) -> dict:
|
| dimensions = []
|
| total_score = 0.0
|
| groups = [("outcome", outcome_path), ("process", process_path)]
|
| present = [(name, path) for name, path in groups if path.exists()]
|
| weight = 100.0 / len(present) if present else 100.0
|
| for name, path in present:
|
| results = _load_pytest_results(path)
|
| total = len(results)
|
| passed = sum(1 for value in results.values() if value)
|
| ratio = passed / total if total else 0.0
|
| score = weight * ratio
|
| total_score += score
|
| dimensions.append(
|
| {
|
| "name": name,
|
| "weight": round(weight, 2),
|
| "tests_matched": total,
|
| "tests_passed": passed,
|
| "scoring": "proportional",
|
| "ratio": round(ratio, 3),
|
| "score": round(score, 2),
|
| }
|
| )
|
| return {
|
| "total_score": round(total_score, 2),
|
| "max_score": 100.0,
|
| "dimensions": dimensions,
|
| }
|
|
|
|
|
| def _group_to_dimension(name: str, group: dict, weight: float) -> dict:
|
| total = int(group.get("total", 0))
|
| passed = int(group.get("passed", 0))
|
| ratio = (passed / total) if total else 0.0
|
| return {
|
| "name": name,
|
| "weight": round(weight, 2),
|
| "tests_matched": total,
|
| "tests_passed": passed,
|
| "scoring": "proportional",
|
| "ratio": round(ratio, 3),
|
| "score": round(weight * ratio, 2),
|
| }
|
|
|
|
|
| def _generic_script_score(outcome_report: dict, process_report: dict) -> dict:
|
| groups = []
|
| if outcome_report:
|
| if "public" in outcome_report:
|
| groups.append(("outcome_public", outcome_report["public"]))
|
| if "hidden" in outcome_report:
|
| groups.append(("outcome_hidden", outcome_report["hidden"]))
|
| if process_report:
|
| if "public" in process_report:
|
| groups.append(("process_public", process_report["public"]))
|
| if "hidden" in process_report:
|
| groups.append(("process_hidden", process_report["hidden"]))
|
| groups = [
|
| (name, group)
|
| for name, group in groups
|
| if isinstance(group, dict) and group.get("total", 0) > 0
|
| ]
|
| weight = 100.0 / len(groups) if groups else 100.0
|
| dimensions = []
|
| total_score = 0.0
|
| for name, group in groups:
|
| dim = _group_to_dimension(name, group, weight)
|
| total_score += dim["score"]
|
| dimensions.append(dim)
|
| return {
|
| "total_score": round(total_score, 2),
|
| "max_score": 100.0,
|
| "dimensions": dimensions,
|
| }
|
|
|
|
|
| def _all_script_groups_pass(report: dict) -> bool:
|
| relevant = [report.get("public"), report.get("hidden")]
|
| present = [
|
| group
|
| for group in relevant
|
| if isinstance(group, dict) and group.get("total", 0) > 0
|
| ]
|
| return all(group.get("passed", 0) == group.get("total", 0) for group in present)
|
|
|
|
|
| def _load_module(name: str, path: Path):
|
| spec = importlib.util.spec_from_file_location(name, path)
|
| module = importlib.util.module_from_spec(spec)
|
| assert spec and spec.loader
|
| spec.loader.exec_module(module)
|
| return module
|
|
|
|
|
| def _run_script_report(name: str, path: Path, support_root: Path) -> dict:
|
| sys.path.insert(0, str(support_root))
|
| module = _load_module(name, path)
|
| if not hasattr(module, "run"):
|
| raise RuntimeError(f"{path} does not expose run()")
|
| return module.run()
|
|
|
|
|
| def _run_score(score_script: Path, outcome_path: Path, process_path: Path) -> Path:
|
| subprocess.run(
|
| [sys.executable, str(score_script), str(outcome_path), str(process_path)],
|
| cwd=LOG_DIR,
|
| check=True,
|
| env=os.environ.copy(),
|
| )
|
| return LOG_DIR / "score_report.json"
|
|
|
|
|
| def _compute_score_fallback(score_script: Path, outcome_path: Path, process_path: Path) -> dict:
|
| module = _load_module("legacy_score_module", score_script)
|
| if hasattr(module, "compute_score"):
|
| combined_results = {
|
| **_load_pytest_results(outcome_path),
|
| **_load_pytest_results(process_path),
|
| }
|
| result = module.compute_score(combined_results)
|
| if isinstance(result, tuple) and len(result) == 2:
|
| total, dims = result
|
| return {"total_score": float(total), "max_score": 100.0, "dimensions": dims}
|
| if isinstance(result, dict):
|
| total = result.get("total_score", result.get("total", 0.0))
|
| maximum = result.get("max_score", 100.0)
|
| dims = result.get("dimensions", result.get("dims", []))
|
| return {
|
| "total_score": float(total),
|
| "max_score": float(maximum),
|
| "dimensions": dims,
|
| }
|
| outcome_data = json.loads(outcome_path.read_text(encoding="utf-8"))
|
| process_data = json.loads(process_path.read_text(encoding="utf-8"))
|
| combined_report = {
|
| "tests": outcome_data.get("tests", []) + process_data.get("tests", []),
|
| }
|
| if all(hasattr(module, attr) for attr in ("RUBRIC", "_collect", "_score_dim")):
|
| passed, failed = module._collect(combined_report)
|
| total = 0.0
|
| dimensions = []
|
| for dim in module.RUBRIC:
|
| score = float(module._score_dim(dim, passed, failed))
|
| total += score
|
| dimensions.append(
|
| {
|
| "name": getattr(dim, "name", "dimension"),
|
| "weight": float(getattr(dim, "weight", 0.0)),
|
| "score": round(score, 2),
|
| }
|
| )
|
| return {
|
| "total_score": round(total, 2),
|
| "max_score": 100.0,
|
| "dimensions": dimensions,
|
| }
|
| raise RuntimeError(f"Unsupported score result from {score_script}")
|
|
|
|
|
| def _write_reward(score_report: dict, outcome_code: int, process_code: int) -> None:
|
| total = float(score_report.get("total_score", 0.0))
|
| maximum = float(score_report.get("max_score", 100.0)) or 100.0
|
| dimensions = score_report.get("dimensions", [])
|
| if dimensions and all(
|
| dim.get("tests_matched") == dim.get("tests_passed")
|
| for dim in dimensions
|
| ):
|
| total = maximum
|
| score_report["total_score"] = maximum
|
| normalized = total / maximum
|
| payload = {
|
| "total_score": total,
|
| "max_score": maximum,
|
| "normalized_score": normalized,
|
| "outcome_passed": 1.0 if outcome_code == 0 else 0.0,
|
| "process_passed": 1.0 if process_code == 0 else 0.0,
|
| }
|
| LOG_DIR.mkdir(parents=True, exist_ok=True)
|
| (LOG_DIR / "reward.txt").write_text(f"{normalized:.6f}\n", encoding="utf-8")
|
| (LOG_DIR / "reward.json").write_text(
|
| json.dumps(payload, indent=2) + "\n", encoding="utf-8"
|
| )
|
|
|
|
|
| if not PROJECT_ROOT.exists():
|
| raise FileNotFoundError(f"project root not found: {PROJECT_ROOT}")
|
|
|
| with tempfile.TemporaryDirectory(prefix="harbor-eval-") as tmpdir:
|
| runtime_root = Path(tmpdir)
|
| runtime_task_root = runtime_root / "workspace" / "task"
|
| project_root = runtime_task_root / "project"
|
| runtime_test_root = runtime_task_root / "test"
|
| support_root = runtime_root / "support"
|
|
|
| runtime_task_root.mkdir(parents=True)
|
| shutil.copytree(PROJECT_ROOT, project_root)
|
| _copy_test_tree(SCRIPT_DIR, runtime_test_root)
|
| task_root = SCRIPT_DIR.parent
|
| instruction_path = task_root / "instruction.md"
|
| if instruction_path.exists():
|
| shutil.copy2(instruction_path, runtime_task_root / "instruction.md")
|
| _write_runtime_support(support_root)
|
| os.environ["PYTHONPATH"] = str(support_root) + os.pathsep + os.environ.get("PYTHONPATH", "")
|
| os.environ["npm_config_cache"] = str(runtime_root / "npm-cache")
|
|
|
| outcome_path = runtime_test_root / "test_outcome.py"
|
| process_path = runtime_test_root / "test_process.py"
|
| score_path = runtime_test_root / "score.py"
|
| pytest_config = runtime_test_root / "pytest.ini"
|
| pytest_config = pytest_config if pytest_config.exists() else None
|
|
|
| uses_script_runtime = False
|
| for candidate in (outcome_path, process_path):
|
| if candidate.exists() and "verifier_lib.runtime" in candidate.read_text(
|
| encoding="utf-8", errors="ignore"
|
| ):
|
| uses_script_runtime = True
|
| break
|
|
|
| if uses_script_runtime:
|
| outcome_report = (
|
| _run_script_report("harbor_outcome", outcome_path, support_root)
|
| if outcome_path.exists()
|
| else {}
|
| )
|
| process_report = (
|
| _run_script_report("harbor_process", process_path, support_root)
|
| if process_path.exists()
|
| else {}
|
| )
|
| LOG_DIR.mkdir(parents=True, exist_ok=True)
|
| (LOG_DIR / "outcome_report.json").write_text(
|
| json.dumps(outcome_report, indent=2) + "\n", encoding="utf-8"
|
| )
|
| (LOG_DIR / "process_report.json").write_text(
|
| json.dumps(process_report, indent=2) + "\n", encoding="utf-8"
|
| )
|
| outcome_code = 0 if _all_script_groups_pass(outcome_report) else 1
|
| process_code = 0 if _all_script_groups_pass(process_report) else 1
|
| score_report = _generic_script_score(outcome_report, process_report)
|
| (LOG_DIR / "score_report.json").write_text(
|
| json.dumps(score_report, indent=2) + "\n", encoding="utf-8"
|
| )
|
| _write_reward(score_report, outcome_code, process_code)
|
| raise SystemExit(0 if outcome_code == 0 and process_code == 0 else 1)
|
|
|
| outcome_json = runtime_root / "outcome.json"
|
| process_json = runtime_root / "process.json"
|
| outcome_code = _run_pytest(outcome_path, outcome_json, runtime_task_root, pytest_config)
|
| process_code = _run_pytest(process_path, process_json, runtime_task_root, pytest_config)
|
|
|
| if score_path.exists():
|
| try:
|
| score_report_path = _run_score(score_path, outcome_json, process_json)
|
| except subprocess.CalledProcessError:
|
| score_report = _compute_score_fallback(score_path, outcome_json, process_json)
|
| score_report_path = LOG_DIR / "score_report.json"
|
| score_report_path.write_text(
|
| json.dumps(score_report, indent=2) + "\n", encoding="utf-8"
|
| )
|
| if score_report_path.exists():
|
| score_report = json.loads(score_report_path.read_text(encoding="utf-8"))
|
| else:
|
| score_report = _compute_score_fallback(score_path, outcome_json, process_json)
|
| score_report_path.write_text(
|
| json.dumps(score_report, indent=2) + "\n", encoding="utf-8"
|
| )
|
| else:
|
| score_report = _generic_pytest_score(outcome_json, process_json)
|
| LOG_DIR.mkdir(parents=True, exist_ok=True)
|
| (LOG_DIR / "score_report.json").write_text(
|
| json.dumps(score_report, indent=2) + "\n", encoding="utf-8"
|
| )
|
|
|
| _write_reward(score_report, outcome_code, process_code)
|
| raise SystemExit(0 if outcome_code == 0 and process_code == 0 else 1)
|
| PY
|
|
|
| if [ ! -f "$LOG_DIR/reward.txt" ]; then
|
| echo 0 > "$LOG_DIR/reward.txt"
|
| fi
|
|
|
| exit 0
|
|
|
