| """Classify screen episodes into the pilot's failure categories. |
| |
| Each failed episode gets one primary category, decided in this order: |
| invalid_action the reply was not one valid JSON action (malformed JSON, escaping, schema), or an |
| over-long reply was cut while budget remained |
| budget the completion/context budget or the call cap ended the episode |
| missing_output the episode ended normally but the output file did not exist |
| bad_structure the file exists but does not parse or has the wrong keys/header/types |
| wrong_code repair tasks: the file is structurally fine but the code fails the checks |
| wrong_answer other tasks: structurally fine, wrong values |
| grader_defect the saved files pass a local regrade although the episode scored 0 |
| The output's state at the end is reported for every episode as well, whatever ended it. |
| |
| Usage: PYTHONPATH=. .venv/bin/python tools/classify.py runs/pilot-4x/records.jsonl |
| """ |
|
|
| import ast |
| import collections |
| import csv |
| import io |
| import json |
| import os |
| import random |
| import sys |
| import tempfile |
|
|
| sys.path.insert(0, ".") |
| os.environ.setdefault("TERMINAL_DESK_APP", tempfile.mkdtemp(prefix="td-cls-")) |
| from terminal_desk.families import ALL_FAMILIES, FAMILIES, instance_seed, parse_task_id |
|
|
| BUDGET = 4096 |
| MISSING = "@@MISSING@@" |
|
|
| JSON_KEYS = { |
| "ev_backorder": {"backordered"}, |
| "tx_events": {"counts", "errors", "skipped"}, |
| "plan_load": {"items", "total_value", "total_weight_kg"}, |
| } |
| CSV_HEADERS = { |
| "ev_calibration": ["sample_id", "instrument_id", "run_date"], |
| "cmp_channels": ["channel", "total_hours", "weighted_minutes"], |
| "cmp_rainfall": ["station", "total_mm", "wet_days", "mean_mm_per_wet_day"], |
| "plan_shifts": ["shift_id", "staff"], |
| } |
|
|
|
|
| def structure_ok(family: str, text: str, path: str = "") -> bool: |
| if family not in CSV_HEADERS and family not in JSON_KEYS and family not in ("fix_toolkit", "tx_contacts", "fix_report"): |
| |
| try: |
| if path.endswith(".csv"): |
| from terminal_desk.families.util import parse_csv_strict |
| return parse_csv_strict(text) is not None |
| if path.endswith(".json"): |
| json.loads(text) |
| return True |
| if path.endswith(".py"): |
| ast.parse(text) |
| return True |
| except (ValueError, SyntaxError): |
| return False |
| return bool(text.strip()) |
| try: |
| if family in CSV_HEADERS: |
| header = next(csv.reader(io.StringIO(text))) |
| return [h.strip() for h in header] == CSV_HEADERS[family] |
| if family == "fix_toolkit": |
| ast.parse(text) |
| return True |
| value = json.loads(text) |
| if family in JSON_KEYS: |
| return isinstance(value, dict) and set(value) == JSON_KEYS[family] |
| if family == "tx_contacts": |
| keys = {"id", "name", "email", "tags", "active"} |
| return isinstance(value, list) and all(isinstance(v, dict) and set(v) == keys for v in value) |
| if family == "fix_report": |
| return isinstance(value, dict) and all(isinstance(v, dict) for v in value.values()) |
| except (ValueError, StopIteration, SyntaxError): |
| return False |
| return True |
|
|
|
|
| def regrade(task_id: str, snapshot: dict) -> bool: |
| fid, level, _ = parse_task_id(task_id) |
| built = ALL_FAMILIES[fid].build(level, random.Random(instance_seed(task_id))) |
| app = tempfile.mkdtemp(prefix="td-regrade-") |
| for path, text in snapshot.items(): |
| full = os.path.join(app, path) |
| os.makedirs(os.path.dirname(full), exist_ok=True) |
| with open(full, "w") as fh: |
| fh.write(text + ("" if text.endswith("\n") else "\n")) |
| try: |
| return bool(built.artifact.verify(app)) |
| except Exception: |
| return False |
|
|
|
|
| def output_state(rec: dict) -> str: |
| family = rec["task_id"].split("-L")[0] |
| snap = rec.get("snapshot") or {} |
| fid, level, _ = parse_task_id(rec["task_id"]) |
| path = ALL_FAMILIES[fid].build(level, random.Random(instance_seed(rec["task_id"]))).artifact.path |
| text = snap.get(path) |
| if text is None: |
| return "unknown" |
| if text.strip() == MISSING: |
| return "missing" |
| if not structure_ok(family, text, path): |
| return "bad_structure" |
| if rec["reward"] == 1.0: |
| return "correct" |
| return "passes_regrade" if regrade(rec["task_id"], {p: t for p, t in snap.items() if t.strip() != MISSING}) else "wrong" |
|
|
|
|
| def classify(rec: dict) -> tuple[str, str]: |
| state = output_state(rec) |
| if rec["reward"] == 1.0: |
| return "solved", state |
| ended = rec["ended"] |
| if ended in ("invalid_reply", "invalid_action"): |
| return "invalid_action", state |
| if ended == "truncated": |
| return ("budget" if rec["completion_spent"] >= BUDGET - 16 else "invalid_action"), state |
| if ended in ("budget", "context", "cap"): |
| return "budget", state |
| if state == "passes_regrade": |
| return "grader_defect", state |
| if state == "missing": |
| return "missing_output", state |
| if state == "bad_structure": |
| return "bad_structure", state |
| family = rec["task_id"].split("-L")[0] |
| return ("wrong_code" if family.startswith("fix_") else "wrong_answer"), state |
|
|
|
|
| def main() -> None: |
| recs = [json.loads(line) for line in open(sys.argv[1])] |
| per_task = collections.defaultdict(list) |
| totals = collections.Counter() |
| for r in recs: |
| cat, state = classify(r) |
| per_task[r["task_id"]].append((cat, state, r["ended"], r["steps"], r["completion_spent"])) |
| totals[cat] += 1 |
| for task, eps in per_task.items(): |
| solved = sum(c == "solved" for c, *_ in eps) |
| print(f"{task:18} {solved}/{len(eps)} " + " ".join(f"{c}[{s},{e},{n}st,{sp}t]" for c, s, e, n, sp in eps)) |
| print("\ntotals:", dict(totals)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
