| """Write a second text-to-SQL exam with Claude, as an evaluation set only (never training data). |
| |
| For each new industry, Claude designs a small SQLite database and writes questions with the query that answers each. Every |
| query is run in the sandbox and kept only if it is one read-only SELECT that returns 1 to 100 rows (the checks of the first |
| exam, from gen_sql_data.py). Rows that share a question or a query with the training data are dropped from the exam. |
| The key is read from ANTHROPIC_API_KEY, never printed or written. |
| |
| python scripts/text2sql/gen_exam2.py --out DIR --train train_merged.jsonl [--only 1] [--model claude-sonnet-5-5] |
| """ |
|
|
| |
| import argparse |
| import hashlib |
| import json |
| import os |
| import re |
| import sys |
| import threading |
| import time |
| import urllib.error |
| import urllib.request |
| from concurrent.futures import ThreadPoolExecutor |
| from pathlib import Path |
|
|
| sys.path.insert(0, str(Path(__file__).resolve().parent)) |
| import gen_sql_data as g |
|
|
| API = "https://api.anthropic.com/v1/messages" |
|
|
| |
| INDUSTRIES = [ |
| "museum collections", |
| "veterinary clinic", |
| "wine distribution", |
| "film production schedule", |
| "wind farm maintenance", |
| "court case management", |
| "recycling plant operations", |
| "podcast network", |
| "cinema chain", |
| "fishing fleet", |
| ] |
|
|
| PROMPT = ( |
| "Design a small SQLite database for this industry: {domain}. Give 3 to 5 tables with PRIMARY KEY and FOREIGN KEY clauses, " |
| "realistic column names, a mix of TEXT, INTEGER, REAL and dates stored as ISO text, and 10 to 15 realistic rows per table " |
| "(consistent with the foreign keys, some repeated categories, different dates, some NULLs), as one SQL script of CREATE TABLE " |
| "and INSERT statements in a single ```sql code block.\n\n" |
| "Then write {n} different questions a business user might ask about this data, each with the SQLite SELECT query that answers it. " |
| "Mix: {simple} 'simple' (one table: filter, sort or top-N), {join} 'join' (two or more tables), {agg} 'aggregate' " |
| "(GROUP BY, COUNT, SUM, AVG), {hard} 'hard' (subquery, HAVING, three tables, CASE, or a date calculation).\n" |
| "Rules: phrase each question the way a person would, without copying table or column names; every query must be one read-only " |
| "SELECT, valid SQLite, answerable from the data above, and return between 1 and 20 rows.\n" |
| "After the SQL script, output the questions in exactly this format for each item:\n" |
| "### <number>\nDIFFICULTY: <simple|join|aggregate|hard>\nQUESTION: <question>\nSQL: <query>\n" |
| ) |
|
|
|
|
| class Meter: |
| def __init__(self): |
| self.tin = self.tout = self.calls = 0 |
| self.lock = threading.Lock() |
|
|
|
|
| def ask(key: str, model: str, prompt: str, meter: Meter) -> str | None: |
| body = json.dumps({"model": model, "max_tokens": 16000, "messages": [{"role": "user", "content": prompt}]}).encode() |
| req = urllib.request.Request( |
| API, body, {"x-api-key": key, "anthropic-version": "2023-06-01", "content-type": "application/json"} |
| ) |
| for attempt in range(5): |
| try: |
| with urllib.request.urlopen(req, timeout=300) as r: |
| d = json.load(r) |
| with meter.lock: |
| meter.tin += d.get("usage", {}).get("input_tokens", 0) |
| meter.tout += d.get("usage", {}).get("output_tokens", 0) |
| meter.calls += 1 |
| return "".join(b.get("text", "") for b in d.get("content", []) if b.get("type") == "text") |
| except urllib.error.HTTPError as e: |
| if e.code in (429, 500, 502, 503, 529) and attempt < 4: |
| time.sleep(5 * (attempt + 1)) |
| continue |
| try: |
| err = json.loads(e.read().decode("utf-8", "replace")).get("error", {}) |
| detail = f"{err.get('type')}: {str(err.get('message'))[:240]}" |
| except Exception: |
| detail = "unreadable body" |
| print(f"API error {e.code} ({detail})", flush=True) |
| return None |
| except Exception as e: |
| if attempt == 4: |
| print(f"request failed: {type(e).__name__}", flush=True) |
| return None |
| time.sleep(5 * (attempt + 1)) |
| return None |
|
|
|
|
| def build(job: dict, key: str, model: str, meter: Meter, n: int): |
| mix = {"simple": round(n * 0.3), "join": round(n * 0.3), "agg": round(n * 0.2)} |
| mix["hard"] = n - sum(mix.values()) |
| text = ask(key, model, PROMPT.format(domain=job["domain"], n=n, **mix), meter) |
| if not text: |
| return {"job": job, "rows": [], "fail": "no response"} |
| script = g.sql_block(text.split("### 1")[0]) if "### 1" in text else g.sql_block(text) |
| built = g.build_db(script) if script else None |
| if not built: |
| return {"job": job, "rows": [], "fail": "schema", "raw": text} |
| conn, ddl = built |
| schema_text = "\n\n".join(d.strip().rstrip(";") + ";" for d in ddl) |
| rows, seen, bad = [], set(), 0 |
| for it in g.parse_items(text): |
| if it["difficulty"] not in ("simple", "join", "aggregate", "hard") or it["question"].lower() in seen: |
| bad += 1 |
| continue |
| if g.run_select(conn, it["sql"]) is None: |
| bad += 1 |
| continue |
| seen.add(it["question"].lower()) |
| rows.append({"question": it["question"], "sql": it["sql"].strip().rstrip(";") + ";", "difficulty": it["difficulty"]}) |
| return {"job": job, "script": script, "schema": schema_text, "rows": rows, "rejected": bad, "raw": text} |
|
|
|
|
| def tables(prompt_user: str) -> frozenset: |
| return frozenset(re.findall(r"(?i)create table\s+(?:if not exists\s+)?[\"`]?(\w+)", prompt_user)) |
|
|
|
|
| def main() -> int: |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--out", required=True) |
| ap.add_argument("--train", required=True, help="the merged training file, to drop rows that overlap it") |
| ap.add_argument("--model", default="claude-sonnet-5-5") |
| ap.add_argument("--n", type=int, default=20, help="questions asked per database") |
| ap.add_argument("--only", type=int, default=0, help="only the first N industries (a pilot)") |
| ap.add_argument("--workers", type=int, default=4) |
| a = ap.parse_args() |
| key = os.environ.get("ANTHROPIC_API_KEY", "") |
| if not key: |
| sys.exit("ANTHROPIC_API_KEY is not set") |
| out = Path(a.out) |
| (out / "raw").mkdir(parents=True, exist_ok=True) |
| jobs = [{"id": f"exam2-{i}", "domain": d} for i, d in enumerate(INDUSTRIES[: a.only or None])] |
| meter = Meter() |
| with ThreadPoolExecutor(a.workers) as ex: |
| dbs = list(ex.map(lambda j: build(j, key, a.model, meter, a.n), jobs)) |
| for d in dbs: |
| if d.get("raw"): |
| (out / "raw" / f"{d['job']['id']}.txt").write_text(d["raw"], encoding="utf-8") |
| train = [json.loads(line) for line in open(a.train, encoding="utf-8") if line.strip()] |
| tq = {r["prompt"][1]["content"].rsplit("Question:", 1)[-1].strip().lower() for r in train} |
| ta = {r["completion"][0]["content"].strip() for r in train} |
| tt = {tables(r["prompt"][1]["content"]) for r in train} |
| golden, used, dropped = [], {}, 0 |
| for d in dbs: |
| if not d["rows"]: |
| continue |
| if tables(d["schema"]) in tt: |
| dropped += len(d["rows"]) |
| continue |
| for r in d["rows"]: |
| if r["question"].lower() in tq or r["sql"].strip() in ta: |
| dropped += 1 |
| continue |
| ex = g.example( |
| {"job": {"id": d["job"]["id"], "domain": d["job"]["domain"], "seen": False}, "schema": d["schema"]}, r, True |
| ) |
| golden.append(ex) |
| used[d["job"]["id"]] = d["script"] |
| (out / "golden.jsonl").write_text("\n".join(json.dumps(r) for r in golden) + "\n", encoding="utf-8") |
| (out / "dbs.json").write_text(json.dumps(used), encoding="utf-8") |
| by = {} |
| for r in golden: |
| by[r["meta"]["difficulty"]] = by.get(r["meta"]["difficulty"], 0) + 1 |
| manifest = { |
| "what": "A second text-to-SQL exam, written by a different model than the training labels. Evaluation only; never trained on.", |
| "author_model": a.model, |
| "industries": [j["domain"] for j in jobs], |
| "rows": len(golden), |
| "by_difficulty": by, |
| "databases": len(used), |
| "failed_databases": sum(1 for d in dbs if not d["rows"]), |
| "rejected_by_execution_check": sum(d.get("rejected", 0) for d in dbs), |
| "dropped_for_overlap_with_training": dropped, |
| "api_calls": meter.calls, |
| "tokens": {"in": meter.tin, "out": meter.tout}, |
| "sha256": {f: hashlib.sha256((out / f).read_bytes()).hexdigest() for f in ("golden.jsonl", "dbs.json")}, |
| } |
| (out / "manifest.json").write_text(json.dumps(manifest, indent=2), encoding="utf-8") |
| print(json.dumps(manifest, indent=2)) |
| return 0 if golden else 1 |
|
|
|
|
| if __name__ == "__main__": |
| sys.exit(main()) |
|
|
