Update app.py

app.py

@@ -1,146 +1,159 @@
-import os
 import gradio as gr
-from demo_questions import QUESTIONS
-from zhipuai import ZhipuAI
+import random
+
+# -------------------------------
+# Demo Exam Data
+# -------------------------------
+QUESTIONS = {
+    "Bahasa Melayu Paper 1": [
+        {"text": "Tulis sebuah karangan tentang kepentingan membaca.", "answer": None},
+        {"text": "Huraikan peranan teknologi dalam kehidupan seharian.", "answer": None},
+    ],
+    "Bahasa Melayu Paper 2": [
+        {"text": "Apakah kata dasar bagi perkataan 'berjalan'?",
+         "choices": ["A. Ber", "B. Jalan", "C. An", "D. Jal"], "answer": "B"},
+        {"text": "Peribahasa 'harapkan pegar, pegar makan padi' bermaksud?",
+         "choices": ["A. Orang rajin", "B. Pengkhianatan oleh penjaga", "C. Hidup susah", "D. Orang baik hati"], "answer": "B"},
+    ],
+    "English Paper 1": [
+        {"text": "Write an essay about the importance of sports.", "answer": None},
+        {"text": "Describe a memorable day at school.", "answer": None},
+    ],
+    "English Paper 2": [
+        {"text": "Choose the correct synonym for 'happy'.",
+         "choices": ["A. Sad", "B. Joyful", "C. Angry", "D. Tired"], "answer": "B"},
+        {"text": "What is the plural of 'child'?",
+         "choices": ["A. Childs", "B. Childes", "C. Children", "D. Childer"], "answer": "C"},
+    ],
+}
+
+# -------------------------------
+# Load Exam Function
+# -------------------------------
+def load_exam(subject):
+    questions = QUESTIONS.get(subject, [])
+    outputs = []
 
-# Initialize ZhipuAI client
-ZHIPU_API_KEY = os.getenv("ZHIPU_API_KEY", "")
-client = ZhipuAI(api_key=ZHIPU_API_KEY)
+    for i, q in enumerate(questions, 1):
+        # Display question text
+        outputs.append(f"**Q{i}:** {q['text']}")
 
-# Store student answers
-student_answers = {}
+        # Subjective Paper → Textbox
+        if "choices" not in q:
+            outputs.append("")  # empty string = textbox placeholder
 
+        # Objective Paper → Radio buttons
+        else:
+            outputs.append({"choices": q["choices"], "value": None})
 
-def load_exam(subject, paper):
-    """Load selected subject & paper questions."""
-    if subject not in QUESTIONS or paper not in QUESTIONS[subject]:
-        return [gr.Markdown("⚠️ No questions available for this selection.")]
+    return outputs, questions
 
-    qlist = QUESTIONS[subject][paper]
-    student_answers.clear()  # reset before new exam
 
-    outputs = []
-    for i, q in enumerate(qlist):
-        # Store internally but only show text to student
-        student_answers[i] = {
-            "id": q.get("id"),
-            "question": q.get("text"),
-            "choices": q.get("choices"),
-            "answer": q.get("answer"),
-            "student_answer": None,
-            "paper": paper,
-        }
-
-        outputs.append(gr.Markdown(f"**Q{i+1}:** {q['text']}"))
-
-        if q.get("choices"):
-            outputs.append(
-                gr.Radio(
-                    choices=q["choices"],
-                    label=f"Your Answer for Q{i+1}",
-                    interactive=True,
-                    key=f"q{i+1}",
-                )
-            )
-        else:
-            outputs.append(
-                gr.Textbox(
-                    label=f"Your Answer for Q{i+1}",
-                    interactive=True,
-                    key=f"q{i+1}",
-                )
-            )
-
-    return outputs
-
-
-def grade_with_zhipu(question, student_answer, expected_answer=None):
-    """Ask ZhipuAI to grade subjective answers."""
-    try:
-        prompt = f"""
-You are an exam grader.
-
-Question: {question}
-Student Answer: {student_answer}
-Expected Answer (if provided): {expected_answer or "N/A"}
-
-Grade strictly:
-- Give a score from 0 to 1 (0 = wrong, 1 = fully correct, 0.5 if partially correct).
-- Provide a short feedback (1-2 sentences).
-Return in JSON format with keys: 'score', 'feedback'.
-"""
-        response = client.chat.completions.create(
-            model="glm-4-air",  # lightweight for grading
-            messages=[{"role": "user", "content": prompt}],
-            temperature=0.2,
-        )
-        result = response.choices[0].message["content"].strip()
-
-        # Try to parse JSON-like structure
-        if "'score'" in result or '"score"' in result:
-            return result
-        return '{"score": 0, "feedback": "LLM could not evaluate."}'
-
-    except Exception as e:
-        return f'{{"score": 0, "feedback": "Error grading with LLM: {str(e)}"}}'
-
-
-def submit_exam(*responses):
-    """Process submission, calculate score, and show results."""
+# -------------------------------
+# Submit Exam Function
+# -------------------------------
+def submit_exam(answers, questions):
     score = 0
-    total = len(student_answers)
-
-    for i, response in enumerate(responses):
-        student_answers[i]["student_answer"] = response
+    results = []
 
-    review = []
-    for i, q in student_answers.items():
-        correct = q["answer"]
-        student = q["student_answer"]
-
-        # Paper 2: objective auto-marking
-        if q["choices"]:
-            if student == correct:
+    for ans, q in zip(answers, questions):
+        if "choices" in q:  # objective paper
+            correct = q["answer"]
+            if ans == correct:
                 score += 1
-                result = f"✅ Q{i+1}: Correct! (Your Answer: {student})"
+                results.append(f"✅ {q['text']} → Your answer: {ans} (Correct)")
             else:
-                result = f"❌ Q{i+1}: Wrong (Your Answer: {student}, Correct: {correct})"
-            review.append(result)
-
-        # Paper 1: subjective → LLM grading
-        else:
-            llm_feedback = grade_with_zhipu(q["question"], student, correct)
-            review.append(f"✏️ Q{i+1}: Essay Graded → {llm_feedback}")
+                results.append(f"❌ {q['text']} → Your answer: {ans}, Correct answer: {correct}")
+        else:  # subjective paper
+            results.append(f"📝 {q['text']} → Your response recorded.")
 
-    summary = f"## Exam Finished!\n\n**Score: {score} / {total}**\n\n" + "\n".join(
-        review
-    )
-    return summary
+    return f"Your Score: {score} / {len(questions)}", "\n\n".join(results)
 
 
+# -------------------------------
+# Build Gradio UI
+# -------------------------------
 with gr.Blocks() as demo:
-    gr.Markdown("# 🎓 SPM Exam Simulator (with ZhipuAI Grading)")
-
-    with gr.Row():
-        subject = gr.Dropdown(choices=list(QUESTIONS.keys()), label="Select Subject")
-        paper = gr.Dropdown(choices=["Paper1", "Paper2"], label="Select Paper")
+    gr.Markdown("## 📘 SPM Exam Simulator")
 
+    subject = gr.Dropdown(list(QUESTIONS.keys()), label="Select Subject")
     load_btn = gr.Button("Load Exam")
 
-    exam_area = gr.Column()
+    question_boxes = []
+    answer_inputs = []
+
+    # Preallocate 10 slots (max 10 questions per subject for demo)
+    for i in range(10):
+        qtext = gr.Markdown(visible=False)
+        atext = gr.Textbox(visible=False, label="Your Answer")
+        aradio = gr.Radio(visible=False, label="Select Answer")
+        question_boxes.append((qtext, atext, aradio))
+        answer_inputs.append((atext, aradio))
+
+    submit_btn = gr.Button("Submit", visible=False)
+    score_output = gr.Markdown()
+    detail_output = gr.Markdown()
+    state_questions = gr.State()
+
+    def on_load(subject):
+        outputs, questions = load_exam(subject)
+
+        # Reset UI
+        updates = []
+        answers_state = []
+
+        for i, (qtext, atext, aradio) in enumerate(question_boxes):
+            if i < len(questions):
+                q = questions[i]
+                qtext.update(value=f"**Q{i+1}:** {q['text']}", visible=True)
+
+                if "choices" in q:  # objective
+                    atext.update(visible=False)
+                    aradio.update(choices=q["choices"], value=None, visible=True)
+                    answers_state.append(None)
+                else:  # subjective
+                    aradio.update(visible=False)
+                    atext.update(value="", visible=True)
+                    answers_state.append("")
+            else:
+                qtext.update(visible=False)
+                atext.update(visible=False)
+                aradio.update(visible=False)
+
+            updates.extend([qtext, atext, aradio])
 
-    submit_btn = gr.Button("Submit Answers")
-    result_box = gr.Markdown("")
+        return updates + [gr.Button.update(visible=True), questions]
 
-    def render_exam(subject, paper):
-        return load_exam(subject, paper)
+    def on_submit(*all_inputs):
+        # all_inputs includes answers + state_questions
+        *answers, questions = all_inputs
+
+        # Extract answers: pick from textbox or radio
+        processed = []
+        for (txt, rad), ans in zip(answer_inputs, answers):
+            if isinstance(ans, str):
+                processed.append(ans)
+            elif isinstance(ans, dict) and "value" in ans:
+                processed.append(ans["value"])
+            else:
+                processed.append(None)
 
-    load_btn.click(render_exam, inputs=[subject, paper], outputs=exam_area)
+        return submit_exam(processed, questions)
+
+    load_btn.click(
+        fn=on_load,
+        inputs=[subject],
+        outputs=[comp for triple in question_boxes for comp in triple] + [submit_btn, state_questions],
+    )
+
+    submit_btn.click(
+        fn=on_submit,
+        inputs=[comp for pair in answer_inputs for comp in pair] + [state_questions],
+        outputs=[score_output, detail_output],
+    )
 
-    submit_btn.click(submit_exam, inputs=exam_area, outputs=result_box)
+demo.launch(server_name="0.0.0.0", server_port=7860)
 
-if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860, ssr_mode=True)