initial commit

.gitignore

@@ -0,0 +1 @@
+.DS_Store

app.py

@@ -0,0 +1,178 @@
+import gradio as gr
+import random
+import re
+from pathlib import Path
+
+# -------------------- PARSER -------------------- #
+def parse_latex_questions(tex_path: str):
+    text = Path(tex_path).read_text(encoding="utf-8")
+    pattern = re.compile(
+        r"\\question\s*(.*?)\s*\\choice\s*\{(.*?)\}\s*\{(.*?)\}\s*\{(.*?)\}\s*\{(.*?)\}\s*\{(.*?)\}",
+        re.DOTALL
+    )
+
+    letter_map = {"a": 0, "b": 1, "c": 2, "d": 3}
+    questions = []
+
+    for m in pattern.finditer(text):
+        q_text = m.group(1).strip()
+        options = [m.group(i).strip() for i in range(2, 6)]
+        answer_letter = m.group(6).strip().lower()
+        correct_answer = options[letter_map.get(answer_letter, 0)]
+        questions.append(
+            {
+                "question": q_text,
+                "options": options,
+                "answer": correct_answer,
+            }
+        )
+
+    return questions
+
+# -------------------- LOAD QUESTIONS -------------------- #
+all_questions = parse_latex_questions("questions.tex")
+
+# -------------------- GAME LOGIC -------------------- #
+def start_game():
+    questions = all_questions.copy()
+    random.shuffle(questions)
+    return {"index": 0, "score": 0, "finished": False, "questions": questions}
+
+def get_current_question(state):
+    if state["index"] < len(state["questions"]):
+        current_q = state["questions"][state["index"]]
+        return current_q["question"], current_q["options"]
+    else:
+        state["finished"] = True
+        return "Game Over! Please press 'Restart' to play again.", []
+
+def process_answer(user_answer, state):
+    # If game already finished
+    if state["finished"]:
+        return (
+            "Game Over! Please press 'Restart' to play again.",
+            state,
+            gr.update(choices=[], value=None),
+            "### Game Over!",
+            str(state["score"]),
+        )
+
+    current_q = state["questions"][state["index"]]
+    correct_answer = current_q["answer"]
+
+    if user_answer == correct_answer:
+        state["score"] += 1
+        feedback = "✅ Correct!"
+    else:
+        feedback = f"❌ Incorrect. The correct answer was {correct_answer}."
+
+    # Move to next question
+    state["index"] += 1
+
+    # If no more questions
+    if state["index"] == len(state["questions"]):
+        state["finished"] = True
+        feedback += f" 🎉 Game Over! Your final score is {state['score']}/{len(state['questions'])}."
+        return (
+            feedback,
+            state,
+            gr.update(choices=[], value=None),
+            "### Game Over!",
+            str(state["score"]),
+        )
+
+    # Otherwise show next question
+    new_question, new_options = get_current_question(state)
+    # wrap question in markdown header so it looks nice
+    return (
+        feedback,
+        state,
+        gr.update(choices=new_options, value=None),
+        f"### {new_question}",
+        str(state["score"]),
+    )
+
+def reset_game():
+    new_state = start_game()
+    question, options = get_current_question(new_state)
+    return (
+        new_state,
+        f"### {question}",
+        gr.update(choices=options, value=None),
+        "",
+        "0",
+    )
+
+def load_game():
+    state = start_game()
+    question, options = get_current_question(state)
+    return (
+        state,
+        f"### {question}",
+        gr.update(choices=options, value=None),
+        "0",
+        "",
+    )
+
+# -------------------- UI -------------------- #
+with gr.Blocks() as demo:
+    gr.Markdown("# CNC G-Codes and M-Codes Review")
+
+    # make radio vertical
+    gr.HTML("""
+    <style>
+    .vertical-radio .wrap {
+        display: flex;
+        flex-direction: column;
+        gap: 6px;
+    }
+    </style>
+    """)
+
+    state = gr.State()
+
+    # use Markdown so question auto-sizes
+    question_md = gr.Markdown("## Question will appear here")
+
+    options_buttons = gr.Radio(
+        choices=[],
+        label=" ",
+        interactive=True,
+        elem_classes=["vertical-radio"],
+        show_label=False,
+    )
+
+    with gr.Row():
+        submit_btn = gr.Button("Submit")
+        reset_btn = gr.Button("Restart")
+
+    feedback_box = gr.Textbox(label="Feedback", interactive=False)
+    score_box = gr.Textbox(label="Score", value="0", interactive=False)
+
+    # Submit button logic
+    submit_btn.click(
+        process_answer,
+        inputs=[options_buttons, state],
+        outputs=[feedback_box, state, options_buttons, question_md, score_box],
+    )
+
+    # Restart button logic
+    reset_btn.click(
+        reset_game,
+        inputs=[],
+        outputs=[state, question_md, options_buttons, feedback_box, score_box],
+    )
+
+    # On load, populate first question
+    demo.load(
+        load_game,
+        inputs=None,
+        outputs=[state, question_md, options_buttons, score_box, feedback_box],
+    )
+
+demo.launch()
+
+
+
+# cd 251104_trivia_game/
+# python app.py

questions.tex

@@ -0,0 +1,27 @@
+\begin{questions}
+
+\question
+What is claimed to be the overall advantage of criterion-referred interpretation?
+\choice {An individual's score is compared with the set mastery level}
+        {An individual's score is compared with that of his peers.}
+        {An individual's score is compared with the average scores.}
+        {An individual's score does not to be compared with any measure.}
+        {a}
+
+\question
+Which is an element of norm-referenced grading?
+\choice {The student's past performance.}
+        {An absolute standard}
+        {The performance of the group}
+        {What constitutes a perfect score}
+        {c}
+
+\question
+Which characteristic of good test will pupils be assured of when a teacher constructs a table of specifications for test construction purposes?
+\choice {Authenticity}
+        {Reliability}
+        {Construct Validity}
+        {Content Validity}
+        {d}
+
+\end{questions}