| """Execution verifiers -- the OBJECTIVE half of the reward. |
| |
| For modalities Handicate can produce as code/markup, we don't just ask the judge's |
| opinion -- we actually RUN/parse the artifact and check it works. That hard signal is |
| what lets reinforcement learning improve real capability (working 3D, valid SVG, code |
| that runs) instead of just plausible-looking text. |
| |
| Verifiers return a float in 0..1 (1 = works). They run generated code in a subprocess |
| with a timeout -- safe on the ephemeral HF Job container; locally only run on trusted input. |
| """ |
| import re |
| import subprocess |
| import sys |
| import tempfile |
| from pathlib import Path |
|
|
|
|
| def extract_block(text, langs=("python", "")): |
| for lang in langs: |
| m = re.search(rf"```{lang}\s*\n(.*?)```", text, re.DOTALL | re.IGNORECASE) |
| if m: |
| return m.group(1).strip() |
| |
| m = re.search(r"```\s*\n(.*?)```", text, re.DOTALL) |
| return m.group(1).strip() if m else text.strip() |
|
|
|
|
| def _run(code, prelude="", timeout=15): |
| with tempfile.NamedTemporaryFile("w", suffix=".py", delete=False, encoding="utf-8") as f: |
| f.write(prelude + "\n" + code) |
| path = f.name |
| try: |
| r = subprocess.run([sys.executable, path], capture_output=True, text=True, timeout=timeout) |
| return r.returncode == 0, (r.stdout + r.stderr) |
| except subprocess.TimeoutExpired: |
| return False, "timeout" |
| except Exception as e: |
| return False, str(e) |
| finally: |
| Path(path).unlink(missing_ok=True) |
|
|
|
|
| def verify_python(text): |
| """Code must run without error.""" |
| ok, _ = _run(extract_block(text, ("python", ""))) |
| return 1.0 if ok else 0.0 |
|
|
|
|
| def verify_3d(text): |
| """Generated code must build a valid mesh (a `mesh` trimesh with faces, or save an OBJ).""" |
| code = extract_block(text, ("python", "")) |
| check = ("\n_m = globals().get('mesh', None)\n" |
| "assert _m is not None, 'no mesh variable'\n" |
| "assert len(getattr(_m, 'faces', [])) > 0 and len(getattr(_m, 'vertices', [])) > 0\n" |
| "print('MESH_OK', len(_m.vertices), len(_m.faces))\n") |
| ok, out = _run(code + check, prelude="import trimesh, numpy as np") |
| return 1.0 if (ok and "MESH_OK" in out) else 0.0 |
|
|
|
|
| def verify_svg(text): |
| """SVG must parse and contain at least one drawable shape.""" |
| import xml.etree.ElementTree as ET |
| m = re.search(r"<svg.*?</svg>", text, re.DOTALL | re.IGNORECASE) |
| if not m: |
| return 0.0 |
| try: |
| root = ET.fromstring(m.group(0)) |
| except Exception: |
| return 0.0 |
| shapes = ("path", "rect", "circle", "ellipse", "line", "polyline", "polygon") |
| found = any(el.tag.split("}")[-1] in shapes for el in root.iter()) |
| return 1.0 if found else 0.3 |
|
|
|
|
| def verify_bash(text): |
| """Syntax-check only (no execution): bash -n on a temp file (portable, unix newlines).""" |
| code = extract_block(text, ("bash", "sh", "")) |
| import os |
| with tempfile.NamedTemporaryFile("w", suffix=".sh", delete=False, newline="\n", encoding="utf-8") as f: |
| f.write(code) |
| path = f.name |
| try: |
| r = subprocess.run(["bash", "-n", path], capture_output=True, text=True, timeout=10) |
| return 1.0 if r.returncode == 0 else 0.0 |
| except Exception: |
| return 0.0 |
| finally: |
| Path(path).unlink(missing_ok=True) |
|
|
