| from __future__ import annotations |
|
|
| import json |
| import re |
| from dataclasses import dataclass |
| from typing import Any |
|
|
| from .sandbox import run_python_submission |
|
|
|
|
| @dataclass(frozen=True) |
| class Score: |
| passed: bool |
| value: float |
| maximum: float |
| error: str | None = None |
|
|
|
|
| def response_text(response: dict[str, Any]) -> str: |
| return str(response.get("content") or "") |
|
|
|
|
| def strict_json(text: str) -> Any: |
| stripped = text.strip() |
| if stripped.startswith("```") or not stripped: |
| raise ValueError("Expected bare JSON without Markdown fences") |
| decoder = json.JSONDecoder() |
| value, end = decoder.raw_decode(stripped) |
| if stripped[end:].strip(): |
| raise ValueError("Unexpected text after JSON value") |
| return value |
|
|
|
|
| def _normalize_tool_calls(response: dict[str, Any]) -> list[dict[str, Any]]: |
| normalized = [] |
| for call in response.get("tool_calls") or []: |
| function = call.get("function") or {} |
| arguments = function.get("arguments", {}) |
| if isinstance(arguments, str): |
| arguments = json.loads(arguments) |
| normalized.append({"name": function.get("name"), "arguments": arguments}) |
| return normalized |
|
|
|
|
| def score_response(scorer: str, expected: Any, response: dict[str, Any]) -> Score: |
| try: |
| if scorer == "exact_text": |
| actual = response_text(response).strip() |
| passed = actual == str(expected) |
| elif scorer == "strict_json_exact": |
| actual = strict_json(response_text(response)) |
| passed = actual == expected |
| elif scorer == "strict_json_subset": |
| actual = strict_json(response_text(response)) |
| if not isinstance(actual, dict) or not isinstance(expected, dict): |
| passed = False |
| else: |
| passed = all(actual.get(key) == value for key, value in expected.items()) |
| elif scorer == "tool_calls_exact": |
| actual = _normalize_tool_calls(response) |
| passed = actual == expected |
| elif scorer == "python_code": |
| text = response_text(response).strip() |
| match = re.fullmatch(r"```(?:python)?\s*(.*?)\s*```", text, re.DOTALL | re.IGNORECASE) |
| code = match.group(1) if match else text |
| outcome = run_python_submission(code, str(expected["tests"])) |
| passed = outcome["passed"] |
| return Score(passed, float(passed), 1.0, outcome.get("error")) |
| else: |
| raise ValueError(f"Unknown scorer: {scorer}") |
| return Score(passed, float(passed), 1.0, None if passed else "answer mismatch") |
| except Exception as exc: |
| return Score(False, 0.0, 1.0, f"{type(exc).__name__}: {exc}") |
|
|
|
|
