Update app.py

app.py

@@ -4,98 +4,66 @@ import os
 import gradio as gr
 from agents import AnalyzerAgent, CoachAgent, PredictiveAgent
 
-# Paths
 QUESTIONS_FILE = "questions.json"
 PREDICTIONS_CACHE = "predictions_cache.json"
 
-# Load questions (merged bank)
 if not os.path.exists(QUESTIONS_FILE):
-    # create minimal placeholder
     with open(QUESTIONS_FILE, "w", encoding="utf-8") as f:
-        json.dump([], f, indent=2, ensure_ascii=False)
+        json.dump([], f, indent=2)
 
 with open(QUESTIONS_FILE, "r", encoding="utf-8") as f:
     QUESTION_BANK = json.load(f)
 
-# Ensure predictions cache exists
 if not os.path.exists(PREDICTIONS_CACHE):
     with open(PREDICTIONS_CACHE, "w", encoding="utf-8") as f:
         json.dump({}, f)
 
-# Agents
 analyzer = AnalyzerAgent()
 coach_agent = CoachAgent()
 predictor = PredictiveAgent(cache_path=PREDICTIONS_CACHE)
 
 def ensure_predictions_injected(level, subject, n=8):
-    """
-    Ensure predicted questions for level+subject are generated, cached and injected into QUESTION_BANK.
-    Predictions are stored in predictions_cache.json and also appended to in-memory QUESTION_BANK
-    with a 'source': 'predicted' flag and high id space (>=900000).
-    """
     key = f"{level}_{subject}"
-    # Load cache
     with open(predictor.cache_path, "r", encoding="utf-8") as f:
         cache = json.load(f)
 
     if key in cache and cache[key].get("injected"):
-        # already injected into QUESTION_BANK in this process run
         return
 
-    # ensure we have predictions (generate or fetch)
     preds = predictor.get_or_generate_predictions(level, subject, QUESTION_BANK, n=n)
 
-    # assign unique high IDs and append to in-memory bank and cache
-    next_pred_id = 900000
+    next_id = 900000
     existing_ids = {q["id"] for q in QUESTION_BANK}
-    while next_pred_id in existing_ids:
-        next_pred_id += 1
+    while next_id in existing_ids:
+        next_id += 1
 
-    appended = []
     for p in preds:
-        # create full question structure expected by app
-        q = {
-            "id": next_pred_id,
+        QUESTION_BANK.append({
+            "id": next_id,
             "subject": f"{level}_{subject}",
             "question_type": p.get("question_type", "mcq"),
             "text": p.get("text"),
             "choices": p.get("choices", []),
             "correct_answer": p.get("predicted_answer", ""),
-            "topics": p.get("topics", []),
+            "topics": [p.get("topic", "general")],
             "difficulty": p.get("difficulty", 3),
-            "source": "predicted"  # invisible flag
-        }
-        QUESTION_BANK.append(q)
-        appended.append(q)
-        next_pred_id += 1
+            "source": "predicted"
+        })
+        next_id += 1
 
-    # update cache to mark injected (and save predicted objects)
     cache[key] = {"predictions": preds, "injected": True}
     with open(predictor.cache_path, "w", encoding="utf-8") as f:
         json.dump(cache, f, indent=2, ensure_ascii=False)
 
-    # Optionally persist updated QUESTION_BANK (not required; merge script is authoritative)
-    # with open(QUESTIONS_FILE, "w", encoding="utf-8") as f:
-    #     json.dump(QUESTION_BANK, f, indent=2, ensure_ascii=False)
-
-    return appended
-
 def start_exam(level, subject, num_questions=10, include_predicted=True):
-    """
-    Start a randomized exam. If include_predicted is True, predictions will be ensured and mixed
-    invisibly into the pool before sampling.
-    """
     if include_predicted:
-        # ensure predictions are in in-memory bank
         ensure_predictions_injected(level, subject, n=8)
 
-    # Pool all questions for that level + subject (subject uses format Level_Subject, e.g., Form5_Math)
     pool = [q for q in QUESTION_BANK if q.get("subject") == f"{level}_{subject}"]
 
     if not pool:
-        return [], gr.update(visible=False), gr.update(visible=False), gr.update(visible=True)
+        return [], gr.update(visible=False), gr.update(visible=False), gr.update(visible=True), []
 
-    # Shuffle and pick
     random.shuffle(pool)
     selected = pool[:min(num_questions, len(pool))]
 
@@ -103,32 +71,28 @@ def start_exam(level, subject, num_questions=10, include_predicted=True):
         {"id": q["id"], "text": q["text"], "choices": q.get("choices", []), "topics": q.get("topics", [])}
         for q in selected
     ]
-    return exam_data, gr.update(visible=True), gr.update(visible=False), gr.update(visible=False)
+    return exam_data, gr.update(visible=True), gr.update(visible=False), gr.update(visible=False), exam_data
 
 def submit_exam(answers, exam_data, level, subject):
     if not exam_data:
-        return "No questions found for selected level/subject.", {}, {}, {}, gr.update(visible=False), gr.update(visible=True)
+        return "No questions found.", {}, {}, {}, gr.update(visible=False), gr.update(visible=True)
 
     correct = 0
     per_question = {}
     for q in exam_data:
         qid = str(q["id"])
-        user_ans = answers.get(qid, None)
+        user_ans = answers.get(qid)
         orig = next((item for item in QUESTION_BANK if item["id"] == q["id"]), None)
         correct_ans = orig.get("correct_answer") if orig else None
         per_question[qid] = {"user": user_ans, "correct": correct_ans, "topics": q.get("topics", [])}
-        if user_ans is not None and correct_ans is not None and str(user_ans).strip() == str(correct_ans).strip():
+        if user_ans and correct_ans and str(user_ans).strip() == str(correct_ans).strip():
             correct += 1
 
     score = round(100 * correct / len(exam_data), 2)
 
-    # Analyzer (via GLM)
     analysis = analyzer.analyze(per_question)
-
-    # Coach (via GLM)
     coach = coach_agent.coach(analysis, level, subject)
 
-    # Predictor summary for UI (predictions are cached & may have been injected)
     with open(predictor.cache_path, "r", encoding="utf-8") as f:
         cache = json.load(f)
     pred_key = f"{level}_{subject}"
@@ -145,22 +109,27 @@ def submit_exam(answers, exam_data, level, subject):
 
 # Gradio UI
 with gr.Blocks() as demo:
-    gr.Markdown("## 📘 SPM Exam Simulator with Invisible Predictions")
+    gr.Markdown("## 📘 SPM Exam Simulator (2018–2024) with AI Predictions")
 
     with gr.Row():
-        level = gr.Dropdown(["Form5"], value="Form5", label="Select Level (SPM = Form5)")
-        subject = gr.Dropdown(["Math", "Science", "Physics", "Chemistry", "Biology"], value="Math", label="Select Subject")
-        num_q = gr.Slider(minimum=5, maximum=50, step=5, value=10, label="Number of Questions")
-        include_pred = gr.Checkbox(value=True, label="Include AI-predicted questions (hidden to student)")
-        start_btn = gr.Button("Start Randomized Practice (mixed pool)")
+        level = gr.Dropdown(["Form5"], value="Form5", label="Level (SPM=Form5)")
+        subject = gr.Dropdown(
+            ["BM", "English", "Math", "History", "Science", "MoralStudies",
+             "Accounting", "Economics", "Business"],
+            value="Math",
+            label="Subject"
+        )
+        num_q = gr.Slider(5, 50, step=5, value=10, label="Number of Questions")
+        include_pred = gr.Checkbox(True, label="Include AI-predicted")
+        start_btn = gr.Button("Start Exam")
 
     exam_output = gr.State()
 
     exam_area = gr.Column(visible=False)
     with exam_area:
-        gr.Markdown("### Exam Questions (edit your answers as JSON: {id: 'choice or text'})")
-        exam_display = gr.JSON(label="Questions")
-        answers_box = gr.JSON(label="Your Answers (e.g. {\"900001\":\"A\",\"1002\":\"2/3\"})")
+        gr.Markdown("### Questions")
+        exam_display = gr.JSON(label="Exam")
+        answers_box = gr.JSON(label="Your Answers")
         submit_btn = gr.Button("Submit Exam")
 
     results_area = gr.Column(visible=False)
@@ -170,17 +139,15 @@ with gr.Blocks() as demo:
             analysis_json = gr.JSON()
         with gr.Tab("Study Coach"):
             coach_json = gr.JSON()
-        with gr.Tab("SPM Predictions (admin)"):
+        with gr.Tab("Predictions (Admin)"):
             predictions_json = gr.JSON()
 
-    # start exam -> show exam_area
     start_btn.click(
         start_exam,
         inputs=[level, subject, num_q, include_pred],
-        outputs=[exam_display, exam_area, results_area, score_text]
-    ).then(lambda x: x, outputs=exam_output)
+        outputs=[exam_display, exam_area, results_area, score_text, exam_output]
+    )
 
-    # submit exam -> produce results & predictions
     submit_btn.click(
         submit_exam,
         inputs=[answers_box, exam_output, level, subject],
@@ -193,3 +160,4 @@ if __name__ == "__main__":
 
 
 
+