cleaned up the GUI

app.py

@@ -7,12 +7,16 @@ os.environ["TRANSFORMERS_NO_FLAX"] = "1"
 os.environ["HF_HUB_DISABLE_TELEMETRY"] = "1"
 
 CRUD_VERB = {
-    "INSERT": "inserted",
-    "UPDATE": "updated",
+    "INSERT": "load",
+    "UPDATE": "changed",
     "DELETE": "deleted",
-    "SELECT": "retrieved",
+    "SELECT": "specified",
 }
 
+# ---------- helpers ----------
+def plural(n: int, singular: str = "record", plural_word: str = "records") -> str:
+    return f"{n} {singular if n == 1 else plural_word}"
+
 def detect_command(sql_text: str) -> str:
     m = re.search(r"\b(INSERT|UPDATE|DELETE|SELECT)\b", sql_text, flags=re.IGNORECASE)
     return m.group(1).upper() if m else "OTHER"
@@ -22,7 +26,7 @@ def parse_table_name(sql: str) -> str:
         r"INSERT\s+INTO\s+([A-Za-z0-9\.\[\]_]+)",
         r"UPDATE\s+([A-Za-z0-9\.\[\]_]+)",
         r"DELETE\s+FROM\s+([A-Za-z0-9\.\[\]_]+)",
-        r"FROM\s+([A-Za-z0-9\.\[\]_]+)",
+        r"\bFROM\s+([A-Za-z0-9\.\[\]_]+)",
     ]:
         m = re.search(pat, sql, flags=re.IGNORECASE)
         if m:
@@ -35,6 +39,16 @@ def clean_statement(text: str) -> str:
         text += "."
     return text[0].upper() + text[1:] if text else text
 
+def infer_in_list_count(where_clause: str) -> None:
+    if not where_clause:
+        return None
+    m = re.search(r"\bIN\s*\(\s*([^)]+?)\s*\)", where_clause, flags=re.IGNORECASE | re.DOTALL)
+    if not m:
+        return None
+    items = [x.strip() for x in m.group(1).split(",") if x.strip()]
+    return len(items) if items else None
+
+# ---------- deterministic CRUD summaries ----------
 def summarize_insert(sql: str) -> str:
     table = parse_table_name(sql)
     cols_match = re.search(r"\(\s*([^)]+?)\s*\)\s*VALUES", sql, flags=re.IGNORECASE | re.DOTALL)
@@ -61,18 +75,20 @@ def summarize_insert(sql: str) -> str:
 
     count = len(tuples)
     verb = CRUD_VERB["INSERT"]
+
     if user_ids:
         groups = {}
         for u in user_ids:
             groups[u] = groups.get(u, 0) + 1
         if len(groups) == 1:
             uid = next(iter(groups))
-            return f"{count} record(s) {verb} into {table} (user_id {uid})."
+            return f"{count} record(s) {verb} into table {table} (column user_id {uid})."
         else:
-            parts = [f"{n} with user_id {uid}" for uid, n in sorted(groups.items())]
-            return f"{count} record(s) {verb} into {table} ({', '.join(parts)})."
+            parts = [f"{n} with column user_id {uid}" for uid, n in sorted(groups.items())]
+            return f"{count} record(s) {verb} into table {table} ({', '.join(parts)})."
     else:
-        return f"{count} record(s) {verb} into {table}."
+        return f"{count} record(s) {verb} into table {table}."
+
 
 def summarize_update(sql: str) -> str:
     table = parse_table_name(sql)
@@ -84,32 +100,36 @@ def summarize_update(sql: str) -> str:
             col = a.split("=")[0].strip().strip("[]")
             if col:
                 changed_cols.append(col)
+
     where = ""
     w = re.search(r"\bWHERE\b\s+(.+?)(;|$)", sql, flags=re.IGNORECASE | re.DOTALL)
     if w:
         where = re.sub(r"\s+", " ", w.group(1)).strip()
 
     verb = CRUD_VERB["UPDATE"]
-    base = f"Record(s) {verb} in {table}"
+    base = f"Record(s) {verb} in table {table}"
     if changed_cols:
-        if len(changed_cols) <= 3:
-            base += f" (changed: {', '.join(changed_cols)})"
-        else:
-            base += f" ({len(changed_cols)} columns changed)"
+        cols_txt = ", ".join(changed_cols)
+        base += f" (changed: column(s) {cols_txt})"
     if where:
-        base += f" where {where}"
+        base += f" with {where}"
     return base + "."
 
+
 def summarize_delete(sql: str) -> str:
     table = parse_table_name(sql)
     where = ""
     w = re.search(r"\bWHERE\b\s+(.+?)(;|$)", sql, flags=re.IGNORECASE | re.DOTALL)
     if w:
         where = re.sub(r"\s+", " ", w.group(1)).strip()
+
+    n_targets = infer_in_list_count(where)
     verb = CRUD_VERB["DELETE"]
-    base = f"Record(s) {verb} from {table}"
+
+    base = (f"{plural(n_targets, 'record', 'records')} {verb} from {table}"
+            if n_targets else f"Records {verb} from {table}")
     if where:
-        base += f" where {where}"
+        base += f" that match {where}"
     return base + "."
 
 def summarize_select(sql: str) -> str:
@@ -126,7 +146,7 @@ def summarize_select(sql: str) -> str:
     verb = CRUD_VERB["SELECT"]
     base = f"{cols} will be {verb} from {table}"
     if where:
-        base += f" where {where}"
+        base += f" that match {where}"
     return base + "."
 
 def deterministic_summary(sql_text: str) -> str:
@@ -141,6 +161,7 @@ def deterministic_summary(sql_text: str) -> str:
         return summarize_select(sql_text)
     return "Unrecognized SQL command."
 
+# ---------- optional T5 rephrase ----------
 _HAS_T5 = False
 try:
     from transformers import T5Tokenizer, T5ForConditionalGeneration
@@ -156,7 +177,7 @@ CRUD_PROMPT = {
     "UPDATE": "Rewrite as a clear statement that existing records will be updated. Keep names and conditions.",
     "DELETE": "Rewrite as a clear statement that records will be deleted. Keep conditions if present.",
     "SELECT": "Rewrite as a clear statement that data will be retrieved. Keep table/filters.",
-    "OTHER": "Rewrite as a short, clear statement for non-technical users.",
+    "OTHER":  "Rewrite as a short, clear statement for non-technical users.",
 }
 
 def load_t5():
@@ -170,8 +191,7 @@ def rephrase_with_t5(summary: str, cmd: str) -> str:
         return summary
     load_t5()
     instruction = CRUD_PROMPT.get(cmd, CRUD_PROMPT["OTHER"])
-    # Force a statement; avoid question opening
-    input_text = f"explain sql in plain english statement: {instruction} {summary} </s>"
+    input_text = f"explain sql in plain english statement: {instruction} {summary}"
     feats = _T5_TOKENIZER([input_text], return_tensors="pt")
     out = _T5_MODEL.generate(
         input_ids=feats["input_ids"],
@@ -182,11 +202,42 @@ def rephrase_with_t5(summary: str, cmd: str) -> str:
     decoded = _T5_TOKENIZER.decode(out[0], skip_special_tokens=True)
     return clean_statement(decoded)
 
+def _bad_rephrase(text: str) -> bool:
+    if text is None:
+        return True
+    t = str(text).strip()
+    if len(t) >= 2 and ((t[0] == t[-1] == '"') or (t[0] == t[-1] == "'")):
+        t = t[1:-1].strip()
+    t_norm = re.sub(r"[\s\.\!\?]+$", "", t).strip().lower()
+    # added "true" here to force fallback for True./False. answers
+    if t_norm in ("false", "true", "none", "null", "n/a", "na", ""):
+        return True
+    if re.match(r"^(what|which|how)\b", t_norm, re.IGNORECASE):
+        return True
+    return len(t_norm) < 3
+
+def explain(sql_text: str):
+    sql_text = (sql_text or "").strip()
+    cmd = detect_command(sql_text)
+    deterministic = deterministic_summary(sql_text)
 
+    final = None
+    if _HAS_T5 and cmd != "OTHER":
+        try:
+            final = rephrase_with_t5(deterministic, cmd)
+        except Exception as e:
+            print(f"T5 rephrase failed: {e}")
+            final = None
+
+    if _bad_rephrase(final):
+        final = deterministic
+    return final
+
+# ---------- UI ----------
 EXAMPLES = [
     # INSERT
     """INSERT INTO demo_database..user_records (record_id, person_id, created_at) 
-    VALUES (101, 5, GETDATE()), (102, 5, GETDATE()), (103, 5, GETDATE());""",
+VALUES (101, 5, GETDATE()), (102, 5, GETDATE()), (103, 5, GETDATE());""",
     # UPDATE
     """UPDATE users
 SET status = 'active', last_login = GETDATE()
@@ -200,44 +251,15 @@ FROM accounts
 WHERE email LIKE '%@example.com' AND created_at >= '2025-01-01';""",
 ]
 
-with gr.Blocks(title="SQL → Human: CRUD Explainer") as demo:
-    gr.HTML("<h1 style='text-align:center;'>SQL → Human: CRUD Explainer</h1>")
-    gr.Markdown(
-        "Paste any SQL (INSERT/UPDATE/DELETE/SELECT). "
-        "The app will detect the command, create a deterministic summary, "
-        "and optionally rephrase it using a SQL→English model."
-    )
-
-    with gr.Row():
-        sql_in = gr.Textbox(label="SQL input", lines=14, placeholder="Paste your SQL here...")
-    with gr.Row():
-        use_t5 = gr.Checkbox(label="Use T5 rephrase (mrm8488/t5-base-finetuned-wikiSQL-sql-to-en)", value=True)
+with gr.Blocks(theme=gr.themes.Glass()) as demo:
+    gr.Markdown("## 📝 CRUD-SQL2Text")
 
-    with gr.Row():
-        btn = gr.Button("Explain SQL", variant="primary")
+    sql_in = gr.Textbox(label="Enter SQL Query", lines=8, placeholder="Paste your SQL statement here...")
+    final_out = gr.Textbox(label="Natural Language Output", lines=3)
 
-    detected_out = gr.Label(label="Detected Command")
-    deterministic_out = gr.Markdown(label="Deterministic Summary")
-    final_out = gr.Markdown(label="Final Explanation")
+    btn = gr.Button("Explain SQL")
+    btn.click(explain, inputs=[sql_in], outputs=[final_out])
 
-    def explain(sql_text: str, want_t5: bool):
-        sql_text = (sql_text or "").strip()
-        cmd = detect_command(sql_text)
-        deterministic = deterministic_summary(sql_text)
-        if want_t5 and _HAS_T5 and cmd != "OTHER":
-            final = rephrase_with_t5(deterministic, cmd)
-        else:
-            final = clean_statement(deterministic)
-        return {"Detected Command": cmd}, deterministic, final
-
-    btn.click(explain, inputs=[sql_in, use_t5], outputs=[detected_out, deterministic_out, final_out])
-
-    gr.Examples(
-        examples=EXAMPLES,
-        inputs=[sql_in],
-        label="Try examples",
-        examples_per_page=4
-    )
+    gr.Examples(examples=EXAMPLES, inputs=[sql_in], outputs=[final_out], fn=explain, cache_examples=False)
 
-if __name__ == "__main__":
-    demo.launch()
+demo.launch(share=True)