| |
| """Dated-break eval scorer: classify one model reply for one item. |
| |
| from score import score, load_status |
| outcome, detail = score(item, reply_text, status, runner=None) |
| |
| Reading rule: only fenced code blocks are read, except blocks tagged text/markdown/md/console/output/ |
| log/diff. A reply with no readable block is UNSCORED. Whole-line comments, whole block comments |
| (/* */, <!-- -->), end-of-line comments and Python triple-quoted strings are dropped, and so are the |
| prose string arguments of warn/log/print/echo/raise lines. PASS means a live route was chosen, not |
| that the code runs. The route the code points at is scored (endpoint, host or path family, model ID, |
| formula, image) even when the method spelling is invented; no identifiable route is UNSCORED. |
| |
| Outcomes (worst first, used for worst-of over a reply's slot values): |
| BROKEN_ALREADY_ROW stopped working on or before the eval date and the item's own calendar row says so |
| FAIL the item's own calendar row breaks it after the eval date |
| MIXED fail and pass forms both appear (never in the strict numerator; upper bound only) |
| BROKEN_ALREADY_OTHER dead before the eval date but on none of the item's rows (reported beside the headline) |
| ALIAS_SCHEDULED alias whose own end is unstated (reported beside FAIL) |
| OTHER_SCHEDULED a published removal date that is not the item's row (reported apart) |
| REROUTED calls keep working on another model (Gemini 2.5 flash/pro) |
| UNKNOWN_ID / INVALID_ID adjudicated by hand after the run (arm-blind), never guessed |
| PASS a live value fills the slot |
| UNSCORED / UNSCORED_IMPORT / NOT_RUN not scored (outside the denominator, reported per cell) |
| |
| Exec items (rust, duckdb) run code only through `runner(kind, files, argv, env)`; the |
| default local runner is for our own planted fixtures. Model replies go through a |
| contained runner (agent-run.py shell, offline), never the host. |
| """ |
| import datetime as dt |
| import json |
| import os |
| import re |
| import subprocess |
| import tempfile |
| from pathlib import Path |
|
|
| HERE = Path(__file__).resolve().parent |
| ORDER = ["BROKEN_ALREADY_ROW", "FAIL", "BROKEN_ALREADY_OTHER", "ALIAS_SCHEDULED", "OTHER_SCHEDULED", "REROUTED", "UNKNOWN_ID", "INVALID_ID", "PASS"] |
| BAD = ("BROKEN_ALREADY_ROW", "FAIL") |
| SKIP_LANGS = {"text", "txt", "plaintext", "markdown", "md", "console", "output", "log", "diff"} |
| FENCE = re.compile(r"```([^\n`]*)\n(.*?)```", re.S) |
| LINE_COMMENT = re.compile(r"^\s*(#(?!!)|//|/\*|\*(?!\*)|<!--|--\s)") |
| TAIL_COMMENT = re.compile(r"(?<=\S)\s+(#|//)\s.*$") |
| TRIPLE = re.compile(r'"""[\s\S]*?"""|\'\'\'[\s\S]*?\'\'\'') |
| BLOCK_COMMENT = re.compile(r"(?m)(?:^|(?<=\s))/\*[\s\S]*?\*/|<!--[\s\S]*?-->") |
| LOGCALL = re.compile(r"^\s*(?:warnings\.warn|(?:logging|logger|log|LOG|LOGGER)\.\w+|console\.(?:log|warn|error|info|debug)|print|echo|puts" |
| r"|raise\s+\w+|throw\s+new\s+\w+|System\.(?:out|err)\.print(?:ln)?|fmt\.Print\w*)\b") |
| PROSE_STR = re.compile(r'"[^"\n]*\s[^"\n]*"|\'[^\'\n]*\s[^\'\n]*\'') |
|
|
|
|
| def blocks_of(reply): |
| """Code blocks a check may read: fenced blocks minus text/markdown/console/output/log/diff.""" |
| out = [] |
| for lang, body in FENCE.findall(reply): |
| tag = (lang.strip().lower().split() or [""])[0] |
| if tag not in SKIP_LANGS: |
| out.append((lang.strip().lower(), body)) |
| return out |
|
|
|
|
| def clean(code): |
| code = BLOCK_COMMENT.sub("", code) |
| code = TRIPLE.sub('""', code) |
| out = [] |
| for l in code.splitlines(): |
| if LINE_COMMENT.match(l): |
| continue |
| l = TAIL_COMMENT.sub("", l) |
| if LOGCALL.match(l): |
| l = PROSE_STR.sub('""', l) |
| out.append(l) |
| return "\n".join(out) |
|
|
|
|
| def _row_date(row_id): |
| return dt.date.fromisoformat(row_id[:10]) |
|
|
|
|
| |
| Q = r"[\"'`]" |
| SLOT = [re.compile(p) for p in ( |
| r"\bmodel(?:_?[iI]d|_?[nN]ame)?\s*[:=]\s*" + Q + r"([^\"'`\s]+)" + Q, |
| r"[\"']model(?:_?[iI]d|_?[nN]ame)?[\"']\s*:\s*[\"']([^\"']+)[\"']", |
| r"\b(?:[A-Z][A-Z0-9_]*)?MODEL[A-Z0-9_]*\s*[:=]\s*[\"']?([\w.\-:/@]+)", |
| r"(?:getenv|environ\.get)\(\s*[\"'][^\"']*MODEL[^\"']*[\"']\s*,\s*[\"']([^\"']+)[\"']", |
| r"process\.env\.\w*MODEL\w*\s*(?:\|\||\?\?)\s*" + Q + r"([^\"'`]+)" + Q, |
| r"[?&]model=([\w.\-:]+)", |
| r"\b(?:openai|anthropic|google|bedrock|azure)(?:\.\w+)?\(\s*" + Q + r"([^\"'`]+)" + Q, |
| r"--model[ =][\"']?([\w.\-:/@]+)", |
| |
| r"\bGenerativeModel\(\s*" + Q + r"([^\"'`]+)" + Q, |
| r"\bAudio\.(?:transcribe|translate)\(\s*" + Q + r"([^\"'`]+)" + Q, |
| )] |
| STRING = re.compile(r"\"([^\"\n]{2,120})\"|'([^'\n]{2,120})'|`([^`\n]{2,120})`") |
| DATED = re.compile(r"^(.*?)-(\d{4}-\d{2}-\d{2}|\d{8})$") |
| REGION = re.compile(r"^(us|eu|apac|global|jp|au)\.") |
|
|
|
|
| def norm(token, providers): |
| t = re.sub(r"^(openai/|models/|anthropic/|google/)", "", token.strip()) |
| return REGION.sub("", t) if "bedrock" in providers else t |
|
|
|
|
| def alias_snapshots(mid, status, providers): |
| """Real aliases only: OpenAI/Google bare name = a dated snapshot minus its date; |
| Anthropic: dateless 4.x names (claude-sonnet-4-5, claude-opus-4-0 for -4-2025...), |
| and '-latest' for 3.x. Anything else is not an alias.""" |
| snaps = {} |
| for k, v in status.items(): |
| if v["provider"] not in providers: |
| continue |
| m = DATED.match(k) |
| if not m: |
| continue |
| stem = m.group(1) |
| names = {stem} |
| if v["provider"] == "anthropic": |
| names = {stem + "-latest"} if stem.startswith("claude-3") else {stem, stem + "-0"} |
| if mid in names: |
| snaps[k] = v |
| return snaps |
|
|
|
|
| def _on_row(mid, row_ids): |
| """row scope is the explicit rowIds list on the item (IDs the row's own notice retires, bare names it |
| names as affected; regexes allowed), not a text search: the gpt-5 row mentions gpt-3.5-turbo only in passing.""" |
| return any(re.fullmatch(r, mid) for r in row_ids) |
|
|
|
|
| def broken(mid, row_ids, snaps=()): |
| """Dead before the eval date: _ROW when the item's own row names it (or a snapshot of the alias), else _OTHER.""" |
| row = _on_row(mid, row_ids) or any(_on_row(x, row_ids) for x in snaps) |
| return "BROKEN_ALREADY_ROW" if row else "BROKEN_ALREADY_OTHER" |
|
|
|
|
| def classify_id(mid, status, providers, row_ids): |
| on_row = _on_row(mid, row_ids) |
| m = status.get(mid) |
| if m and m["provider"] in providers and m["status"] != "deprecated_undated": |
| st = m["status"] |
| if st == "shutdown": |
| return broken(mid, row_ids), {"shutdown": m["shutdown"], "onRow": on_row} |
| if st == "scheduled": |
| return ("FAIL" if on_row else "OTHER_SCHEDULED"), {"shutdown": m["shutdown"], "onRow": on_row} |
| return {"active": "PASS", "rerouted": "REROUTED"}[st], {} |
| if "bedrock" in providers and not re.search(r"-v\d+(:\d+)?$", mid): |
| |
| |
| cands = [k for k, v in status.items() if v["provider"] == "bedrock" and re.fullmatch(re.escape(mid) + r"-v\d+:\d+", k)] |
| if len(cands) == 1: |
| out, info = classify_id(cands[0], status, providers, row_ids) |
| |
| |
| if not out.startswith("BROKEN_ALREADY"): |
| return "INVALID_ID", {**info, "missingVersionSuffix": cands[0], "wouldBe": out} |
| return out, {**info, "missingVersionSuffix": cands[0]} |
| snaps = alias_snapshots(mid, status, providers) |
| if snaps: |
| st = {v["status"] for v in snaps.values()} |
| info = {"aliasOf": sorted(snaps)} |
| if "active" in st: |
| return "PASS", info |
| if st <= {"shutdown"}: |
| return broken(mid, row_ids, snaps), info |
| |
| |
| snap_on_row = any(_on_row(x, row_ids) for x in snaps) |
| return ("ALIAS_SCHEDULED" if snap_on_row else "OTHER_SCHEDULED"), info |
| if m and m["status"] == "deprecated_undated": |
| return "ALIAS_SCHEDULED", {"why": "provider marks it Deprecated with no date of its own"} |
| return "UNKNOWN_ID", {} |
|
|
|
|
| def check_model(it, code, status, ctx): |
| pat = re.compile(it["check"]["pattern"]) |
| providers = it["check"]["providers"] |
| adj = ctx.get("adjudications", {}) |
| slot_vals, raw_slots = [], [] |
| for rx_ in SLOT: |
| for mm in rx_.finditer(code): |
| v = norm(mm.group(1), providers) |
| if pat.fullmatch(v) and v not in slot_vals: |
| slot_vals.append(v) |
| raw_slots.append(mm.group(1).strip()) |
| mentions = [] |
| for mm in STRING.finditer(code): |
| s = next(g for g in mm.groups() if g is not None) |
| for t in re.findall(r"[\w.\-:/@]+", s): |
| t = norm(t.rstrip(":"), providers) |
| if pat.fullmatch(t) and t not in slot_vals and t not in mentions: |
| mentions.append(t) |
| found = [] |
| for v in slot_vals: |
| if v in adj: |
| out, info = adj[v]["outcome"], {"adjudicated": adj[v]["source"]} |
| if out == "BROKEN_ALREADY": |
| out = broken(v, ctx["row_ids"]) |
| else: |
| out, info = classify_id(v, status, providers, ctx["row_ids"]) |
| found.append({"id": v, "outcome": out, **info}) |
| if not found: |
| return "UNSCORED", {"why": "no model value in a model slot", "mentions": mentions} |
| worst = min(found, key=lambda f: ORDER.index(f["outcome"])) |
| det = {"slots": found, "mentions": mentions, "tokens": [f["id"] for f in found if f["outcome"] == worst["outcome"]]} |
| if "bedrock" in providers and any(not REGION.match(t) for t in raw_slots): |
| det["bareNoPrefix"] = True |
| if worst["outcome"] in BAD and any(f["outcome"] == "PASS" for f in found): |
| return "MIXED", det |
| return worst["outcome"], det |
|
|
|
|
| |
| def rx_flags(s): |
| f = 0 |
| for ch in s: |
| f |= {"i": re.I, "m": re.M, "s": re.S}[ch] |
| return f |
|
|
|
|
| def check_regex(it, code): |
| c = it["check"] |
| fl = rx_flags(c.get("flags", "")) |
|
|
| def hit(pats): |
| out = [] |
| for p in pats: |
| m = re.search(p, code, fl) |
| if m: |
| out.append((p, m.group(0)[:80])) |
| return out |
|
|
| f_any = hit(c["fail"]) |
| f_all = c.get("all_fail") or [] |
| all_ok = bool(f_all) and len(hit(f_all)) == len(f_all) |
| p = hit(c["pass"]) |
| extra = hit(c.get("mixed", [])) |
| gone = hit(c.get("already", [])) |
| toks = lambda hs: [t for _, t in hs if t] |
| if f_any or all_ok: |
| fh = f_any or hit(f_all) |
| det = {"matched": [x for x, _ in fh], "tokens": toks(fh)} |
| guard = c.get("guard") and re.search(c["guard"], code) |
| if guard: |
| return "MIXED", {**det, "why": "fail form under a version guard"} |
| if (p and not c.get("baseline_pass")) or extra: |
| return "MIXED", {**det, "why": "fail and pass forms both present", "alsoMatched": [x for x, _ in p + extra]} |
| return "FAIL", det |
| if gone: |
| return "BROKEN_ALREADY_OTHER", {"matched": [x for x, _ in gone], "tokens": toks(gone)} |
| if p: |
| return "PASS", {"matched": [x for x, _ in p], "tokens": toks(p)} |
| return "UNSCORED", {"why": "no fail or pass route matched (no identifiable route)"} |
|
|
|
|
| MAC_RUNNER_FAIL = [r"runs-on:\s*\[?\s*[\"']?macos-14(-large|-xlarge)?\b", r"[\"']macos-14(-large|-xlarge)?[\"']"] |
| MAC_TOKENS = [r"xcode-version:\s*[\"']?15", r"Xcode_15", r"name=iPhone 15\b", r"OS=(17\.\d|18\.[12])\b"] |
| MAC_NEW = [r"runs-on:\s*\[?\s*[\"']?macos-(1[5-9]|2\d|latest)\b", r"[\"']macos-(1[5-9]|2\d|latest)[\"']"] |
| MAC_GONE = [r"runs-on:\s*\[?\s*[\"']?macos-1[0-3]\b", r"[\"']macos-1[0-3][\"']"] |
|
|
|
|
| def check_macos(it, code): |
| """only the runner label is scored. Simulator or Xcode tokens are off-row (the |
| macos-15 image has no iPhone 15, iOS 17/18.1/18.2 simulator or Xcode 15: provider runner-image pages).""" |
| h = lambda pats: [m.group(0) for p in pats for m in [re.search(p, code, re.I)] if m] |
| old, new, gone, tok = h(MAC_RUNNER_FAIL), h(MAC_NEW), h(MAC_GONE), h(MAC_TOKENS) |
| det = {"tokens": old or new or gone, "offRowTokens": tok} |
| if old: |
| if new: |
| return "MIXED", {**det, "why": "macos-14 and a newer runner label both present"} |
| return "FAIL", det |
| if gone: |
| return "BROKEN_ALREADY_OTHER", det |
| if new: |
| return "PASS", det |
| return "UNSCORED", {**det, "why": "no runner label: the route is the runner"} |
|
|
|
|
| FROM_LINE = re.compile(r"^\s*FROM\s+(?:--\S+\s+)*[\"']?(\S+?)[\"']?(?:\s+AS\s+\S+)?\s*$", re.I | re.M) |
|
|
|
|
| def check_php(it, code): |
| froms = [f for f in FROM_LINE.findall(code) if re.match(r"(docker\.io/)?(library/)?php(:|@|$)", f)] |
| if not froms: |
| return "UNSCORED", {"why": "no php base image"} |
| final = froms[-1] |
| tag = final.split("@")[0].split(":", 1)[1] if ":" in final.split("@")[0] else "" |
| pin = re.match(r"(\d+)\.(\d+)", tag) |
| if "@sha256:" in final or (pin and (int(pin.group(1)), int(pin.group(2))) < (8, 6)): |
| return "PASS", {"from": final} |
| |
| moving = bool(pin) or tag == "" or re.fullmatch(r"(latest|8|fpm|apache|cli|zts|alpine|8-[a-z][\w.\-]*|(fpm|apache|cli|zts)-[a-z][\w.\-]*)", tag) |
| if not moving: |
| return "UNSCORED", {"from": final, "why": "tag not classified"} |
| pecl = re.search(r"\bpecl\s+install\b", code) |
| ipe = re.search(r"install-php-extensions[^\n]*\b(apcu|redis)\b", code) |
| if pecl or ipe: |
| return "FAIL", {"from": final, "pecl": bool(pecl), "ipeApcuRedis": bool(ipe)} |
| return "UNSCORED", {"from": final, "why": "moving tag; extension route not classified"} |
|
|
|
|
| NODE_IMG = re.compile(r"(?:^\s*FROM\s+(?:--\S+\s+)*|image:\s*)[\"']?(?:docker\.io/)?(?:library/)?node(?::([\w.\-]+))?(@sha256:\w+)?", re.I | re.M) |
|
|
|
|
| def check_node(it, code): |
| imgs = NODE_IMG.findall(code) |
| if not imgs: |
| return "UNSCORED", {"why": "no node image"} |
| uses = re.search(r"(^|[\s;&|\"'\[])(yarn|corepack)(\s|$|[\"',\]])", code, re.M) |
| installs = re.search(r"npm\s+(i|install)\s+(-g|--global)\s+[^\n]*\b(yarn|corepack)\b", code) |
| if not uses or installs: |
| return "PASS", {"images": imgs, "yarnOrCorepack": bool(uses), "installs": bool(installs)} |
| verdicts = [] |
| for tag, digest in imgs: |
| if digest: |
| verdicts.append("PASS") |
| elif tag.startswith("lts-krypton") or re.match(r"(1\d|2[0-4])(\b|[.\-])", tag): |
| verdicts.append("PASS") |
| elif re.match(r"lts(\b|-)", tag) or re.match(r"2[6-9](\b|[.\-])", tag): |
| verdicts.append("FAIL") |
| else: |
| verdicts.append("UNSCORED") |
| if "FAIL" in verdicts: |
| return "FAIL", {"images": imgs} |
| if "UNSCORED" in verdicts: |
| return "UNSCORED", {"images": imgs, "why": "node tag whose yarn/corepack content is not verified"} |
| return "PASS", {"images": imgs} |
|
|
|
|
| def check_ghapy(it, code): |
| old = it["check"]["old"] |
| has_old = re.search(r"python-version[^\n]*[\[:\s\"',]3\.(" + old + r")(?!\d)", code) or \ |
| re.search(r"^\s*-\s*[\"']?3\.(" + old + r")(?!\d)[\"']?\s*$", code, re.M) |
| if not has_old: |
| return "UNSCORED", {"why": "old Python not in the workflow"} |
| latest = re.search(r"ubuntu-latest", code) |
| pinned = re.search(r"ubuntu-2[24]\.04", code) |
| alt = re.search(r"astral-sh/setup-uv|uv python install|conda-incubator|deadsnakes", code) |
| if latest and not pinned and not alt: |
| return "FAIL", {} |
| if pinned and not latest: |
| return "PASS", {} |
| if alt and not re.search(r"actions/setup-python@", code): |
| return "PASS", {"alt": alt.group(0)} |
| return "UNSCORED", {"why": "mixed runners: needs a per-job read"} |
|
|
|
|
| def check_launchdarkly(it, code): |
| v = re.findall(r"LD-API-Version[\"']?\s*[:=,]\s*[\"']([\w\-]+)[\"']", code, re.I) |
| |
| paged = re.search(r"[?&](limit|offset)=|[\"']?\b(limit|offset)\b[\"']?\s*[:=]|\b_links\b[^\n]{0,40}[\"']?next\b", code) |
| if any(x != "20240415" for x in v): |
| return "FAIL", {"versions": v} |
| if not paged: |
| return "FAIL", {"versions": v, "why": "no paging: at most 20 flags (calendar)"} |
| if not v: |
| return "UNSCORED", {"why": "paging but no header: depends on the token's default version"} |
| return "PASS", {"versions": v} |
|
|
|
|
| def _ver(s): |
| return tuple(int(x) for x in re.findall(r"\d+", s)) |
|
|
|
|
| def _sat(v, op, w): |
| a, b = list(v), list(w) |
| n = max(len(a), len(b)) |
| a += [0] * (n - len(a)); b += [0] * (n - len(b)) |
| a, b = tuple(a), tuple(b) |
| if op == "~>": |
| parts = list(w) |
| upper = (parts[0] + 1,) if len(parts) <= 2 else tuple(parts[:-2]) + (parts[-2] + 1,) |
| return _sat(v, ">=", w) and _sat(v, "<", upper) |
| return {"=": a == b, "==": a == b, "!=": a != b, ">=": a >= b, ">": a > b, "<=": a <= b, "<": a < b}[op] |
|
|
|
|
| def check_rails(it, code): |
| lines = re.findall(r"gem\s+[\"']rails[\"']((?:\s*,\s*[\"'][^\"']+[\"'])*)", code) |
| if not lines: |
| return "UNSCORED", {} |
| cons = re.findall(r"[\"']\s*(~>|>=|<=|!=|==|=|>|<)?\s*([\d.]+)\s*[\"']", lines[-1]) |
| supported = [(8, 1, 0), (8, 1, 4, 1), (8, 1, 99), (8, 2, 0), (9, 0, 0)] |
| ok = any(all(_sat(t, op or "=", _ver(w)) for op, w in cons) for t in supported) |
| return ("PASS" if ok else "FAIL"), {"constraints": cons, "lineUsed": "last"} |
|
|
|
|
| |
| RUSTC_STUB = """#!/bin/sh |
| case "$1" in |
| -vV) printf 'rustc {v} (8a2b3c4d5 2026-11-12)\\nbinary: rustc\\ncommit-hash: 8a2b3c4d5\\nhost: x86_64-unknown-linux-gnu\\nrelease: {v}\\nLLVM version: 21.1.0\\n' ;; |
| *) echo "rustc {v} (8a2b3c4d5 2026-11-12)" ;; |
| esac |
| """ |
| LANG_TAGS = {"bash": ("bash", "sh", "shell", "zsh", ""), "python": ("python", "py", "python3"), |
| "make": ("make", "makefile", "mk", "")} |
|
|
|
|
| def local_runner(kind, files, argv, env): |
| with tempfile.TemporaryDirectory() as d: |
| for name, (body, mode) in files.items(): |
| p = Path(d) / name |
| p.parent.mkdir(parents=True, exist_ok=True) |
| p.write_text(body) |
| os.chmod(p, mode) |
| e = {"PATH": f"{d}/bin:/usr/bin:/bin", "HOME": d, "LANG": "C.UTF-8"} |
| e.update(env) |
| r = subprocess.run(argv, cwd=d, env=e, capture_output=True, text=True, timeout=30) |
| return r.returncode, r.stdout[-2000:], r.stderr[-2000:] |
|
|
|
|
| def check_rust(it, reply, runner): |
| c = it["check"] |
| lang, mn = c["lang"], c.get("min", "1.70") |
| blocks = blocks_of(reply) |
| pick = [b for l, b in blocks if l in LANG_TAGS[lang]] or [b for _, b in blocks] |
| if not pick: |
| return "UNSCORED", {"why": "no code"} |
| code = pick[0] |
| major, minor = _ver(mn)[:2] |
| low = f"{major}.{minor - 1}.0" |
| name, argv = {"bash": ("check.sh", ["bash", "check.sh"]), |
| "python": ("check.py", ["python3", "-I", "check.py"]), |
| "make": ("Makefile", ["make", "-s", "check-rust"])}[lang] |
| body = code if lang != "make" else re.sub(r"(?m)^ {2,8}(?=\S)", "\t", code) |
| rc, errs = {}, {} |
| for v in ("1.100.0", "1.99.0", low): |
| r_ = runner("rust", {name: (body, 0o644), "bin/rustc": (RUSTC_STUB.format(v=v), 0o755)}, argv, {}) |
| rc[v], errs[v] = r_[0], (r_[2] if len(r_) > 2 else "") |
| if any(re.search(r"ModuleNotFoundError|ImportError", e) for e in errs.values()): |
| |
| return "UNSCORED_IMPORT", {"why": "ImportError in the runner", "rc": rc, |
| "err": next(e for e in errs.values() if "Error" in e)[-200:]} |
| if rc[low] == 0: |
| return "UNSCORED", {"why": f"accepts {low}: not a minimum-version check", "rc": rc} |
| if rc["1.99.0"] != 0: |
| return "UNSCORED", {"why": "rejects 1.99.0: broken for another reason", "rc": rc} |
| return ("PASS" if rc["1.100.0"] == 0 else "FAIL"), {"rc": rc} |
|
|
|
|
| def check_duckdb(it, code, runner): |
| m = [p for p in it["check"]["static_fail"] if re.search(p, code)] |
| if runner is None: |
| return ("FAIL" if m else "UNSCORED"), {"static": True, "matched": m} |
| raise NotImplementedError("contained duckdb 2.0 runner: see PROTOCOL") |
|
|
|
|
| |
| def score(it, reply, status, runner=None, ctx=None): |
| ctx = dict(ctx or {}) |
| ctx.setdefault("row_ids", it.get("rowIds", [])) |
| blocks = blocks_of(reply) |
| if not blocks: |
| return "UNSCORED", {"why": "no code block (text/markdown/console blocks are not read)"} |
| t = it["check"]["type"] |
| if t == "exec_rust": |
| out, det = check_rust(it, reply, runner or local_runner) |
| else: |
| code = clean("\n".join(b for _, b in blocks)) |
| fn = {"model_id": lambda: check_model(it, code, status, ctx), "regex": lambda: check_regex(it, code), |
| "php": lambda: check_php(it, code), "node": lambda: check_node(it, code), |
| "ghapy": lambda: check_ghapy(it, code), "macos": lambda: check_macos(it, code), "launchdarkly": lambda: check_launchdarkly(it, code), |
| "rails": lambda: check_rails(it, code), "exec_duckdb": lambda: check_duckdb(it, code, runner)}[t] |
| out, det = fn() |
| |
| if out == "FAIL" and t != "model_id" and it["breakClass"] == "stops-working": |
| eval_date = dt.date.fromisoformat(ctx.get("eval_date") or META["evalDate"]) |
| if all(_row_date(r) <= eval_date for r in it["rows"]): |
| out, det = "BROKEN_ALREADY_ROW", {**det, "rowDatePassed": True} |
| if ctx.get("calendar_text") and det.get("tokens"): |
| det.update(calendar_echo(det["tokens"], ctx["calendar_text"])) |
| return out, det |
|
|
|
|
| def calendar_echo(tokens, cal): |
| """Arm C: does a decisive matched token appear verbatim in the calendar text the model was given?""" |
| cal_l = cal.lower() |
| parts = [t for tok in tokens for t in re.findall(r"[\w.\-:/@]{5,}", tok)] |
| seen = [t.lower() in cal_l for t in parts] |
| return {"calendarEchoAny": any(seen), "calendarEchoAll": bool(seen) and all(seen), "echoTokens": parts[:8]} |
|
|
|
|
| _ROWS = None |
|
|
|
|
| def row_text(it): |
| global _ROWS |
| if _ROWS is None: |
| _ROWS = {r["id"]: r for r in json.load(open(HERE / "calendar-entries-20261112.json"))["entries"]} |
| return "\n".join(_ROWS[r]["what"] + "\n" + _ROWS[r]["affected"] for r in it["rows"]) |
|
|
|
|
| def load_status(): |
| d = json.load(open(HERE / "model_status.json")) |
| global META |
| META = d["meta"] |
| return d["models"] |
|
|
|
|
| META = json.load(open(HERE / "model_status.json"))["meta"] |
|
|
