quiz ui to navigate questions

app.py

@@ -1,71 +1,12 @@
+import re
 import gradio as gr
-from huggingface_hub import hf_hub_download
-from llama_cpp import Llama
-
-print("Downloading model...")
-model_path = hf_hub_download(
-    repo_id="ebbalg/llama-finetome",
-    filename="llama-3.2-1b-instruct.Q4_K_M.gguf"
-)
-
-print("Loading model...")
-llm = Llama(
-    model_path=model_path,
-    n_ctx=2048,
-    n_threads=2,
-    verbose=False,
-    chat_format="llama-3"
-)
-
-def chat(message, history):
-    """Simple chat function"""
-    messages = []
-    
-    # Handle history - it might be a list of tuples or list of dicts
-    if history:
-        for h in history:
-            if isinstance(h, (list, tuple)):
-                # Format: [user_msg, assistant_msg]
-                messages.append({"role": "user", "content": str(h[0])})
-                messages.append({"role": "assistant", "content": str(h[1])})
-            elif isinstance(h, dict):
-                # Format: {"role": "...", "content": "..."}
-                messages.append(h)
-    
-    # Add current message
-    messages.append({"role": "user", "content": message})
-    
-    # Generate response
-    response = llm.create_chat_completion(
-        messages=messages,
-        max_tokens=256,
-        temperature=0.7,
-    )
-    
-    return response["choices"][0]["message"]["content"]
-
-def quiz():
-    '''Generate a multiple choice quiz with 10 questions (created by the llm)'''
-    system_prompt = {
-        "role": "system",
-        "content": (
-            "Generate a set of 10 multiple-choice questions about machine learning for a student."
-            "Each question should have 4 answer options (A–D) with a single correct answer.\n\n"
-            "Format exactly like this:\n\n"
-            "1. Question text...\n"
-            "A) ...\nB) ...\nC) ...\nD) ...\n**Correct Answer: X**\n\n"
-        )
-    }
-
-    response = llm.create_chat_completion(
-        messages=[system_prompt],
-        max_tokens=512,
-        temperature=0.7
-    )
-
-    return response["choices"][0]["message"]["content"]
+from quiz import create_quiz, parse_quiz, start_quiz, submit_and_next, restart_quiz
+from chatbot import chat
 
 
+print("Creating quiz...")
+raw_quiz = create_quiz()
+parsed_quiz = parse_quiz(raw_quiz)
 
 
 with gr.Blocks(title="TAI: AI Teacher Assistant") as demo:
@@ -76,10 +17,15 @@ with gr.Blocks(title="TAI: AI Teacher Assistant") as demo:
                 
     This Llama 3.2 1B model was fine-tuned on the FineTome-100k instruction dataset.
     """)
+
+    initial_quiz = create_quiz()
+    quiz_state = gr.State(initial_quiz)
+
+
     with gr.Row():
 
         # Left column: chat
-        with gr.Column(scale=2):
+        with gr.Column(scale=1):
             chatbot = gr.ChatInterface(
                 chat,
                 examples=[
@@ -91,12 +37,87 @@ with gr.Blocks(title="TAI: AI Teacher Assistant") as demo:
             )
         
         # Right column: quiz
-        with gr.Column(scale=1):
-            gr.Markdown("## Machine Learning Quiz")
-            quiz_btn = gr.Button("Start Quiz", variant="primary")
-            quiz_output = gr.Markdown()
+        with gr.Column(scale=2):
+            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]
+            )
 
-            quiz_btn.click(fn=quiz, outputs=quiz_output)
+            # 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
+
+            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]
+            )
+
+            # 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]
+            )
+
+            # 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
+            )
+
+            # 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,
+                inputs=[],
+                outputs=[question_md, options, idx_state, score_state, progress, result_md, finished_state]
+            )
 
 
 demo.launch()

chatbot.py

@@ -0,0 +1,44 @@
+from llama_cpp import Llama
+from huggingface_hub import hf_hub_download
+
+print("Downloading model...")
+model_path = hf_hub_download(
+    repo_id="ebbalg/llama-finetome",
+    filename="llama-3.2-1b-instruct.Q4_K_M.gguf"
+)
+
+print("Loading model...")
+llm = Llama(
+    model_path=model_path,
+    n_ctx=2048,
+    n_threads=2,
+    verbose=False,
+    chat_format="llama-3"
+)
+
+def chat(message, history):
+    """Simple chat function"""
+    messages = []
+    
+    # Handle history - it might be a list of tuples or list of dicts
+    if history:
+        for h in history:
+            if isinstance(h, (list, tuple)):
+                # Format: [user_msg, assistant_msg]
+                messages.append({"role": "user", "content": str(h[0])})
+                messages.append({"role": "assistant", "content": str(h[1])})
+            elif isinstance(h, dict):
+                # Format: {"role": "...", "content": "..."}
+                messages.append(h)
+    
+    # Add current message
+    messages.append({"role": "user", "content": message})
+    
+    # Generate response
+    response = llm.create_chat_completion(
+        messages=messages,
+        max_tokens=256,
+        temperature=0.7,
+    )
+    
+    return response["choices"][0]["message"]["content"]

quiz.py

@@ -0,0 +1,159 @@
+import re
+from chatbot import llm
+
+### CREATE AND PARSE QUIZ
+
+def create_quiz(llm):
+    '''Generate a multiple choice quiz with 10 questions (created by the llm)'''
+    system_prompt = {
+        "role": "system",
+        "content": (
+            "Generate a set of 10 multiple-choice questions about machine learning for a student."
+            "Each question should have 4 answer options (A–D) with a single correct answer.\n\n"
+            "Format exactly like this:\n\n"
+            "1. Question text...\n"
+            "A) ...\nB) ...\nC) ...\nD) ...\n**Correct Answer: X**\n\n"
+        )
+    }
+
+    response = llm.create_chat_completion(
+        messages=[system_prompt],
+        max_tokens=512,
+        temperature=0.7
+    )
+
+    return response["choices"][0]["message"]["content"]
+
+def parse_quiz(text):
+    question_blocks = re.findall(r'(\d+)\.\s*(.*?)(?=\n\d+\.|\Z)', text, flags=re.S)
+    parsed = []
+    for idx, block_text in question_blocks:
+        block = block_text.strip()
+        # Extract the question line before options
+        # Find A) position
+        m_a = re.search(r'\nA[\)\.]', block)
+        if m_a:
+            question_text = block[:m_a.start()].strip()
+            rest = block[m_a.start():].strip()
+        else:
+            # if no A) found, entire block as question
+            question_text = block
+            rest = ""
+
+        # Extract options A-D
+        opts = re.findall(r'([A-D])[\)\.]\s*(.+?)(?=\n[A-D][\)\.]|\n\*\*Correct|\n\d+\.|\Z)', rest, flags=re.S)
+        options = []
+        # sort options by letter just in case
+        opts_sorted = sorted(opts, key=lambda x: x[0]) if opts else []
+        for letter, opt_text in opts_sorted:
+            options.append(opt_text.strip().replace("\n", " "))
+
+        # Extract correct answer
+        ans = None
+        m_corr = re.search(r'\*\*\s*Correct Answer\s*:\s*([A-D])\s*\*\*', block, flags=re.I)
+        if not m_corr:
+            m_corr = re.search(r'Correct Answer\s*:\s*([A-D])', block, flags=re.I)
+        if not m_corr:
+            # possible "Correct: A" or "Answer: A"
+            m_corr = re.search(r'(Correct|Answer)\s*[:\-]\s*([A-D])', block, flags=re.I)
+            if m_corr:
+                ans = m_corr.group(2).upper()
+        else:
+            ans = m_corr.group(1).upper()
+
+        parsed.append({
+            "q": question_text,
+            "options": options,
+            "answer": ans
+        })
+
+    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
+
+    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
+
+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"]