clean repo without LFS and binaries

.gitattributes

@@ -0,0 +1,36 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.sqlite filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,12 @@
+__pycache__/
+*.pyc
+.DS_Store
+# checkpoints/milestone_before_more_dbs
+checkpoints/best_rlhf_codet5_soft
+checkpoints/best_rlhf_model
+results/
+*.png
+*.pt
+*.bin
+*.safetensors
+*.zip

README.md

@@ -0,0 +1,14 @@
+---
+title: Text2sql Demo
+emoji: 🐨
+colorFrom: yellow
+colorTo: pink
+sdk: gradio
+sdk_version: 6.8.0
+app_file: app.py
+pinned: false
+license: mit
+short_description: 'to show the gradio interface '
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,651 @@
+"""
+GRADIO DEMO UI
+NL → SQL → Result Table
+"""
+
+import gradio as gr
+import pandas as pd
+import re
+import time
+import os
+import torch
+import sys
+import json
+import subprocess
+import base64
+from pathlib import Path
+from typing import Iterator
+import io
+
+import zipfile
+
+MODEL_DIR = "int8_dynamic"
+
+if not os.path.exists(MODEL_DIR):
+    if os.path.exists("int8_model.zip"):
+        print("Extracting model...")
+        with zipfile.ZipFile("int8_model.zip", 'r') as zip_ref:
+            zip_ref.extractall(".")
+    else:
+        raise FileNotFoundError("Model zip not found!")
+# ==========================================
+# 🔥 CUDA MOCK PATCH FOR MAC (MPS) / CPU
+# ==========================================
+if not torch.cuda.is_available():
+    class MockCUDAEvent:
+        def __init__(self, enable_timing=False, blocking=False, interprocess=False):
+            self.t = 0.0
+        def record(self, stream=None):
+            self.t = time.perf_counter()
+        def elapsed_time(self, end_event):
+            return (end_event.t - self.t) * 1000.0 
+
+    torch.cuda.Event = MockCUDAEvent
+    if not hasattr(torch.cuda, 'synchronize'):
+        torch.cuda.synchronize = lambda: None
+
+# ==========================================
+# RELATIVE PATH RESOLUTION (GLOBAL)
+# ==========================================
+try:
+    PROJECT_ROOT = Path(__file__).resolve().parent
+except NameError:
+    PROJECT_ROOT = Path(".").resolve()
+
+if (PROJECT_ROOT / "data" / "database").exists():
+    DB_ROOT = PROJECT_ROOT / "data" / "database"
+else:
+    DB_ROOT = PROJECT_ROOT / "final_databases"
+
+def get_db_path(db_id: str) -> str:
+    path1 = DB_ROOT / db_id / f"{db_id}.sqlite"
+    path2 = DB_ROOT / f"{db_id}.sqlite"
+    return str(path1) if path1.exists() else str(path2)
+
+# ==========================================
+# IMPORTS & ENGINE SETUP
+# ==========================================
+from src.quantized_text2sql_engine import QuantizedText2SQLEngine
+from src.schema_encoder import SchemaEncoder
+
+fallback_adapter = str(PROJECT_ROOT /  "best_rlhf_model_2")
+if not os.path.exists(fallback_adapter):
+    fallback_adapter = str(PROJECT_ROOT /  "sft_adapter_codet5")
+
+adapter_path = os.environ.get("TEXT2SQL_ADAPTER_PATH", fallback_adapter)
+base_model_name = os.environ.get("TEXT2SQL_BASE_MODEL", "Salesforce/codet5-base")
+use_lora_env = os.environ.get("TEXT2SQL_USE_LORA", "true").strip().lower()
+use_lora = use_lora_env not in {"0", "false", "no"}
+
+DEFAULT_QUANT_ARTIFACT = os.environ.get("TEXT2SQL_QUANT_ARTIFACT", str(PROJECT_ROOT /  "int8_dynamic")).strip()
+if not DEFAULT_QUANT_ARTIFACT:
+    DEFAULT_QUANT_ARTIFACT = str(PROJECT_ROOT /  "int8_dynamic")
+
+_ENGINE_CACHE = {}
+_QUERY_LOG = []  
+_PERF_LOG = []   
+_SUCCESS_LOG = []  
+
+_OP_STATS = {
+    "SELECT": {"ok": 0, "fail": 0}, "WHERE": {"ok": 0, "fail": 0}, "JOIN": {"ok": 0, "fail": 0},
+    "GROUP_BY": {"ok": 0, "fail": 0}, "ORDER_BY": {"ok": 0, "fail": 0}, "HAVING": {"ok": 0, "fail": 0}, "LIMIT": {"ok": 0, "fail": 0},
+}
+
+def get_quant_engine(artifact_dir: str, use_constrained: bool, exec_workers: int = 8, use_cache: bool = True):
+    key = (artifact_dir, bool(use_constrained), int(exec_workers), bool(use_cache))
+    if key not in _ENGINE_CACHE:
+        try:
+            _ENGINE_CACHE[key] = QuantizedText2SQLEngine(artifact_dir, device="cpu", use_constrained=bool(use_constrained), exec_workers=int(exec_workers), use_cache=bool(use_cache))
+        except TypeError:
+            _ENGINE_CACHE[key] = QuantizedText2SQLEngine(artifact_dir)
+    return _ENGINE_CACHE[key]
+
+try:
+    quant_engine = get_quant_engine(DEFAULT_QUANT_ARTIFACT, use_constrained=False, exec_workers=8, use_cache=True)
+except Exception:
+    quant_engine = None
+
+schema_encoder = SchemaEncoder(DB_ROOT)
+
+SAMPLES = [
+    ("Show 10 distinct employee first names.", "chinook_1"), ("Which artist has the most albums?", "chinook_1"),
+    ("List all the tracks that belong to the 'Rock' genre.", "chinook_1"), ("What are the names of all the cities?", "flight_1"),
+    ("Find the flight number and cost of the cheapest flight.", "flight_1"), ("List the airlines that fly out of New York.", "flight_1"),
+    ("Which campus was opened between 1935 and 1939?", "csu_1"), ("Count the number of students in each department.", "college_2"),
+    ("List the names of all clubs.", "club_1"), ("How many members does each club have?", "club_1"),
+    ("Show the names of all cinemas.", "cinema"), ("Which cinema has the most screens?", "cinema")
+]
+SAMPLE_QUESTIONS = [q[0] for q in SAMPLES]
+
+def explain_sql(sql):
+    if not sql: return ""
+    explanation = "This SQL query retrieves information from the database."
+    sql_lower = sql.lower()
+    if "join" in sql_lower: explanation += "\n• It combines data from multiple tables using JOIN."
+    if "where" in sql_lower: explanation += "\n• It filters rows using a WHERE condition."
+    if "group by" in sql_lower: explanation += "\n• It groups results using GROUP BY."
+    if "order by" in sql_lower: explanation += "\n• It sorts the results using ORDER BY."
+    if "limit" in sql_lower: explanation += "\n• It limits the number of returned rows."
+    return explanation
+
+def sql_ops(sql: str) -> list[str]:
+    s = (sql or "").lower()
+    ops = ["SELECT"] 
+    if " where " in f" {s} ": ops.append("WHERE")
+    if " join " in f" {s} ": ops.append("JOIN")
+    if " group by " in f" {s} ": ops.append("GROUP_BY")
+    if " order by " in f" {s} ": ops.append("ORDER_BY")
+    if " having " in f" {s} ": ops.append("HAVING")
+    if " limit " in f" {s} ": ops.append("LIMIT")
+    return ops
+
+def classify_error(sql: str, error_msg: str | None = None, *, timed_out: bool = False):
+    s = (sql or "").lower()
+    m = (error_msg or "").lower()
+    if timed_out or "interrupted" in m or "timeout" in m: return "timeout"
+    if not s.strip().startswith(("select", "with")): return "syntax_error"
+    if " join " in f" {s} " and " on " not in f" {s} ": return "missing_join"
+    if " where " in f" {s} " and not any(op in s for op in ["=", ">", "<", " in ", " like ", " between ", " is null", " is not null"]): return "wrong_where"
+    if ("is null" in s or "is not null" in s) and ("no such column" in m or "misuse" in m): return "null_handling"
+    if "no such table" in m: return "missing_table"
+    if "no such column" in m: return "missing_column"
+    if "ambiguous column name" in m: return "ambiguous_column"
+    if "datatype mismatch" in m or "type mismatch" in m: return "type_mismatch"
+    if "misuse of aggregate" in m or "misuse of aggregate function" in m: return "wrong_aggregation"
+    if "syntax error" in m: return "syntax_error"
+    if "near" in m and "syntax error" in m: return "syntax_error"
+    if "runtime" in m or "constraint failed" in m: return "runtime_error"
+    return "other"
+
+def get_hint(error_type):
+    hints = {
+        "missing_join": "Check JOIN conditions between tables.", "wrong_aggregation": "Use proper aggregation like avg(column).",
+        "wrong_where": "Check WHERE condition syntax.", "syntax_error": "Ensure SQL starts with SELECT.",
+        "missing_table": "Use only tables from the provided schema.", "missing_column": "Use only columns from the provided schema.",
+        "ambiguous_column": "Disambiguate by using table.column.", "timeout": "Query took too long; simplify joins.", "other": "Review SQL logic."
+    }
+    return hints.get(error_type, "Review query.")
+
+def is_relevant_to_schema(question, db_id):
+    try: raw_schema = schema_encoder.structured_schema(db_id).lower()
+    except: return True 
+    schema_words = set(re.findall(r'[a-z0-9_]+', raw_schema))
+    q_words = re.findall(r'[a-z0-9_]+', question.lower())
+    stop_words = {"show", "list", "all", "what", "is", "the", "how", "many", "count", "find", "get", "me", "a", "an", "of", "in", "for", "from", "with", "which", "are", "there", "give", "tell", "details", "info", "data", "everything"}
+    meaningful_q_words = [w for w in q_words if w not in stop_words and not w.isdigit()]
+    if not meaningful_q_words: return True 
+    for word in meaningful_q_words:
+        singular_word = word[:-1] if word.endswith('s') else word
+        if word in schema_words or singular_word in schema_words: return True
+    return False 
+
+def run_query(method, sample_q, custom_q, db_id):
+    # HARDCODED INFERENCE DEFAULTS
+    quant_artifact_dir = DEFAULT_QUANT_ARTIFACT
+    use_constrained_decoding = False
+    gen_beams = 4
+    gen_max_new_tokens = 120
+    exec_timeout_s = 2.0
+    exec_workers = 8
+    exec_cache_on = True
+
+    def _log(error_type: str, *, question: str, db_id_val: str, sql: str = "", error_msg: str = "") -> None:
+        _QUERY_LOG.append({"t": time.time(), "db_id": str(db_id_val), "question": str(question), "sql": str(sql), "error_type": str(error_type), "error_msg": str(error_msg)})
+
+    def _perf_log(payload: dict) -> None:
+        _PERF_LOG.append(payload)
+        if len(_PERF_LOG) > 1000: del _PERF_LOG[:200]
+
+    raw_question = sample_q if method == "💡 Pick a Sample" else custom_q
+
+    # 1. EMPTY CHECK
+    if not raw_question or str(raw_question).strip() == "":
+        return "-- No input provided", pd.DataFrame(columns=["Warning"]), "⚠️ Please enter a question."
+    if not db_id or str(db_id).strip() == "":
+        return "-- No database selected", pd.DataFrame(columns=["Warning"]), "⚠️ Please select a database."
+
+    typo_corrections = [(r'\bshaw\b', 'show'), (r'\bshw\b', 'show'), (r'\bsho\b', 'show'), (r'\blsit\b', 'list'), (r'\blis\b', 'list'), (r'\bfidn\b', 'find'), (r'\bfnd\b', 'find'), (r'\bgte\b', 'get')]
+    question = str(raw_question)
+    for bad, good in typo_corrections: question = re.sub(bad, good, question, flags=re.IGNORECASE)
+    q_lower = question.strip().lower()
+
+    # 🔥 FIX 1: STRICTER GIBBERISH FILTER
+    # Blocks single-word nonsensical inputs like "wdasefgbn"
+    if len(q_lower.split()) < 2:
+        _log("gibberish", question=question, db_id_val=str(db_id), error_msg="gibberish filtered")
+        return "-- Input Blocked", pd.DataFrame(columns=["Warning"]), "⚠️ Please enter a clear, meaningful natural language question (more than one word)."
+
+    # 3. DML (DELETE/UPDATE) BLOCKER
+    if re.search(r'\b(delete|update|insert|drop|alter|truncate)\b', q_lower):
+        _log("blocked_dml", question=question, db_id_val=str(db_id), error_msg="DML blocked")
+        return "-- ❌ BLOCKED: Data Modification", pd.DataFrame(columns=["Security Alert"]), "🛑 Security Alert: Modifying or deleting data is strictly prohibited."
+
+    # 4. OUT OF DOMAIN
+    if not is_relevant_to_schema(question, db_id):
+        _log("out_of_domain", question=question, db_id_val=str(db_id), error_msg="out of domain")
+        return "-- ❌ BLOCKED: Out of Domain", pd.DataFrame(columns=["Domain Alert"]), f"🛑 Relevance Alert: I don't see anything related to your question in the '{db_id}' schema."
+
+    start_time = time.time()
+    t0 = time.perf_counter()
+    ui_warnings = ""
+
+    try:
+        engine = quant_engine
+        if quant_artifact_dir and str(quant_artifact_dir).strip():
+            engine = get_quant_engine(str(quant_artifact_dir).strip(), bool(use_constrained_decoding), exec_workers=int(exec_workers), use_cache=bool(exec_cache_on))
+        if engine is None: raise RuntimeError("Quantized engine is not available.")
+        try:
+            result = engine.ask(question, str(db_id), num_beams=int(gen_beams), max_new_tokens=int(gen_max_new_tokens), timeout_s=float(exec_timeout_s))
+        except TypeError:
+            result = engine.ask(question, str(db_id))
+
+    except Exception as e:
+        _log("backend_crash", question=question, db_id_val=str(db_id), error_msg=str(e))
+        return f"-- ❌ BACKEND CRASH\n-- {str(e)}", pd.DataFrame(columns=["Error Status"]), f"❌ CRITICAL BACKEND CRASH:\n{str(e)}"
+
+    final_sql = str(result.get("sql", ""))
+    model_sql = final_sql
+        
+    # 🔥 FIX 2: ADVANCED SEMANTIC LIMIT CLEANER
+    num_match = re.search(r'\b(?:show|list|top|limit|get|first|last|sample|of)\s+(?:[a-zA-Z_]+\s+)?(\d+)\b', q_lower)
+    if not num_match and q_lower.startswith(("show", "list", "get")):
+        num_match = re.search(r'\b(\d+)\b', q_lower)
+
+    if num_match and final_sql:
+        limit_val = num_match.group(1)
+        
+        # 1. Strip hallucinated count(*) = X in WHERE clauses
+        final_sql = re.sub(rf"(?i)\s*(?:where|having|and)?\s*count\s*\(\s*\*\s*\)\s*=\s*{limit_val}", "", final_sql)
+        
+        # 2. Strip hallucinated WHERE column = '5' (Fixes "show firstname of 5 employees")
+        final_sql = re.sub(rf"(?i)\s*(?:where|and)\s+[a-zA-Z0-9_.]+\s*=\s*['\"]?{limit_val}['\"]?", "", final_sql)
+        final_sql = re.sub(r"(?i)\s*where\s*$", "", final_sql) # Cleanup empty where
+        final_sql = re.sub(r"(?i)\s*where\s+(group by|order by|limit)", r" \1", final_sql) # Cleanup dangling where before other clauses
+        
+        # 3. Strip unwarranted complex Groupings
+        agg_kws = ["most", "top", "highest", "lowest", "count", "many", "group", "frequent", "popular"]
+        if not any(k in q_lower for k in agg_kws):
+            final_sql = re.sub(r"(?i)\s*group by\s+[a-zA-Z0-9_.]+\s*order by\s+count\(\*\)\s*(?:desc|asc)?", "", final_sql)
+            final_sql = re.sub(r"(?i)\s*order by\s+count\(\*\)\s*(?:desc|asc)?", "", final_sql)
+            final_sql = re.sub(r"(?i),\s*count\(\*\)", "", final_sql)
+            final_sql = re.sub(r"(?i)count\(\*\)\s*,", "", final_sql)
+        
+        if "group by" in final_sql.lower() and not re.search(r'(?i)\b(count|sum|avg|max|min)\b\(', final_sql):
+            final_sql = re.sub(r"(?i)\s*group by\s+[a-zA-Z0-9_.]+", "", final_sql)
+            
+        # 4. Append limits safely
+        if "limit" not in final_sql.lower():
+            final_sql = f"{final_sql.strip().rstrip(';')} LIMIT {limit_val}"
+
+    # =====================================================================
+    # 🔥 ROBUST SQLITE EXECUTION 
+    # =====================================================================
+    from src.sql_validator import validate_sql_schema
+    db_path = get_db_path(str(db_id))
+    
+    try: strict_valid, _ = validate_sql_schema(final_sql, db_path)
+    except Exception: strict_valid = False
+
+    error_msg = None
+    rows, cols = [], []
+    sqlite_success = False
+
+    if final_sql and engine is not None:
+        try:
+            rows, cols = engine._execute_one(final_sql, db_path, timeout_s=float(exec_timeout_s))
+            sqlite_success = True
+        except Exception as e:
+            error_msg = str(e)
+            sqlite_success = False
+
+    if not sqlite_success and model_sql and model_sql != final_sql and engine is not None:
+        try:
+            alt_rows, alt_cols = engine._execute_one(model_sql, db_path, timeout_s=float(exec_timeout_s))
+            final_sql = model_sql
+            rows, cols = alt_rows, alt_cols
+            sqlite_success = True
+            error_msg = None
+        except Exception: pass
+
+    valid = sqlite_success
+
+    if error_msg or not valid:
+        et = classify_error(final_sql, str(error_msg or ""), timed_out=("interrupted" in str(error_msg or "").lower()))
+        _log(et, question=str(question), db_id_val=str(db_id), sql=str(final_sql), error_msg=str(error_msg or "Execution failed"))
+
+    latency = round(time.time() - start_time, 3)
+    t1 = time.perf_counter()
+    
+    engine_stats_after = engine.stats() if hasattr(engine, 'stats') else {}
+
+    perf = {
+        "db_id": str(db_id), "use_constrained_decoding": bool(use_constrained_decoding), "num_beams": int(gen_beams),
+        "latency_total_ms": round((t1 - t0) * 1000.0, 2), "constraint_ok": bool(strict_valid), "has_error": bool(error_msg),
+        "exec_cache_hit_rate": float(engine_stats_after.get("exec_cache_hit_rate", 0.0) or 0.0),
+    }
+    _perf_log(perf)
+
+    window = _PERF_LOG[-50:]
+    avg_ms = sum(float(x.get("latency_total_ms", 0.0) or 0.0) for x in window) / len(window) if window else 0.0
+    constraint_rate = sum(1 for x in window if x.get("constraint_ok")) / len(window) if window else 0.0
+
+    perf_block = (
+        "\n\n---\nPerformance (task impact)\n"
+        f"- Total latency (ms): {perf['latency_total_ms']}\n"
+        f"- Strict Python Validator OK (Task 3): {perf['constraint_ok']}\n"
+        f"- Exec cache hit-rate (Task 1/5): {round(perf['exec_cache_hit_rate'], 3)}\n"
+        f"- Rolling avg latency last 50 (ms): {round(avg_ms, 2)}\n"
+        f"- Rolling constraint rate last 50: {round(constraint_rate, 3)}\n"
+    )
+
+    if error_msg or not valid:
+        display_sql = final_sql if final_sql.strip() else "-- ❌ INVALID SQL"
+        explanation = f"{ui_warnings}❌ Error Details:\n\n"
+        if error_msg: explanation += f"{error_msg}\n\n"
+        
+        error_type = classify_error(final_sql, str(error_msg or ""))
+        explanation += f"Error Type: {error_type}\nHint: {get_hint(error_type)}"
+        explanation += perf_block
+        ops = sql_ops(final_sql)
+        for op in ops:
+            if op in _OP_STATS: _OP_STATS[op]["fail"] += 1
+        return display_sql, pd.DataFrame(columns=["Execution Notice"]), explanation
+
+    safe_cols = cols if cols else ["Result"]
+    explanation = f"{ui_warnings}✅ Query executed successfully\n\nRows returned: {len(rows)}\nExecution Time: {latency} sec\n\n{explain_sql(final_sql)}{perf_block}"
+    
+    ops = sql_ops(final_sql)
+    for op in ops:
+        if op in _OP_STATS: _OP_STATS[op]["ok"] += 1
+    _SUCCESS_LOG.append({"t": time.time(), "db_id": str(db_id), "question": question, "sql": final_sql, "ops": ops})
+
+    limit_match = re.search(r'LIMIT\s+(\d+)', final_sql, re.IGNORECASE)
+    if limit_match and len(rows) < int(limit_match.group(1)):
+        explanation += f"\n\nℹ️ Query allowed up to {int(limit_match.group(1))} rows but only {len(rows)} matched."
+
+    return final_sql, pd.DataFrame(rows, columns=safe_cols), explanation
+
+def _run_cmd(cmd: list[str], env: dict | None = None) -> str:
+    run_env = (env or os.environ.copy()).copy()
+    project_root = str(PROJECT_ROOT)
+    run_env["PYTHONPATH"] = project_root + (os.pathsep + run_env["PYTHONPATH"] if run_env.get("PYTHONPATH") else "")
+    res = subprocess.run(cmd, capture_output=True, text=True, env=run_env, cwd=project_root)
+    out = (res.stdout or "") + ("\n" + res.stderr if res.stderr else "")
+    return out.strip()
+
+def task1_benchmark(n_rollouts: int, max_workers: int) -> Iterator[tuple[str, str]]:
+    project_root = str(PROJECT_ROOT)
+    env = os.environ.copy()
+    env["PYTHONPATH"] = project_root + (os.pathsep + env["PYTHONPATH"] if env.get("PYTHONPATH") else "")
+    env.setdefault("MPLBACKEND", "Agg")
+    env.setdefault("MPLCONFIGDIR", "/tmp/mplconfig")
+    try: os.makedirs(env["MPLCONFIGDIR"], exist_ok=True)
+    except Exception: pass
+
+    cmd = [sys.executable, "-u", "scripts/benchmark_parallel_reward.py", "--n", str(int(n_rollouts)), "--max-workers", str(int(max_workers)), "--skip-profile"]
+    proc = subprocess.Popen(cmd, cwd=project_root, env=env, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, bufsize=1)
+    last_yield = time.perf_counter()
+    lines: list[str] = []
+    yield "Running Task 1 benchmark...\n", "<i>Running...</i>"
+
+    assert proc.stdout is not None
+    for line in proc.stdout:
+        lines.append(line)
+        now = time.perf_counter()
+        if now - last_yield >= 0.5:
+            last_yield = now
+            yield "".join(lines[-200:]).strip(), "<i>Running...</i>"
+
+    proc.wait()
+    out = "".join(lines).strip()
+
+    plot_path = str(PROJECT_ROOT / "results" / "task1_plot.png")
+    if os.path.exists(plot_path):
+        try:
+            b64 = base64.b64encode(Path(plot_path).read_bytes()).decode("ascii")
+            yield out, f"<img src='data:image/png;base64,{b64}' style='max-width: 100%; border: 1px solid #e2e8f0; border-radius: 8px;' />"
+            return
+        except Exception:
+            yield out, f"<pre>{plot_path}</pre>"
+            return
+
+    yield out, "<i>No plot generated</i>"
+
+def task2_dashboard_structured():
+    if not _QUERY_LOG:
+        empty_counts = pd.DataFrame(columns=["error_type", "count", "hint"])
+        empty_recent = pd.DataFrame(columns=["time", "db_id", "error_type", "question", "error_msg"])
+        return empty_counts, empty_recent, gr.update(choices=[], value=None)
+
+    counts = {}
+    for r in _QUERY_LOG[-1000:]:
+        k = r.get("error_type") or "other"
+        counts[k] = counts.get(k, 0) + 1
+    rows = [{"error_type": k, "count": int(v), "hint": get_hint(k)} for k, v in sorted(counts.items(), key=lambda x: (-x[1], x[0]))]
+    counts_df = pd.DataFrame(rows)
+
+    recent = []
+    for r in _QUERY_LOG[-100:]:
+        ts = r.get("t")
+        try: ts_s = time.strftime("%H:%M:%S", time.localtime(float(ts))) if ts else ""
+        except Exception: ts_s = ""
+        recent.append({"time": ts_s, "db_id": r.get("db_id", ""), "error_type": r.get("error_type", ""), "question": r.get("question", ""), "error_msg": r.get("error_msg", "")})
+    recent_df = pd.DataFrame(recent)
+
+    choices = [str(x["error_type"]) for x in rows]
+    default = choices[0] if choices else None
+    return counts_df, recent_df, gr.update(choices=choices, value=default)
+
+def task2_error_examples(error_type: str) -> str:
+    if not error_type: return ""
+    hint = get_hint(error_type)
+    matches = [r for r in reversed(_QUERY_LOG) if (r.get("error_type") or "") == str(error_type)][:3]
+    if not matches: return f"Error type: {error_type}\nHint: {hint}\n\nNo examples yet."
+    out = [f"Error type: {error_type}", f"Hint: {hint}", ""]
+    for i, r in enumerate(matches, 1):
+        out.extend([f"Example {i}", f"DB: {r.get('db_id','')}", f"Q: {r.get('question','')}", f"SQL: {r.get('sql','')}", f"Msg: {r.get('error_msg','')}", ""])
+    return "\n".join(out).strip()
+
+def _plot_op_stats_html() -> str:
+    try:
+        import matplotlib.pyplot as plt
+        labels = list(_OP_STATS.keys())
+        oks = [int(_OP_STATS[k]["ok"]) for k in labels]
+        fails = [int(_OP_STATS[k]["fail"]) for k in labels]
+
+        fig, ax = plt.subplots(figsize=(9, 3.5))
+        x = list(range(len(labels)))
+        ax.bar(x, oks, label="ok", color="#16a34a")
+        ax.bar(x, fails, bottom=oks, label="fail", color="#dc2626")
+        ax.set_xticks(x)
+        ax.set_xticklabels(labels, rotation=30, ha="right")
+        ax.set_title("Success/Failure by SQL operation")
+        ax.legend()
+        fig.tight_layout()
+
+        buf = io.BytesIO()
+        fig.savefig(buf, format="png", dpi=160)
+        plt.close(fig)
+        b64 = base64.b64encode(buf.getvalue()).decode("ascii")
+        return f"<img src='data:image/png;base64,{b64}' style='max-width: 100%; border: 1px solid #e2e8f0; border-radius: 8px;' />"
+    except Exception as e: return f"<pre>Plot error: {e}</pre>"
+
+def task2_ops_table():
+    rows = []
+    for op, d in _OP_STATS.items():
+        ok = int(d.get("ok", 0))
+        fail = int(d.get("fail", 0))
+        total = ok + fail
+        rows.append({"op": op, "ok": ok, "fail": fail, "total": total, "success_rate": (ok / total) if total else 0.0})
+    return pd.DataFrame(rows), _plot_op_stats_html()
+
+def run_adversarial_suite():
+    quant_artifact_dir = DEFAULT_QUANT_ARTIFACT
+    use_constrained = False
+    gen_beams = 4
+    gen_max_new = 120
+    exec_timeout_s = 2.0
+    exec_workers = 8
+    exec_cache_on = True
+
+    engine = quant_engine
+    if quant_artifact_dir and str(quant_artifact_dir).strip():
+        engine = get_quant_engine(str(quant_artifact_dir).strip(), bool(use_constrained), exec_workers=int(exec_workers), use_cache=bool(exec_cache_on))
+    if engine is None: return pd.DataFrame(columns=["name", "db_id", "expected", "got", "status"]), "Engine unavailable."
+
+    ADVERSARIAL_CASES = [
+        {"name": "Missing JOIN", "db_id": "chinook_1", "question": "List track names and their artist names.", "expected": "missing_join"},
+        {"name": "Wrong WHERE", "db_id": "flight_1", "question": "Show flights that cost more than 500.", "expected": "wrong_where"},
+        {"name": "NULL handling", "db_id": "student_1", "question": "List students with no advisor.", "expected": "null_handling"},
+        {"name": "Type mismatch", "db_id": "store_1", "question": "List orders where order_id equals 'abc'.", "expected": "type_mismatch"},
+    ]
+
+    out_rows = []
+    for c in ADVERSARIAL_CASES:
+        dbid = c["db_id"]
+        q = c["question"]
+        expected = c.get("expected", "")
+        try:
+            try: res = engine.ask(q, dbid, num_beams=int(gen_beams), max_new_tokens=int(gen_max_new), timeout_s=float(exec_timeout_s))
+            except TypeError: res = engine.ask(q, dbid)
+            sql = str(res.get("sql", "") or "")
+            err = res.get("error", None)
+            got = classify_error(sql, str(err or "")) if err else ""
+            status = "ok" if not err else "fail"
+        except Exception as e:
+            got, status = "backend_crash", "crash"
+        out_rows.append({"name": c["name"], "db_id": dbid, "expected": expected, "got": got, "status": status})
+
+    df = pd.DataFrame(out_rows)
+    return df, json.dumps({"summary": df["status"].value_counts().to_dict()}, indent=2)
+
+def toggle_input_method(method, current_sample):
+    if method == "💡 Pick a Sample":
+        db = next((db for q, db in SAMPLES if q == current_sample), "chinook_1")
+        return (gr.update(visible=True), gr.update(visible=False), gr.update(visible=False), gr.update(value=db, interactive=False))
+    return (gr.update(visible=False), gr.update(visible=True), gr.update(visible=True), gr.update(interactive=True))
+
+def load_sample(selected_question):
+    if not selected_question: return gr.update()
+    return gr.update(value=next((db for q, db in SAMPLES if q == selected_question), "chinook_1"))
+
+def clear_inputs():
+    return (gr.update(value="💡 Pick a Sample"), gr.update(value=SAMPLE_QUESTIONS[0], visible=True), gr.update(visible=False), gr.update(value="", visible=False), gr.update(value="chinook_1", interactive=False), "", pd.DataFrame(), "")
+
+def update_schema(db_id):
+    if not db_id: return ""
+    try:
+        raw_schema = schema_encoder.structured_schema(db_id)
+        html_output = "<div style='max-height: 250px; overflow-y: auto; background: #f8fafc; padding: 12px; border-radius: 8px; border: 1px solid #e2e8f0; font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace; font-size: 0.9em; line-height: 1.6;'>"
+        for line in raw_schema.strip().split('\n'):
+            line = line.strip()
+            if not line: continue
+            match = re.search(r'^([a-zA-Z0-9_]+)\s*\((.*)\)', line)
+            if match: html_output += f"<div style='margin-bottom: 8px;'><strong style='color: #0f172a; font-size: 1.05em; font-weight: 800;'>{match.group(1).upper()}</strong> <span style='color: #64748b;'>( {match.group(2).lower()} )</span></div>"
+            else: html_output += f"<div style='color: #475569;'>{line}</div>"
+        html_output += "</div>"
+        return html_output
+    except Exception as e: return f"<div style='color: red;'>Error loading schema: {str(e)}</div>"
+
+# =========================
+# UI LAYOUT
+# =========================
+with gr.Blocks(title="Text-to-SQL RLHF") as demo:
+    gr.HTML("""
+        <div style="text-align: center; background-color: #e0e7ff; padding: 20px; border-radius: 10px; margin-bottom: 20px; border: 1px solid #c7d2fe;">
+            <h1 style="color: #3730a3; margin-top: 0; margin-bottom: 10px; font-size: 2.2em;"> Text-to-SQL using RLHF + Execution Reward</h1>
+            <p style="color: #4f46e5; font-size: 1.1em; margin: 0;">Convert Natural Language to SQL, strictly validated and safely executed on local SQLite databases.</p>
+        </div>
+    """)
+
+    DBS = sorted(["flight_1", "student_assessment", "store_1", "bike_1", "book_2", "chinook_1", "academic", "aircraft", "car_1", "cinema", "club_1", "csu_1", "college_1", "college_2", "company_1", "company_employee", "customer_complaints", "department_store", "employee_hire_evaluation", "museum_visit", "products_for_hire", "restaurant_1", "school_finance", "shop_membership", "small_bank_1", "student_1", "tvshow", "voter_1", "world_1"])
+
+    with gr.Tabs():
+        with gr.Tab("Inference"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("### 1. Configuration & Input")
+                    input_method = gr.Radio(choices=["💡 Pick a Sample", "✍️ Type my own"], value="💡 Pick a Sample", label="How do you want to ask?")
+                    sample_dropdown = gr.Dropdown(choices=SAMPLE_QUESTIONS, value=SAMPLE_QUESTIONS[0], label="Select a Sample Question", info="The database will be selected automatically.", visible=True)
+                    type_own_warning = gr.Markdown("**⚠️ Please select a Database first, then type your custom question below:**", visible=False)
+                    gr.Markdown("---")
+                    db_id = gr.Dropdown(choices=DBS, value="chinook_1", label="Select Database", interactive=False)
+                    custom_question = gr.Textbox(label="Ask your Custom Question", placeholder="Type your own question here...", lines=3, visible=False)
+
+                    gr.Markdown("#### 📋 Database Structure")
+                    gr.HTML("<p style='font-size: 0.85em; color: #64748b; margin-top: -10px; margin-bottom: 5px;'>Use these exact names! Table names are <strong>Dark</strong>, Column names are <span style='color: #94a3b8;'>Light</span>.</p>")
+                    schema_display = gr.HTML(value=update_schema("chinook_1"))
+
+                    with gr.Row():
+                        clear_btn = gr.Button("🗑️ Clear", variant="secondary")
+                        run_btn = gr.Button(" Generate & Run SQL", variant="primary")
+
+                with gr.Column(scale=2):
+                    gr.Markdown("### 2. Execution Results")
+                    final_sql = gr.Code(language="sql", label="Final Executed SQL")
+                    result_table = gr.Dataframe(label="Query Result Table", interactive=False, wrap=True)
+                    explanation = gr.Textbox(label="AI Explanation + Execution Details", lines=8)
+
+        with gr.Tab("Diagnostics"):
+            gr.Markdown("## Diagnostics & Telemetry")
+            
+            with gr.Accordion("Task 1: Parallel Reward Benchmark", open=False):
+                gr.Markdown("*(Simulates the heavy RLHF training workload by running hundreds of complex SQL queries concurrently to test SQLite multi-threading performance.)*")
+                t1_n = gr.Number(value=20, precision=0, label="Rollouts (n)")
+                t1_workers = gr.Number(value=10, precision=0, label="Max workers")
+                t1_run = gr.Button("Run Task 1 benchmark")
+                t1_out = gr.Textbox(label="Output", lines=12)
+                t1_plot = gr.HTML(label="Plot (if generated)")
+                t1_run.click(fn=task1_benchmark, inputs=[t1_n, t1_workers], outputs=[t1_out, t1_plot])
+
+            with gr.Accordion("Task 2: Error Dashboard", open=True):
+                gr.Markdown("*(Live telemetry tracking the most common SQL failures. Populates automatically when queries fail in the Inference tab.)*")
+                t2_refresh = gr.Button("Refresh dashboard")
+                t2_counts = gr.Dataframe(label="Error counts", interactive=False, wrap=True)
+                t2_recent = gr.Dataframe(label="Recent errors", interactive=False, wrap=True)
+                t2_type = gr.Dropdown(choices=[], value=None, label="Select error type")
+                t2_examples = gr.Textbox(label="Examples + hint", lines=10)
+
+                t2_refresh.click(fn=task2_dashboard_structured, inputs=[], outputs=[t2_counts, t2_recent, t2_type])
+                t2_type.change(fn=task2_error_examples, inputs=[t2_type], outputs=[t2_examples])
+
+            with gr.Accordion("Task 2: Clause Telemetry", open=False):
+                gr.Markdown("*(Analyzes which specific SQL clauses—SELECT, WHERE, JOIN, etc.—are most prone to errors during natural language generation.)*")
+                t2_ops_refresh = gr.Button("Refresh SQL-op stats")
+                t2_ops_tbl = gr.Dataframe(label="Success/failure by op", interactive=False, wrap=True)
+                t2_ops_plot = gr.HTML(label="Op plot")
+                t2_ops_refresh.click(fn=task2_ops_table, inputs=[], outputs=[t2_ops_tbl, t2_ops_plot])
+
+            with gr.Accordion("Task 2: Adversarial Suite", open=False):
+                gr.Markdown("*(Runs a predefined set of tricky, out-of-distribution natural language questions designed to confuse the model, testing its robustness and constraint mapping.)*")
+                adv_run = gr.Button("Run adversarial suite")
+                adv_out = gr.Dataframe(label="Adversarial results", interactive=False, wrap=True)
+                adv_summary = gr.Textbox(label="Summary", lines=8)
+                adv_run.click(fn=run_adversarial_suite, inputs=[], outputs=[adv_out, adv_summary])
+
+
+    # EVENT BINDING: The .then() forces the diagnostic tab to update live in the background!
+    input_method.change(fn=toggle_input_method, inputs=[input_method, sample_dropdown], outputs=[sample_dropdown, type_own_warning, custom_question, db_id])
+    sample_dropdown.change(fn=load_sample, inputs=[sample_dropdown], outputs=[db_id])
+    db_id.change(fn=update_schema, inputs=[db_id], outputs=[schema_display])
+    
+    run_btn.click(
+        fn=run_query, 
+        inputs=[input_method, sample_dropdown, custom_question, db_id], 
+        outputs=[final_sql, result_table, explanation]
+    ).then(
+        fn=task2_dashboard_structured, inputs=[], outputs=[t2_counts, t2_recent, t2_type]
+    ).then(
+        fn=task2_ops_table, inputs=[], outputs=[t2_ops_tbl, t2_ops_plot]
+    )
+    
+    clear_btn.click(fn=clear_inputs, inputs=[], outputs=[input_method, sample_dropdown, type_own_warning, custom_question, db_id, final_sql, result_table, explanation])
+
+if __name__ == "__main__":
+    share = os.environ.get("GRADIO_SHARE", "0").strip() in {"1", "true", "True", "yes", "Y"}
+    server_name = os.environ.get("GRADIO_SERVER_NAME", "127.0.0.1")
+    demo.launch(
+        share=share,
+        server_name=server_name,
+        # theme=gr.themes.Soft()
+    )

final_databases/academic.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9ca59ebaa830731011a222885480e4b9f9d49c3e36849dee25b769fb74f296c2
+size 122880

final_databases/activity_1.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9e32fff45bbcf0d0f4304bf646d52c651063f3c128d974d72cb751d5cf105c83
+size 24576

final_databases/aircraft.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2b92973e99d8348a324e318fd4d62645ebe428e7346b51277e78385d1ad3b1ef
+size 45056

final_databases/allergy_1.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d3ce73d649463526f6f6b04f457f40a778c8c192b8451cc2837437dc7a18a207
+size 20480

final_databases/apartment_rentals.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:42121c39f5132a9df8eea63ff01d4cdb446144e020079c073a58a949f9d40e34
+size 53248

final_databases/architecture.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ea405f3511d01a3f7d688fbec2b214b7fb82ed9f5795f424a0e1a655f704d406
+size 28672

final_databases/assets_maintenance.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:847af85ebcc94f6be06e06f5bd8a22500bd4e208a29a3e732eed13c72eda43c1
+size 69632

final_databases/battle_death.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:12569f4493a9655639c4ea86ba4bd8a4ea6411e1b8ae0e1fdf3d6a995344265d
+size 28672

final_databases/behavior_monitoring.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:689af3fbf11164f50d02f4a75ff6c9a7fb419938de861a1c26477ae577c1443a
+size 65536

final_databases/bike_1.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f5ae0e24e3a9d860a38ec6256828e3b9e37691c80931ef554adc202f8eb2950c
+size 1785856

final_databases/body_builder.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:76221ea59be7c46e0712e308dd9f0527c63b71669186b2e97c23df78ab974108
+size 20480

final_databases/book_2.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8b0bffbf8805809461b29573dc55782d810cc688af526e28088b299326d72407
+size 20480

final_databases/browser_web.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ced1ee75f531e02adf66f387ced5997f416653adbcf519c037813aa69599f17a
+size 28672

final_databases/candidate_poll.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7df58984f9d9796538716294ba0dda9f48a4a54907f03a3859285aa4b5cf8dc5
+size 20480

final_databases/car_1.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9d851e396e02997a1de073ae982fe1e4b1769fdffce2fac6e325857a3a938709
+size 65536

final_databases/chinook_1.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:70b3eb8c3ffb5351eb7943e3bf05b693a5397c22d200ff022ef99e2ca18ab7b9
+size 901120

final_databases/cinema.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9fbcc850e33d813a792417291ddfb1cebc4a31716621284ed28ef53df360a14e
+size 28672

final_databases/city_record.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:112ff582c4552d8b35a0a70205fb7d8562f18c6a231b86fe8ac19beebebc4d4b
+size 36864

final_databases/climbing.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f2d3893fc5e79943ffad120b59522358b90ef077a989fb40c7c5fbbe16bfccd9
+size 20480

final_databases/club_1.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8c2fc993225d6ed604f7cb95146e025e5d71777f9a997db6ab0d9ff77eb26748
+size 16384

final_databases/coffee_shop.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a182a8a7f9b5df6da8b2976b42aca0a7db6c2b13300b13b398e568a5bf4a6b2e
+size 36864

final_databases/college_1.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5bf3ee598b9f10b4d9bef9a2d390f1391bccbcb64986c88241fad24452695d18
+size 53248

final_databases/college_2.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cb729920ad0b7f06d38a12f6f678307964acc7d3417af83d98c519c65c90d386
+size 2117632

final_databases/college_3.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9f47b8f927f27a63ba4aa35fcf6cc8360fd68bfd267e6cf05c04430f19cd773e
+size 45056

final_databases/company_1.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a58f492277a8b1bfa575746ac8b06dcbaed059c2a24ba6eb6090debc8b6c892f
+size 12288

final_databases/company_employee.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:86574c9edbecd80ded437d9439d6f81def0973816b1c8af8d007335e62565378
+size 28672

final_databases/company_office.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4514dd10d9257ccaa08acff4d272595b6d92819575c736393f89e72f956c9915
+size 28672

final_databases/concert_singer.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4fa1ba5ab4577e895271088b1dc44aa94be88e25a54293317a67584112ef059d
+size 36864

final_databases/county_public_safety.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d608ce42a7b28ecb7500c4ded8096ade65a57dae6c5eefd56709ba96c3015d4a
+size 20480

final_databases/course_teach.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:da45fcdde64ac2b9330146506b7653ad4417489d8e496e509045e1b02245d793
+size 28672

final_databases/cre_Doc_Control_Systems.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8451c4a097dcbf8fabf7993e70e91df3d825c3c941ba96eb41faa8d236897d30
+size 81920

final_databases/cre_Doc_Template_Mgt.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9c3fdd03d8795ecde60aae782ce50c4fb1d6c03de1401fcdd6dc177342a53df5
+size 24576

final_databases/cre_Doc_Tracking_DB.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9c9df67d3c16e585d159328b627c334383bea333d250c515052f65613a48fc86
+size 57344

final_databases/cre_Docs_and_Epenses.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:87b83375d433672b428afaffa8f586fd73456b5e49f2609c1feae42d90cd4c79
+size 40960

final_databases/cre_Drama_Workshop_Groups.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a9a9e215fae2314be429307b47ee7fc3ffdc749fba933faba980b97a5f6b9a0a
+size 147456

final_databases/cre_Theme_park.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ea37aa49d5cd7905f04eb76c2638f706fab1ef3cd8ce41234507b457a660d261
+size 94208

final_databases/csu_1.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c66e85b742a4941118aab88183c4be7f3e238f9d2558a5e68f8818c504e2710d
+size 102400

final_databases/culture_company.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d73d31db2c91dadeb67b8ed0c9366fbbe7658774dfa110161c168ee13e781820
+size 28672

final_databases/customer_complaints.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:495dbacbcd3ea5afb6c659a99cc10ef524213b66f692a8803942924d93bdb4a9
+size 20480

final_databases/customer_deliveries.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e4d269a357190432d3f0b154070dccf1cc5f7f7715571c1597e2fdd9ee47d485
+size 61440

final_databases/customers_and_addresses.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7d8ceb2520e7b2db55eca8c2a1e9a52a5f1d9e27d7f0dd11bcd367274e6fee96
+size 32768

final_databases/customers_and_invoices.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:19621a734777eefff77544c93f5da387f086e53b9dc0aa6266bc2da55dbd7103
+size 45056

final_databases/customers_and_products_contacts.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0d7e27cbc07e177126eda4914c9fee9eba6afdcfef03ffdc3eeee094c68aa399
+size 32768

final_databases/customers_campaigns_ecommerce.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7f7ae5bbe53359854f5c18656d5878713e88b1a364dfba05670149bcc00f3544
+size 36864

final_databases/customers_card_transactions.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c2cde3ed8c5a33dd1f708a657ef9fab552c1a74ce19010bcc0dbff37ce708d62
+size 20480

final_databases/debate.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6e9d72cbaf8e3e695a2e8865e6a35ee8c73042ddd651c30b1816d72fadfccaa7
+size 28672