Upload app.py

app.py

@@ -1,42 +1,27 @@
-import os, time, json, sqlite3, textwrap, requests
+import os, time, json, sqlite3, textwrap, requests, sys
 import gradio as gr
 
-# -------------------------------------------------
-# 1. CONFIGURATION
-# -------------------------------------------------
-MODEL_ID = "defog/sqlcoder-7b-nl2sql-beta"        # working public model
+# ----------------- CONFIG -----------------
+MODEL_ID = "gpt2"               # always public; swap later for sqlcoder
 API_URL  = f"https://api-inference.huggingface.co/models/{MODEL_ID}"
 
-HF_TOKEN = os.getenv("HF_TOKEN")                  # set in Space → Settings → Secrets
-if not HF_TOKEN:
-    raise RuntimeError("HF_TOKEN secret not found. "
-                       "Add it in Space Settings → Secrets.")
-
-HEADERS = {"Authorization": f"Bearer {HF_TOKEN}"}
+HF_TOKEN = os.getenv("HF_TOKEN")
+HEADERS  = {"Authorization": f"Bearer {HF_TOKEN}"} if HF_TOKEN else {}
 
 DB_PATH     = "company.db"
 SCHEMA_FILE = "schema.sql"
 
-# -------------------------------------------------
-# 2. UTIL: BUILD SQLITE DB IF NEEDED
-# -------------------------------------------------
+# -------------- UTIL: DB ------------------
 def create_db_if_needed():
-    """Create SQLite DB from schema.sql the first time the app runs."""
     if os.path.exists(DB_PATH):
         return
-    if not os.path.isfile(SCHEMA_FILE):
-        raise FileNotFoundError("schema.sql file is missing in the Space.")
     with open(SCHEMA_FILE) as f, sqlite3.connect(DB_PATH) as conn:
         conn.executescript(f.read())
 
-# -------------------------------------------------
-# 3. UTIL: CALL HUGGING FACE MODEL
-# -------------------------------------------------
-def nlp_to_sql(question: str, schema_ddl: str) -> str:
-    """Call HF model to convert NL question into SQL."""
+# -------------- UTIL: CALL API ------------
+def nlp_to_sql(question, schema_ddl):
     prompt = textwrap.dedent(f"""
-        ### Task
-        Translate the following natural language question into ONE valid SQLite SQL query.
+        Translate the natural language question to a SQL query.
 
         ### Schema
         {schema_ddl}
@@ -46,49 +31,51 @@ def nlp_to_sql(question: str, schema_ddl: str) -> str:
 
         ### SQL
     """)
-    payload = {"inputs": prompt, "parameters": {"max_new_tokens": 256}}
+    payload = {"inputs": prompt, "parameters": {"max_new_tokens": 64}}
+
+    # ---------- DEBUG PRINTS ----------
+    print("=" * 60, file=sys.stderr)
+    print("DEBUG URL:", API_URL, file=sys.stderr)
+    print("DEBUG Token present?:", bool(HF_TOKEN), file=sys.stderr)
+    # ----------------------------------
 
     try:
         r = requests.post(API_URL, headers=HEADERS, json=payload, timeout=60)
     except Exception as e:
-        return f"✖ Connection error: {e}"
+        return f"[ConnErr] {e}"
+
+    # ---------- MORE DEBUG ----------
+    print("DEBUG Status code:", r.status_code, file=sys.stderr)
+    print("DEBUG Raw response (first 500 bytes):", r.text[:500], file=sys.stderr)
+    print("=" * 60, file=sys.stderr)
+    # ---------------------------------
 
     if r.status_code != 200:
-        return f"✖ API error {r.status_code}: {r.text}"
+        return f"[API {r.status_code}] {r.text[:200]}"
 
-    # Parse JSON
     try:
-        generated = r.json()[0]["generated_text"]
-    except Exception:
-        return "✖ Invalid JSON response."
-
-    # Extract SQL
-    sql = generated.split("### SQL")[-1].strip()
-    return sql or "✖ Empty SQL returned."
-
-# -------------------------------------------------
-# 4. PIPELINE: NL → SQL → EXECUTE
-# -------------------------------------------------
-def run_pipeline(nl_query: str):
-    start = time.time()
-    trace = []
-
-    # DB setup
+        out = r.json()
+        generated = out[0].get("generated_text", "No generated_text")
+    except Exception as e:
+        return f"[JSONErr] {e}"
+
+    return generated.split("### SQL")[-1].strip() or "[Empty SQL]"
+
+# -------------- PIPELINE ------------------
+def run(query):
+    t0, trace = time.time(), []
     create_db_if_needed()
 
-    # Load schema
     with open(SCHEMA_FILE) as f:
-        schema_ddl = f.read()
+        schema = f.read()
     trace.append(("Schema", "loaded"))
 
-    # Convert NL → SQL
-    sql_query = nlp_to_sql(nl_query, schema_ddl)
-    trace.append(("LLM", sql_query))
+    sql = nlp_to_sql(query, schema)
+    trace.append(("LLM", sql))
 
-    # Execute SQL
     try:
         with sqlite3.connect(DB_PATH) as conn:
-            cur = conn.execute(sql_query)
+            cur = conn.execute(sql)
             rows = cur.fetchall()
             cols = [d[0] for d in cur.description] if cur.description else []
         result = {"columns": cols, "rows": rows}
@@ -97,29 +84,19 @@ def run_pipeline(nl_query: str):
         result = {"error": str(e)}
         trace.append(("Exec error", str(e)))
 
-    trace.append(("Time", f"{time.time() - start:.2f}s"))
-
-    return (
-        sql_query,
-        json.dumps(result, indent=2, ensure_ascii=False),
-        "\n".join(f"{s}: {m}" for s, m in trace),
-    )
-
-# -------------------------------------------------
-# 5. GRADIO UI
-# -------------------------------------------------
-with gr.Blocks(title="NLP → SQL (SQLite, HF Hub)") as demo:
-    gr.Markdown("### NLP → SQL demo • SQLite backend • Hugging Face Inference API")
-    query_in = gr.Textbox(
-        label="Natural-language question",
-        placeholder="e.g. List all employees in Engineering hired after 2021",
-    )
+    trace.append(("Time", f"{time.time()-t0:.2f}s"))
+    return sql, json.dumps(result, indent=2), "\n".join(f"{s}: {m}" for s, m in trace)
+
+# -------------- UI ------------------------
+with gr.Blocks(title="Debug NLP→SQL") as demo:
+    gr.Markdown("### Debugging Hugging Face Inference API calls")
+    q = gr.Textbox(label="Ask", placeholder="Example: List employees")
     with gr.Row():
-        sql_out = gr.Code(label="Generated SQL", language="sql")
-        res_out = gr.Code(label="Query result (JSON)")
-    trace_out = gr.Textbox(label="Trace", lines=6)
-    run_btn = gr.Button("Run")
-    run_btn.click(run_pipeline, query_in, [sql_out, res_out, trace_out])
+        sql_box = gr.Code(label="Generated SQL / debug output")
+        res_box = gr.Code(label="Query result")
+    tbox = gr.Textbox(label="Trace")
+    btn = gr.Button("Run")
+    btn.click(run, q, [sql_box, res_box, tbox])
 
 if __name__ == "__main__":
     demo.launch()