frontier_cs/tasks/frontier-cs-algorithm-113/tests/evaluate.py

#!/usr/bin/env python3
"""Slime Frontier-CS verifier: grade the FINAL /app/solution.cpp via the go-judge.

Writes /logs/verifier/reward.json with a RAW signal (score_raw, cases_passed,
cases_total, is_solved) + a default fractional reward; the slime head re-shapes
from the raw fields (ASYNC_RL_REWARD_SHAPE). Grading is on the final file only —
the agent's submit.sh calls are iteration feedback, not the graded artifact.
"""
import json
import os
import time
from pathlib import Path

import requests

JUDGE_URL = os.environ.get("JUDGE_URL", "")
PROBLEM_ID = os.environ.get("PROBLEM_ID", "")
SOLUTION = Path("/app/solution.cpp")
REWARD_JSON = Path("/logs/verifier/reward.json")
REWARD_TXT = Path("/logs/verifier/reward.txt")
POLL_INTERVAL = 2
MAX_POLL_TIME = int(os.environ.get("MAX_POLL_TIME", "600"))


def write(reward, *, score_raw=0.0, cases_passed=0, cases_total=0, is_solved=False, detail=""):
    REWARD_JSON.parent.mkdir(parents=True, exist_ok=True)
    REWARD_JSON.write_text(json.dumps({
        "reward": reward, "score_raw": score_raw, "cases_passed": cases_passed,
        "cases_total": cases_total, "is_solved": is_solved, "detail": detail,
    }))
    REWARD_TXT.write_text(str(reward))
    print(f"[verify] reward={reward:.4f} score_raw={score_raw} cases={cases_passed}/{cases_total} "
          f"solved={is_solved} {detail}")


def main():
    if not JUDGE_URL:
        write(0.0, detail="JUDGE_URL unset")
        return
    if not SOLUTION.exists() or not SOLUTION.read_text().strip():
        write(0.0, detail="no solution.cpp")
        return
    code = SOLUTION.read_text()

    # wait for judge readiness
    for _ in range(30):
        try:
            if requests.get(f"{JUDGE_URL}/problems", timeout=5).status_code == 200:
                break
        except Exception:
            pass
        time.sleep(2)

    try:
        r = requests.post(f"{JUDGE_URL}/submit", files={"code": ("solution.cpp", code)},
                          data={"pid": PROBLEM_ID, "lang": "cpp"}, timeout=30)
        r.raise_for_status()
        sid = r.json()["sid"]
    except Exception as e:
        write(0.0, detail=f"submit failed: {e}")
        return

    result, start = None, time.time()
    while time.time() - start < MAX_POLL_TIME:
        try:
            resp = requests.get(f"{JUDGE_URL}/result/{sid}", timeout=10)
            if resp.status_code == 200 and resp.json().get("status") in ("done", "error"):
                result = resp.json()
                break
        except Exception:
            pass
        time.sleep(POLL_INTERVAL)

    if result is None:
        write(0.0, detail="judge timed out")
        return
    if result.get("status") == "error":
        write(0.0, detail=str(result.get("message") or result.get("error") or "judge error"))
        return

    score_raw = float(result.get("score") or 0.0)  # 0..100
    cases = result.get("cases") or []
    cases_total = len(cases) if isinstance(cases, list) else 0
    cases_passed = sum(1 for c in cases if isinstance(c, dict) and (c.get("scoreRatio") or 0) >= 1.0)
    is_solved = bool(result.get("passed")) or score_raw >= 100.0 - 1e-6
    write(max(0.0, min(1.0, score_raw / 100.0)), score_raw=score_raw, cases_passed=cases_passed,
          cases_total=cases_total, is_solved=is_solved)


if __name__ == "__main__":
    main()