code/scripts/build_fixer_critique_aware_v6_fast.py

"""
Concurrent version of build_fixer_critique_aware_v6.py — uses ThreadPoolExecutor to process
multiple BIRD-train questions in parallel against the same vLLM ensemble. vLLM batches incoming
requests internally, so concurrent client threads give close to linear speedup.
"""
import argparse
import json
import os
import re
import random
import sqlite3
import threading
from concurrent.futures import ThreadPoolExecutor, as_completed

os.environ.setdefault("PYTHONNOUSERSITE", "1")
os.environ["NO_PROXY"] = "localhost,127.0.0.1"

import requests
from datasets import load_dataset, Dataset, DatasetDict


_db_lock = threading.Lock()


def safe_exec(db_path, sql, timeout=5):
    r = [None]; e = [None]
    def _run():
        try:
            c = sqlite3.connect(db_path); c.text_factory = lambda b: b.decode(errors="ignore")
            r[0] = c.execute(sql).fetchmany(100); c.close()
        except Exception as ex:
            e[0] = str(ex)
    t = threading.Thread(target=_run, daemon=True); t.start(); t.join(timeout)
    return (None, "TIMEOUT") if t.is_alive() else (r[0], e[0])


def results_match(g, p):
    if g is None or p is None: return False
    def n(rs): return sorted(tuple(str(v).strip().lower() if v is not None else "" for v in r) for r in rs)
    return n(g) == n(p)


def extract_sql(text):
    m = re.search(r"```(?:sql)?\s*(.*?)\s*```", text, re.DOTALL)
    if m:
        s = m.group(1).strip()
        return s[3:].strip() if s.upper().startswith("SQL") else s
    return ""


def qwen_chat(p):
    return f"<|im_start|>user\n{p}<|im_end|>\n<|im_start|>assistant\n"


def llama3_chat(p):
    return (f"<|begin_of_text|><|start_header_id|>user<|end_header_id|>\n\n"
            f"{p}<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n")


def vllm_complete(host, model, prompt, n, temperature, top_p, max_tokens, seed, stop=None):
    try:
        r = requests.post(f"{host}/v1/completions", json={
            "model": model, "prompt": prompt,
            "n": n, "temperature": temperature, "top_p": top_p,
            "max_tokens": max_tokens, "seed": seed,
            "stop": stop or ["<|eot_id|>", "<|im_end|>"],
        }, timeout=300)
        r.raise_for_status()
        return [c["text"].strip() for c in r.json()["choices"]]
    except Exception:
        return []


FIXER_PROMPT_HEADER = (
    "You are a SQL fixer. Given the question, schema, original SQL query, "
    "execution response, and the validator's critique below, output ONLY the corrected "
    "final SQL inside ```sql ... ``` markers.\n\n"
)


def build_fixer_prompt(schema_str, question, evidence, planner_sql, exec_response, critique):
    body = (
        f"database schema:\n{schema_str}\n\n"
        f"Question: {question}\n"
        f"External knowledge: {evidence or 'None'}\n\n"
        f"Generated SQL query: {planner_sql}\n\n"
        f"Execution response:\n{exec_response}\n\n"
    )
    return FIXER_PROMPT_HEADER + body + "\n\nValidator critique:\n" + critique + "\n\nFinal SQL:"


def build_validator_body(schema_str, question, evidence, planner_sql, exec_response):
    return (
        f"Generate feedbacks to fix the following SQL query:\n"
        f"Database Schema:\n{schema_str}\n\n"
        f"Question: {question}\n"
        f"External knowledge: {evidence or 'None'}\n\n"
        f"SQL query: {planner_sql}\n\n"
        f"Execution response:\n{exec_response}\n\n"
        f"Feedback:"
    )


DEFAULT_SEL  = "SELECT.\nNo SELECT critique generated.\nConclude: correct."
DEFAULT_COND = "CONDITION.\nNo CONDITION critique generated.\nConclude: correct."


def process_one(args, q_lower, info, bird_train, seed_offset):
    """Process a single BIRD-train question. Returns list of (prompt, completion) rows."""
    bt = bird_train[info["sid"]]
    db_path = bt.get("db_path") or f"data/train_databases/{bt['db_id']}/{bt['db_id']}.sqlite"
    if not os.path.exists(db_path):
        return ("skip_no_db", [])
    question = bt["question"]
    evidence = bt.get("evidence", "") or ""
    gold_sql = bt["sql"]

    user_msg = info["user_msg"]
    if "Database Schema:" in user_msg:
        schema_str = user_msg.split("Database Schema:", 1)[1].split("Question:", 1)[0].rstrip()
    else:
        schema_str = user_msg

    planning_prompt = user_msg.rstrip() + "\n\nPlanning:"
    plans = vllm_complete(
        args.planner_host, "planner", qwen_chat(planning_prompt),
        n=1, temperature=0.0, top_p=1.0, max_tokens=1024, seed=args.seed + seed_offset,
    )
    if not plans:
        return ("no_planner", [])
    m = re.search(r"Final SQL query:\s*```(?:sql)?\s*(.+?)```", plans[0], re.DOTALL | re.IGNORECASE)
    if m:
        planner_sql = m.group(1).strip()
    else:
        planner_sql = extract_sql(plans[0])
    if not planner_sql:
        return ("no_planner", [])

    with _db_lock:
        gold_res, _ = safe_exec(db_path, gold_sql)
        pred_res, perr = safe_exec(db_path, planner_sql)
    if gold_res is None:
        return ("no_gold", [])
    planner_correct = (not perr) and results_match(gold_res, pred_res)
    exec_response = (f"Error: {perr[:200]}" if perr
                     else f"OK. Result rows (preview): {str(pred_res)[:300]}")

    val_body = build_validator_body(schema_str, question, evidence, planner_sql, exec_response)
    sel_seeded  = val_body + "\nSELECT.\n"
    cond_seeded = val_body + "\nCONDITION.\n"

    sel_outs = vllm_complete(
        args.val_sel_host, "validator", llama3_chat(sel_seeded),
        n=args.K, temperature=args.temperature, top_p=0.9,
        max_tokens=384, seed=args.seed + seed_offset,
    )
    cond_outs = vllm_complete(
        args.val_cond_host, "validator", llama3_chat(cond_seeded),
        n=args.K, temperature=args.temperature, top_p=0.9,
        max_tokens=384, seed=args.seed + seed_offset + 1,
    )
    if not sel_outs and not cond_outs:
        return ("no_val", [])
    sel_outs  = [f"SELECT.\n{c.lstrip()}"   if c else DEFAULT_SEL  for c in sel_outs]
    cond_outs = [f"CONDITION.\n{c.lstrip()}" if c else DEFAULT_COND for c in cond_outs]
    while len(sel_outs)  < args.K: sel_outs.append(DEFAULT_SEL)
    while len(cond_outs) < args.K: cond_outs.append(DEFAULT_COND)

    gold_completion = f"```sql\n{gold_sql}\n```"
    rows = []
    for j in range(args.K):
        s_out, c_out = sel_outs[j], cond_outs[j]
        combined = (
            f"<select>\n{s_out}\n</select>\n\n"
            f"<condition>\n{c_out}\n</condition>\n\n"
            "<join>\nJOIN.\nNone\n</join>\n\n"
            "<order>\nORDER BY.\nNone\n</order>"
        )
        prompt = build_fixer_prompt(schema_str, question, evidence, planner_sql, exec_response, combined)
        rows.append({"prompt": prompt, "completion": gold_completion})

    return ("planner_correct" if planner_correct else "planner_wrong", rows)


def main():
    p = argparse.ArgumentParser()
    p.add_argument("--planner_host",   default="http://localhost:8100")
    p.add_argument("--val_sel_host",   default="http://localhost:8101")
    p.add_argument("--val_cond_host",  default="http://localhost:8104")
    p.add_argument("--K", type=int, default=8)
    p.add_argument("--temperature", type=float, default=1.0)
    p.add_argument("--max_questions", type=int, default=-1, help="-1 = use full dataset (default)")
    p.add_argument("--threads", type=int, default=8, help="concurrent worker threads")
    p.add_argument("--seed", type=int, default=42)
    p.add_argument("--out", required=True)
    args = p.parse_args()

    print("Loading BIRD-train + griffith prompts...", flush=True)
    with open("data/sft_bird_with_evidence_train_text2sql.json") as f:
        bird_train = json.load(f)
    ds_g = load_dataset("griffith-bigdata/sft_text2sql", split="train_sft",
                        cache_dir="/weka/s225250685/Huggingface/hub"
                       ).filter(lambda x: x["model_name"] == "deepseek-reasoner")
    griffith = {}
    for row in ds_g:
        sid = int(row["sample_id"])
        if not (0 <= sid < len(bird_train)): continue
        user_msg = row["messages"][1]["content"]
        q_m = re.search(r"Question:\s*(.+?)(?:\n|$)", user_msg)
        if not q_m: continue
        q = q_m.group(1).strip()
        if q.lower() == bird_train[sid]["question"].strip().lower():
            griffith[q.lower()] = {"user_msg": user_msg, "sid": sid}
    print(f"  griffith: {len(griffith)} questions", flush=True)

    random.seed(args.seed)
    items = list(griffith.items()); random.shuffle(items)

    limit = args.max_questions if args.max_questions > 0 else len(items)
    chunk = items[:limit]

    rows_all = []
    counters = {"planner_correct": 0, "planner_wrong": 0, "no_planner": 0,
                "skip_no_db": 0, "no_gold": 0, "no_val": 0}

    print(f"Processing {limit} questions with {args.threads} threads...", flush=True)
    with ThreadPoolExecutor(max_workers=args.threads) as ex:
        futures = []
        for idx, (q_lower, info) in enumerate(chunk):
            futures.append(ex.submit(process_one, args, q_lower, info, bird_train, idx))
        done = 0
        for fut in as_completed(futures):
            try:
                status, rows = fut.result()
            except Exception as e:
                print(f"  worker exception: {e}", flush=True)
                continue
            counters[status] = counters.get(status, 0) + 1
            rows_all.extend(rows)
            done += 1
            if done % 50 == 0:
                print(f"  [{done}/{limit}] rows={len(rows_all)} "
                      f"ok={counters['planner_correct']} wrong={counters['planner_wrong']} "
                      f"no_planner={counters['no_planner']} skip_db={counters['skip_no_db']} "
                      f"no_gold={counters['no_gold']} no_val={counters['no_val']}", flush=True)

    print(f"\nGenerated {len(rows_all)} fixer SFT rows", flush=True)
    print(f"  {counters}", flush=True)
    if not rows_all:
        print("ERROR: no rows generated"); return

    random.seed(42); random.shuffle(rows_all)
    n_train = int(0.95 * len(rows_all))
    DatasetDict({
        "train": Dataset.from_list(rows_all[:n_train]),
        "test":  Dataset.from_list(rows_all[n_train:]),
    }).save_to_disk(args.out)
    print(f"Saved → {args.out}  train={n_train}  test={len(rows_all) - n_train}", flush=True)


if __name__ == "__main__":
    main()