Update app.py

app.py

@@ -723,7 +723,7 @@ def results_equal_or_superset(df_student: pd.DataFrame, df_expected: pd.DataFram
     a = _normalize_columns(df_student); b = _normalize_columns(df_expected)
     if set(a.columns) == set(b.columns):
         a2 = a[sorted(a.columns)].sort_values(sorted(a.columns)).reset_index(drop=True)
-        b2 = b[sorted(b.columns)].sort_values(sorted(b.columns)).reset_index(drop=True)
+        b2 = b[sorted(a.columns)].sort_values(sorted(a.columns)).reset_index(drop=True)
         return (a2.equals(b2), None)
     if set(b.columns).issubset(set(a.columns)):
         a_proj = a[b.columns]
@@ -737,6 +737,13 @@ def results_equal_rowcount_only(df_student: pd.DataFrame, df_expected: pd.DataFr
     # When projection isn't specified, match on row count only.
     return df_student.shape[0] == df_expected.shape[0]
 
+def aliases_present(sql: str, required_aliases: List[str]) -> bool:
+    low = re.sub(r"\s+", " ", (sql or "").lower())
+    for al in (required_aliases or []):
+        if f" {al}." not in low and f" as {al} " not in low:
+            return False
+    return True
+
 def exec_student_sql(sql_text: str) -> Tuple[Optional[pd.DataFrame], Optional[str], Optional[str], Optional[str]]:
     if not sql_text or not sql_text.strip():
         return None, "Enter a SQL statement.", None, None
@@ -954,24 +961,47 @@ def _domain_status_md():
     err = CURRENT_INFO.get("error",""); err_short = (err[:160] + "…") if len(err) > 160 else err
     return f"⚠️ **OpenAI randomization unavailable** → using fallback **{CURRENT_SCHEMA.get('domain','?')}**.\n\n> Reason: {err_short}"
 
-def regenerate_domain():
+# ----- UPDATED: regenerate also refreshes tbl list and, if session active, seeds a new question + shows input
+def list_tables_for_preview():
+    df = run_df(CONN, """
+        SELECT name FROM sqlite_master
+        WHERE type in ('table','view')
+          AND name NOT LIKE 'sqlite_%'
+          AND name NOT IN ('users','attempts','session_meta')
+        ORDER BY type, name
+    """)
+    return df["name"].tolist() if not df.empty else ["(no tables)"]
+
+def regenerate_domain(session: dict):
     global CURRENT_SCHEMA, CURRENT_QS, CURRENT_INFO
     prev = CURRENT_SCHEMA.get("domain") if CURRENT_SCHEMA else None
     CURRENT_SCHEMA, CURRENT_QS, CURRENT_INFO = install_schema_and_prepare_questions(prev_domain=prev)
     erd = draw_dynamic_erd(CURRENT_SCHEMA)
-    return gr.update(value=_domain_status_md(), visible=True), erd
+    status = _domain_status_md()
+
+    # Refresh the preview dropdown
+    choices = list_tables_for_preview()
+    dd_update = gr.update(choices=choices, value=(choices[0] if choices and choices[0]!="(no tables)" else None))
+
+    # If a session is active, show the first question immediately for the new domain
+    prompt_update = gr.update()
+    input_update  = gr.update()
+    if session and session.get("user_id"):
+        q = pick_next_question(session["user_id"])
+        session["qid"] = q["id"]; session["q"] = q; session["start_ts"] = time.time()
+        prompt_update = gr.update(value=f"**Question {q['id']}**\n\n{q['prompt_md']}", visible=True)
+        input_update  = gr.update(value="", visible=True)
+
+    return status, erd, prompt_update, input_update, dd_update, session
 
 def preview_table(tbl: str):
     try:
+        if not tbl or tbl=="(no tables)":
+            return pd.DataFrame()
         return run_df(CONN, f"SELECT * FROM {tbl} LIMIT 20")
     except Exception as e:
         return pd.DataFrame([{"error": str(e)}])
 
-def list_tables_for_preview():
-    df = run_df(CONN, "SELECT name, type FROM sqlite_master WHERE type in ('table','view') AND name NOT IN ('users','attempts','session_meta') ORDER BY type, name")
-    if df.empty: return ["(no tables)"]
-    return df["name"].tolist()
-
 # -------------------- UI --------------------
 with gr.Blocks(title="Adaptive SQL Trainer — Randomized Domains") as demo:
     gr.Markdown(
@@ -1060,21 +1090,19 @@ with gr.Blocks(title="Adaptive SQL Trainer — Randomized Domains") as demo:
         inputs=[export_name],
         outputs=[export_file],
     )
+
+    # UPDATED: one callback handles regeneration, dropdown refresh, and (if session) reseeding the next question
     regen_btn.click(
         regenerate_domain,
-        inputs=[],
-        outputs=[regen_fb, er_image],
+        inputs=[session_state],
+        outputs=[regen_fb, er_image, prompt_md, sql_input, tbl_dd, session_state],
     )
+
     tbl_btn.click(
-        lambda name: preview_table(name),
+        preview_table,
         inputs=[tbl_dd],
         outputs=[preview_df]
     )
-    regen_btn.click(  # refresh list after regeneration
-        lambda: gr.update(choices=list_tables_for_preview()),
-        inputs=[],
-        outputs=[tbl_dd]
-    )
 
 if __name__ == "__main__":
     demo.launch()