| """Deterministic grading for binary-reasoning-v1 items. Pure functions, no framework deps.""" |
| import json |
| import re |
|
|
| JUDGE_FAMILIES = {"func_summary", "arch_semantics_qa", "isa_semantics_qa", "pe_import_reasoning", "pe_structure_qa"} |
|
|
|
|
| def norm_symbol(s: str) -> str: |
| s = s.strip().lower() |
| s = re.sub(r"^[*&]+", "", s) |
| s = re.sub(r"\(.*\)$", "", s).strip() |
| s = re.sub(r"\.+$", "", s) |
| return s |
|
|
|
|
| def _answer_symbol(answer) -> str: |
| if isinstance(answer, dict): |
| return answer.get("symbol", "") |
| return str(answer) |
|
|
|
|
| def grade_func_id_exact(reply: str, answer) -> float: |
| sym = norm_symbol(_answer_symbol(answer)) |
| if not sym: |
| return 0.0 |
| accepted = {sym} |
| if isinstance(answer, dict): |
| accepted |= {norm_symbol(a) for a in answer.get("aliases", []) if a} |
| toks = [norm_symbol(t) for t in re.findall(r"[A-Za-z_][A-Za-z0-9_.]+", reply)] |
| return 1.0 if accepted & set(toks) else 0.0 |
|
|
|
|
| def grade_func_id_mc(reply: str, answer: dict) -> float: |
| correct = answer.get("correct", "") |
| opts = answer.get("options", []) |
| r = reply.strip() |
| m = re.search(r"\b([A-D])\b", r[:80], re.IGNORECASE) |
| if m: |
| idx = ord(m.group(1).upper()) - 65 |
| if 0 <= idx < len(opts): |
| return float(norm_symbol(opts[idx]) == norm_symbol(correct)) |
| names = [norm_symbol(o) for o in re.findall(r"[A-Za-z_][A-Za-z0-9_.]{3,}", r.lower())] |
| return 1.0 if norm_symbol(correct) in names else 0.0 |
|
|
|
|
| def grade_tcfp(reply: str, answer: dict) -> float: |
| strs = answer.get("toolchain_strings", []) |
| if not strs: |
| return 0.0 |
| hits = sum(1 for s in strs if s.lower() in reply.lower()) |
| return hits / len(strs) |
|
|
|
|
| def needs_judge(family: str, answer) -> bool: |
| if family in JUDGE_FAMILIES: |
| return True |
| if family == "func_id_exact": |
| sym = _answer_symbol(answer) |
| |
| return (" " in sym.strip()) or ("inferred" in sym.lower()) |
| return False |
|
|
|
|
| def grade_agentic(reply: str, answer) -> float: |
| flag = _answer_symbol(answer) |
| return 1.0 if flag and flag in reply else 0.0 |
|
|
|
|
| def grade_crossarch(reply: str, answer) -> float: |
| if isinstance(answer, str): |
| try: |
| answer = json.loads(answer) |
| except Exception: |
| answer = {"same": "true" in answer.lower(), |
| "symbol": re.sub(r'.*?"symbol"\s*:\s*"([^"]+)".*', r"\1", answer) if '"symbol"' in answer else ""} |
| want = bool(answer.get("same")) |
| r = reply.lower() |
| neg = bool(re.search(r"\bnot\s+(the\s+)?same\b|\bdifferent\b|\bno\b", r)) |
| pos = not neg and bool(re.search(r"\bsame\b|\byes\b|\btrue\b|match", r)) |
| if not (neg or pos): |
| return 0.0 |
| if pos != want: |
| return 0.0 |
| if want: |
| sym = norm_symbol(answer.get("symbol", "")) |
| toks = [norm_symbol(t) for t in re.findall(r"[A-Za-z_][A-Za-z0-9_.]+", reply)] |
| if sym not in toks: |
| return 0.0 |
| return 1.0 |
|
|
|
|
| def grade_library_ident(reply: str, answer) -> float: |
| ans = _answer_symbol(answer) |
| toks = [t for t in re.split(r"\s+", ans) if len(t) >= 2] |
| r = reply.lower() |
| return 1.0 if all(t.lower() in r for t in toks) else 0.0 |
|
|
|
|
| def grade_item(family: str, reply: str, answer) -> float: |
| if needs_judge(family, answer): |
| return 0.0 |
| if family == "library_ident": |
| return grade_library_ident(reply, answer) |
| if family == "crossarch_equivalence": |
| return grade_crossarch(reply, answer) |
| if family == "agentic_flag_hunt": |
| return grade_agentic(reply, answer) |
| if family == "func_id_exact": |
| return grade_func_id_exact(reply, answer) |
| if family == "func_id_mc": |
| return grade_func_id_mc(reply, answer) |
| if family == "toolchain_fp": |
| return grade_tcfp(reply, answer) |
| return 0.0 |
|
|
