Datasets:
File size: 6,190 Bytes
e8c001c | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 | #!/usr/bin/env python3
"""
flinksql_005: End-to-end verification that ground_truth.sql earns FULL product score.
GT is graded as if it were the agent's answer. We assert the ground truth earns
the FULL product score (A/B/C/D dims, product_ratio == 1.0). Process dims
(G/H/I/J) are ignored: a bare GT run has no agent transcript, so those dims are
legitimately 0 and must NOT count against the case.
Flow:
1. Start Docker container with Flink environment
2. Setup workspace (copy init/)
3. Copy ground_truth.sql -> result.sql
4. Inject gt/ directory
5. Run grade(workspace_path='/tmp_workspace')
6. Assert product_ratio == 1.0 (GT must earn full product score)
7. Cleanup container
Usage:
python3 verify_grade.py
"""
import json
import os
import subprocess
import sys
import tempfile
import uuid
from pathlib import Path
DOCKER_IMAGE = os.environ.get("DOCKER_IMAGE", "dataclaw-eval:v1.0")
TMP_WORKSPACE = "/tmp_workspace"
TASK_DIR = Path(__file__).resolve().parent.parent # flinksql_005/
CONTAINER_NAME = f"verify_gt_flinksql_005_{uuid.uuid4().hex[:8]}"
PRODUCT_PREFIXES = ("A_", "B_", "C_", "D_")
def run_cmd(cmd, timeout=300, check=True):
"""Run a command, raise on failure if check=True."""
r = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
universal_newlines=True, timeout=timeout)
if check and r.returncode != 0:
raise RuntimeError("Command failed: {}\nstderr: {}\nstdout: {}".format(
' '.join(cmd), r.stderr, r.stdout))
return r
def cleanup():
subprocess.run(["docker", "rm", "-f", CONTAINER_NAME],
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
def product_ratio(scores):
"""GT product ratio (0..1) = sum(A/B/C/D raw score) / sum(A/B/C/D max).
Uses RAW dimension scores, NOT product_points: product_points already
applies a per-case product_weight (0.6 or 0.7) which differs across cases
and is irrelevant to "did GT max out the product dims".
"""
raw = mx = 0.0
for dim, info in (scores.get("details", {}) or {}).items():
if dim.startswith(PRODUCT_PREFIXES) and isinstance(info, dict):
raw += info.get("score", 0) or 0
mx += info.get("max", 0) or 0
return round(raw / mx, 4) if mx else 0.0
def main():
workspace_path = str(TASK_DIR)
print(f"[verify] Task dir: {workspace_path}")
print(f"[verify] Container: {CONTAINER_NAME}")
print(f"[verify] Docker image: {DOCKER_IMAGE}")
cleanup()
try:
print("[verify] Step 1: Starting container...")
run_cmd([
"docker", "run", "-d",
"--name", CONTAINER_NAME,
"-v", f"{workspace_path}/init:/app:ro",
DOCKER_IMAGE, "/bin/bash", "-c", "tail -f /dev/null",
])
print("[verify] Step 2: Setting up workspace...")
run_cmd([
"docker", "exec", CONTAINER_NAME, "/bin/bash", "-c",
f"mkdir -p {TMP_WORKSPACE}/init && cp -r /app/. {TMP_WORKSPACE}/init/ "
f"&& chmod -R u+w {TMP_WORKSPACE}",
])
print("[verify] Step 3: Copying ground_truth.sql -> result.sql...")
gt_host = os.path.join(workspace_path, "gt")
run_cmd(["docker", "cp", gt_host, f"{CONTAINER_NAME}:{TMP_WORKSPACE}/gt"])
run_cmd([
"docker", "exec", CONTAINER_NAME, "/bin/bash", "-c",
f"cp {TMP_WORKSPACE}/gt/ground_truth.sql {TMP_WORKSPACE}/result.sql",
])
print("[verify] Step 4: Running grade()...")
grade_runner = "\n".join([
"import json",
"import sys",
f"sys.path.insert(0, '{TMP_WORKSPACE}')",
f"sys.path.insert(0, '{TMP_WORKSPACE}/gt')",
"from grade import grade",
f"result = grade(workspace_path='{TMP_WORKSPACE}')",
"print('__VERIFY_JSON_START__')",
"print(json.dumps(result, ensure_ascii=False))",
"print('__VERIFY_JSON_END__')",
]) + "\n"
with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False,
encoding="utf-8") as f:
f.write(grade_runner)
runner_host = f.name
try:
run_cmd(["docker", "cp", runner_host,
f"{CONTAINER_NAME}:/tmp/_verify_runner.py"])
r = subprocess.run(
["docker", "exec", CONTAINER_NAME, "python3", "/tmp/_verify_runner.py"],
stdout=subprocess.PIPE, stderr=subprocess.PIPE,
universal_newlines=True, timeout=600,
)
finally:
os.unlink(runner_host)
stdout = r.stdout or ""
if "__VERIFY_JSON_START__" not in stdout or "__VERIFY_JSON_END__" not in stdout:
print("[verify] FAIL: No JSON output from grade")
print(f" stdout (last 2000): {stdout[-2000:]}")
print(f" stderr (last 2000): {(r.stderr or '')[-2000:]}")
sys.exit(1)
json_str = stdout.split("__VERIFY_JSON_START__")[1].split("__VERIFY_JSON_END__")[0].strip()
scores = json.loads(json_str)
print("[verify] Grade result:")
print(json.dumps(scores, indent=2, ensure_ascii=False))
ratio = product_ratio(scores)
print(f"[verify] product_ratio = {ratio} "
f"(product_points={scores.get('product_points')}, "
f"overall_score={scores.get('overall_score')})")
if ratio >= 1.0:
print(f"\n[verify] PASS: GT earned full product score (product_ratio={ratio})")
else:
print(f"\n[verify] FAIL: GT did NOT earn full product score (product_ratio={ratio})")
for dim, info in (scores.get("details", {}) or {}).items():
if dim.startswith(PRODUCT_PREFIXES) and isinstance(info, dict):
print(f" {dim}: {info.get('score', 0)}/{info.get('max', 0)}")
for d in (scores.get("diagnostics") or []):
print(f" diag: {d}")
sys.exit(1)
except Exception as e:
print(f"[verify] ERROR: {e}")
sys.exit(1)
finally:
cleanup()
if __name__ == "__main__":
main()
|