updated quiz ui

app.py

@@ -1,9 +1,11 @@
 import re
 import gradio as gr
-from quiz import create_quiz, parse_quiz, start_quiz, submit_and_next, restart_quiz
+#from quiz import create_quiz, parse_quiz, start_quiz, submit_and_next, restart_quiz
+from quiz import *
 from chatbot import chat
 from llama_cpp import Llama
 from huggingface_hub import hf_hub_download
+from functools import partial
 
 print("Downloading model...")
 model_path = hf_hub_download(
@@ -25,6 +27,7 @@ raw_quiz = create_quiz(llm)
 parsed_quiz = parse_quiz(raw_quiz)
 
 
+
 with gr.Blocks(title="TAI: AI Teacher Assistant") as demo:
     gr.Markdown("""
     # TAI: Your AI Teacher Assistant
@@ -41,7 +44,7 @@ with gr.Blocks(title="TAI: AI Teacher Assistant") as demo:
     with gr.Row():
 
         # Left column: chat
-        with gr.Column(scale=1):
+        with gr.Column(scale=2):
             chatbot = gr.ChatInterface(
                 fn=lambda message, history: chat(llm, message, history),
                 examples=[
@@ -53,86 +56,55 @@ with gr.Blocks(title="TAI: AI Teacher Assistant") as demo:
             )
         
         # Right column: quiz
-        with gr.Column(scale=2):
+        with gr.Column(scale=1):
             gr.Markdown("## Test Yourself")
-             # Visible elements
-            progress = gr.Markdown(f"**Progress:** 0/0", elem_id="quiz-progress")
-            question_md = gr.Markdown("", elem_id="quiz-question")
-            options = gr.Radio(choices=[], label="Choose an answer", type="value")
-            next_btn = gr.Button("Next")
+            
             start_btn = gr.Button("Start Quiz", variant="primary")
-            restart_btn = gr.Button("Restart Quiz")
-            result_md = gr.Markdown("", visible=False)
-
-            # State holders
-            quiz_raw_state = gr.State(raw_quiz)        # raw quiz text
-            quiz_parsed_state = gr.State(parsed_quiz)       # parsed list of questions
-            idx_state = gr.State(0)                         # current index
-            score_state = gr.State(0)                       # current score
-            finished_state = gr.State(False)                # finished flag
-
-            # Start Quiz -> show first question (no model call)
-            def on_start(quiz_raw, quiz_parsed):
-                payload, idx, score = start_quiz(quiz_raw, quiz_parsed)
-                # return question_md, options choices, idx, score, progress, result_md_visible
-                return payload["question_md"], payload["options"], gr.update(value=idx), gr.update(value=score), payload["progress"], gr.update(visible=False), gr.update(visible=True)
-                # Note: last two are for hiding/showing result_md (kept simple)
 
-            start_btn.click(
-                fn=lambda qr, qp: start_quiz(qr, qp)[0],  # we only want the payload (question data) but mapping below
-                inputs=[quiz_raw_state, quiz_parsed_state],
-                outputs=[question_md]
-            )
+            question_md = gr.Markdown("")
+            feedback_md = gr.Markdown("")
+            progress_md = gr.Markdown("")
 
-            # After start, we also need to set options, progress, idx, score and ensure result is hidden.
-            def start_full(quiz_raw, quiz_parsed):
-                payload, idx, score = start_quiz(quiz_raw, quiz_parsed)
-                return payload["question_md"], payload["options"], idx, score, payload["progress"], "", False
+            # Answer buttons
+            btn_A = gr.Button("A")
+            btn_B = gr.Button("B")
+            btn_C = gr.Button("C")
+            btn_D = gr.Button("D")
+            retry_btn = gr.Button("Retry")
 
-            start_btn.click(
-                fn=start_full,
-                inputs=[quiz_raw_state, quiz_parsed_state],
-                outputs=[question_md, options, idx_state, score_state, progress, result_md, finished_state]
-            )
+            # States
+            idx_state = gr.State(0)
+            score_state = gr.State(0)
 
-            # Next button: check selected and move forward
-            def on_next(selected, quiz_parsed, idx, score):
-                md_or_q, opts, new_idx, new_score, prog, finished = submit_and_next(selected, quiz_parsed, idx, score)
-                if finished:
-                    # show final result
-                    return md_or_q, [], new_idx, new_score, prog, True
-                else:
-                    return md_or_q, opts, new_idx, new_score, prog, False
-
-            next_btn.click(
-                fn=on_next,
-                inputs=[options, quiz_parsed_state, idx_state, score_state],
-                outputs=[question_md, options, idx_state, score_state, progress, finished_state]
-            )
+            # Start quiz
+            start_fn = partial(start_quiz, parsed_quiz)
 
-            # When finished_state becomes True, show the result markdown and hide options
-            def show_result_if_finished(finished_flag, current_question_md):
-                if finished_flag:
-                    # current_question_md will be the result text returned earlier
-                    return gr.update(value=current_question_md), gr.update(visible=True), gr.update(visible=False)
-                else:
-                    return gr.update(value=""), gr.update(visible=False), gr.update(visible=True)
-
-            finished_state.change(
-                fn=show_result_if_finished,
-                inputs=[finished_state, question_md],
-                outputs=[result_md, result_md, options]  # show result_md & hide options when finished
+            start_btn.click(
+                fn=start_fn,
+                inputs=[],
+                outputs=[question_md, idx_state, score_state, feedback_md, progress_md, start_btn]
             )
 
-            # Restart quiz (without regenerating)
-            def on_restart():
-                q_md, q_opts, idx, score, prog = restart_quiz(raw_quiz, parsed_quiz)
-                return q_md, q_opts, idx, score, prog, "", False
-
-            restart_btn.click(
-                fn=on_restart,
+            # Answer button clicks
+            answer_fn_A = partial(answer_question, parsed_quiz, "A")
+            answer_fn_B = partial(answer_question, parsed_quiz, "B")
+            answer_fn_C = partial(answer_question, parsed_quiz, "C")
+            answer_fn_D = partial(answer_question, parsed_quiz, "D")
+
+            btn_A.click(fn=answer_fn_A, inputs=[idx_state, score_state],
+                        outputs=[question_md, idx_state, score_state, feedback_md, progress_md])
+            btn_B.click(fn=answer_fn_B, inputs=[idx_state, score_state],
+                        outputs=[question_md, idx_state, score_state, feedback_md, progress_md])
+            btn_C.click(fn=answer_fn_C, inputs=[idx_state, score_state],
+                        outputs=[question_md, idx_state, score_state, feedback_md, progress_md])
+            btn_D.click(fn=answer_fn_D, inputs=[idx_state, score_state],
+                        outputs=[question_md, idx_state, score_state, feedback_md, progress_md])
+
+            # Retry button
+            retry_btn.click(
+                fn=retry_quiz,
                 inputs=[],
-                outputs=[question_md, options, idx_state, score_state, progress, result_md, finished_state]
+                outputs=[question_md, idx_state, score_state, feedback_md, progress_md, start_btn]
             )
 
 

quiz.py

@@ -68,91 +68,30 @@ def parse_quiz(text):
 
     return parsed
 
-
 def start_quiz(quiz_raw, quiz_parsed):
-    """Return first question payload and initialize index & score."""
-    # If parse failed or zero questions, show raw text
-    if not quiz_parsed:
-        return {
-            "question_md": "⚠️ Could not parse generated quiz. Showing raw output below:\n\n" + quiz_raw,
-            "options": [],
-            "progress": "0/0"
-        }, 0, 0  # index, score
-
+    """Initialize quiz state, return first question display."""
     idx = 0
     q = quiz_parsed[idx]
-    opts = q["options"]
-    # If options are empty, present the whole block as markdown
-    if not opts:
-        return {
-            "question_md": f"**Q {idx+1}.** {q['q']}",
-            "options": [],
-            "progress": f"{idx+1}/{len(quiz_parsed)}"
-        }, idx, 0
-
-    # present options as list of strings
     return {
-        "question_md": f"**Q {idx+1}.** {q['q']}",
-        "options": [f"{letter}) {opt}" for letter, opt in zip(['A','B','C','D'], opts)],
-        "progress": f"{idx+1}/{len(quiz_parsed)}"
-    }, idx, 0
-
-def show_question(quiz_parsed, idx):
-    """Return the question (md), options list, progress for a given index."""
-    if not quiz_parsed or idx < 0 or idx >= len(quiz_parsed):
-        return "No question", [], "0/0"
-    q = quiz_parsed[idx]
-    opts = q["options"]
-    md = f"**Q {idx+1}.** {q['q']}"
-    if not opts:
-        return md, [], f"{idx+1}/{len(quiz_parsed)}"
-    return md, [f"{letter}) {opt}" for letter, opt in zip(['A','B','C','D'], opts)], f"{idx+1}/{len(quiz_parsed)}"
-
-def submit_and_next(selected, quiz_parsed, idx, score):
-    """
-    Process user's selected option for question idx, return:
-    - question text for next idx or results message if finished
-    - options list for next question
-    - updated index, updated score
-    - status/progress string
-    """
-    # Validate
-    if not quiz_parsed:
-        return "No quiz parsed.", [], idx, score, "0/0", False
-
-    # Check current answer
-    if 0 <= idx < len(quiz_parsed):
-        current = quiz_parsed[idx]
-        correct = current.get("answer")
-        # normalize selected like "A) text" -> "A"
-        sel_letter = None
-        if selected:
-            m = re.match(r'\s*([A-D])[\)\.]', selected)
-            if m:
-                sel_letter = m.group(1).upper()
-        # If there is a correct letter available, compare
-        if correct and sel_letter:
-            if sel_letter == correct:
-                score += 1
-
-    # Move to next question
-    idx += 1
-    if idx >= len(quiz_parsed):
-        # Quiz finished
-        result_md = f"### 🧾 Quiz complete!\n\nYour score: **{score} / {len(quiz_parsed)}**"
-        # Optionally show correct answers summary
-        answers_lines = []
-        for i, q in enumerate(quiz_parsed):
-            ans = q.get("answer") or "?"
-            answers_lines.append(f"{i+1}. {ans}")
-        result_md += "\n\n**Correct answers:**\n\n" + "\n".join(answers_lines)
-        return result_md, [], idx, score, f"{len(quiz_parsed)}/{len(quiz_parsed)}", True
-
-    # Otherwise return next question
-    md, opts, progress = show_question(quiz_parsed, idx)
-    return md, opts, idx, score, progress, False
+        "question_text": q["q"],
+        "feedback": "",
+        "progress": f"{idx+1}/{len(quiz_parsed)}",
+        "show_start": False
+    }, idx, 0  # idx, score
+
+def answer_question(parsed_quiz, selected, idx, score):
+    current = parsed_quiz[idx]
+    correct = current["answer"]
+    if selected.upper() == correct:
+        score += 1
+        idx += 1
+        if idx >= len(parsed_quiz):
+            return "Quiz Complete!", idx, score, "✅ Correct!", f"{len(parsed_quiz)}/{len(parsed_quiz)}"
+        q = parsed_quiz[idx]
+        return q["q"], idx, score, "✅ Correct!", f"{idx+1}/{len(parsed_quiz)}"
+    else:
+        return current["q"], idx, score, "❌ Incorrect, try again.", f"{idx+1}/{len(parsed_quiz)}"
+
+def retry_quiz():
+    return start_quiz()
 
-def restart_quiz(raw_quiz, parsed_quiz):
-    """Reset to the first question, keep the same parsed quiz."""
-    payload, idx, score = start_quiz(raw_quiz, parsed_quiz)
-    return payload["question_md"], payload["options"], idx, score, payload["progress"]