Update app.py

app.py

@@ -1,98 +1,165 @@
 import os
 import json
 import random
-import subprocess
+import sqlite3
 import gradio as gr
 
 from agents import AnalyzerAgent, CoachAgent, PredictiveAgent
-from ocr_agent import OcrAgent
 
 # Paths
-DATA_DIR = "data"
 QUESTIONS_FILE = "questions.json"
-os.makedirs(DATA_DIR, exist_ok=True)
+DB_FILE = "exam.db"
 
-# Load merged question bank
+# Initialize agents
+analyzer = AnalyzerAgent()
+coach = CoachAgent()
+predictor = PredictiveAgent()
+
+
+# ---------- Helpers ----------
 def load_question_bank():
+    """Load questions from JSON file."""
     if not os.path.exists(QUESTIONS_FILE) or os.path.getsize(QUESTIONS_FILE) == 0:
         return []
     try:
         with open(QUESTIONS_FILE, "r", encoding="utf-8") as f:
             return json.load(f)
-    except:
+    except Exception:
         return []
 
-QUESTION_BANK = load_question_bank()
 
-# Initialize agents
-analyzer = AnalyzerAgent()
-coach = CoachAgent()
-predictor = PredictiveAgent()
-ocr_agent = OcrAgent()
-
-# Functions
-def upload_pdf(pdf_file, subject, year, paper):
-    if pdf_file is None:
-        return "⚠️ No file uploaded."
-    questions = ocr_agent.extract_questions(pdf_file, subject, year, paper)
-    subprocess.run(["python", "merge_questions.py"])
-    return f"✅ Extracted {len(questions)} questions from {subject.upper()} Paper {paper} ({year})"
-
-def run_exam(subject, num_questions, include_predicted):
-    pool = [q for q in QUESTION_BANK if subject.lower() in q["source"]]
-    if include_predicted:
-        predicted = predictor.predict(subject)
-        pool.append({"id": 9999, "text": predicted, "choices": [], "topics": [], "source": "predicted"})
-    if not pool:
-        return "⚠️ No questions available.", [], []
-    selected = random.sample(pool, min(num_questions, len(pool)))
-    q_texts = [q["text"] for q in selected]
-    q_ids = [q["id"] for q in selected]
-    return "\n\n".join(q_texts), q_ids, [q.get("choices", []) for q in selected]
-
-def submit_answers(q_ids, answers):
-    correct_answers = ["A"] * len(q_ids)  # Placeholder until scheme data ready
-    score, analysis = analyzer.analyze(answers, correct_answers)
-    return f"Score: {score}/{len(q_ids)}", "\n".join(analysis)
-
-def essay_feedback(essay_text):
-    return coach.coach(essay_text)
-
-# Gradio UI
+def init_db():
+    """Setup SQLite if not exists and sync with JSON."""
+    conn = sqlite3.connect(DB_FILE)
+    cur = conn.cursor()
+    cur.execute("""
+    CREATE TABLE IF NOT EXISTS questions (
+        id INTEGER PRIMARY KEY,
+        text TEXT,
+        choices TEXT,
+        answer TEXT,
+        subject TEXT,
+        paper INTEGER,
+        year INTEGER,
+        image TEXT
+    )""")
+    conn.commit()
+
+    # Sync JSON → DB
+    questions = load_question_bank()
+    for q in questions:
+        cur.execute("INSERT OR IGNORE INTO questions VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+                    (q["id"], q["text"], json.dumps(q["choices"]),
+                     q["answer"], q["subject"], q["paper"], q["year"], q.get("image")))
+    conn.commit()
+    conn.close()
+
+
+def get_questions(subject, paper=2, num_questions=10):
+    """Fetch random questions from DB."""
+    conn = sqlite3.connect(DB_FILE)
+    cur = conn.cursor()
+    cur.execute("SELECT * FROM questions WHERE subject=? AND paper=?", (subject, paper))
+    rows = cur.fetchall()
+    conn.close()
+
+    if not rows:
+        return []
+
+    selected = random.sample(rows, min(num_questions, len(rows)))
+    questions = []
+    for row in selected:
+        questions.append({
+            "id": row[0],
+            "text": row[1],
+            "choices": json.loads(row[2]),
+            "answer": row[3],
+            "subject": row[4],
+            "paper": row[5],
+            "year": row[6],
+            "image": row[7]
+        })
+    return questions
+
+
+# ---------- Exam Logic ----------
+def start_exam(subject, num_questions):
+    """Prepare questions for UI rendering."""
+    questions = get_questions(subject, paper=2, num_questions=num_questions)
+    return questions
+
+
+def submit_exam(answers, questions):
+    """Evaluate submitted answers."""
+    correct = 0
+    wrong_details = []
+
+    for q, ans in zip(questions, answers):
+        if ans == q["answer"]:
+            correct += 1
+        else:
+            wrong_details.append(f"Q{q['id']}: Correct answer was {q['answer']}")
+
+    score_text = f"Score: {correct}/{len(questions)}\nCorrect: {correct}, Wrong: {len(questions) - correct}"
+    analysis = coach.coach("Student got result: " + score_text)
+    return score_text, "\n".join(wrong_details), analysis
+
+
+# ---------- Gradio UI ----------
 with gr.Blocks() as demo:
     gr.Markdown("## 📝 SPM Exam Simulator (Form 5)")
 
-    with gr.Tab("Upload Past Papers"):
-        pdf_file = gr.File(label="Upload PDF", type="filepath")
-        subject = gr.Dropdown(["BM", "English", "Math", "History", "Science", "MoralStudies"], label="Subject")
-        year = gr.Number(label="Year", value=2018, precision=0)
-        paper = gr.Dropdown([1, 2], label="Paper")
-        upload_btn = gr.Button("Process PDF")
-        upload_out = gr.Textbox(label="Upload Status")
-        upload_btn.click(fn=upload_pdf, inputs=[pdf_file, subject, year, paper], outputs=upload_out)
-
     with gr.Tab("Paper 2 Simulator"):
         subject_sim = gr.Dropdown(["BM", "English", "Math", "History", "Science", "MoralStudies"], label="Subject")
         num_q = gr.Slider(1, 50, step=1, value=10, label="Number of Questions")
-        include_pred = gr.Checkbox(label="Include AI-Predicted")
-        run_btn = gr.Button("Start Simulation")
-        q_out = gr.Textbox(label="Questions")
-        ids_out = gr.State()
-        choices_out = gr.State()
-        run_btn.click(fn=run_exam, inputs=[subject_sim, num_q, include_pred], outputs=[q_out, ids_out, choices_out])
-
-        ans_in = gr.Textbox(label="Your Answers (comma-separated, e.g. A,B,C)")
-        submit_btn = gr.Button("Submit")
-        score_out = gr.Textbox(label="Score")
-        analysis_out = gr.Textbox(label="Analysis")
-        submit_btn.click(fn=lambda ids, ans: submit_answers(ids, ans.split(",")),
-                         inputs=[ids_out, ans_in], outputs=[score_out, analysis_out])
-
-    with gr.Tab("Paper 1 (Essay Practice)"):
-        essay_in = gr.Textbox(label="Write your essay here", lines=10)
-        essay_btn = gr.Button("Get Feedback")
-        essay_out = gr.Textbox(label="Feedback")
-        essay_btn.click(fn=essay_feedback, inputs=essay_in, outputs=essay_out)
+        run_btn = gr.Button("Start Exam")
+
+        question_state = gr.State()
+        answer_inputs = []
+
+        exam_area = gr.Column(visible=False)
+        results_area = gr.Column(visible=False)
+
+        with exam_area:
+            question_boxes = []
+            for i in range(50):  # max 50
+                q_text = gr.Markdown(visible=False)
+                q_img = gr.Image(type="filepath", visible=False)
+                q_choice = gr.Radio(choices=[], label=f"Answer Q{i+1}", visible=False)
+                question_boxes.append((q_text, q_img, q_choice))
+                answer_inputs.append(q_choice)
+            submit_btn = gr.Button("Submit")
+
+        with results_area:
+            score_out = gr.Textbox(label="Score")
+            wrong_out = gr.Textbox(label="Wrong Answers")
+            advice_out = gr.Textbox(label="AI Advice")
+
+        # Start exam
+        def render_exam(subject, num):
+            qs = start_exam(subject, num)
+            updates = []
+            for i, q in enumerate(qs):
+                updates.append(gr.update(value=f"**Q{i+1}. {q['text']}**", visible=True))  # text
+                updates.append(gr.update(value=q["image"], visible=bool(q["image"])))      # image
+                updates.append(gr.update(choices=q["choices"], visible=True))              # choices
+            # Hide unused slots
+            for j in range(len(qs), 50):
+                updates.extend([gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)])
+            return [qs, gr.update(visible=True), *updates]
+
+        run_btn.click(render_exam, [subject_sim, num_q], [question_state, exam_area] + sum(question_boxes, ()))
+
+        # Submit exam
+        submit_btn.click(
+            fn=submit_exam,
+            inputs=[answer_inputs, question_state],
+            outputs=[score_out, wrong_out, advice_out]
+        ).then(lambda: gr.update(visible=True), None, results_area)
+
+
+# Init DB before launch
+init_db()
 
 demo.launch(server_name="0.0.0.0", server_port=7860)
 
@@ -117,5 +184,6 @@ demo.launch(server_name="0.0.0.0", server_port=7860)
 
 
 
+