Update app.py

app.py

@@ -2,6 +2,7 @@ import gradio as gr
 import random
 import json
 from fpdf import FPDF
+import os
 
 # Load question bank
 with open("questions.json", "r", encoding="utf-8") as f:
@@ -11,55 +12,108 @@ with open("questions.json", "r", encoding="utf-8") as f:
 def get_random_questions():
     return random.sample(question_bank, 50)
 
-# Function to evaluate answers
+# Function to evaluate answers (handles single or multiple-correct formats)
 def evaluate_test(student_name, father_name, roll_no, answers, questions):
-    attempted = sum([1 for a in answers if a is not None and a != ""])
+    # answers: list of 50 selected option strings (or None)
+    attempted = sum(1 for a in answers if a is not None and a != "")
     correct = 0
     for q, ans in zip(questions, answers):
-        if ans == q["answer"]:
-            correct += 1
-    percentage = (correct / len(questions)) * 100
-
-    # Generate PDF report
+        if ans is None or ans == "":
+            continue
+        correct_key = q.get("answer")
+        # support either a single string or a list of accepted answers
+        if isinstance(correct_key, list):
+            if ans in correct_key:
+                correct += 1
+        else:
+            if ans == correct_key:
+                correct += 1
+
+    total = len(questions) if questions else 0
+    percentage = (correct / total) * 100 if total > 0 else 0.0
+
+    # Generate PDF report (safe encoding)
     pdf = FPDF()
     pdf.add_page()
     pdf.set_font("Arial", size=12)
     pdf.cell(200, 10, txt="Test Report - Class 6 General Knowledge", ln=True, align="C")
     pdf.ln(10)
-    pdf.cell(200, 10, txt=f"Student Name: {student_name}", ln=True)
-    pdf.cell(200, 10, txt=f"Father's Name: {father_name}", ln=True)
-    pdf.cell(200, 10, txt=f"Roll No: {roll_no}", ln=True)
-    pdf.ln(10)
-    pdf.cell(200, 10, txt=f"Total Questions: {len(questions)}", ln=True)
-    pdf.cell(200, 10, txt=f"Attempted: {attempted}", ln=True)
-    pdf.cell(200, 10, txt=f"Correct: {correct}", ln=True)
-    pdf.cell(200, 10, txt=f"Percentage: {percentage:.2f}%", ln=True)
 
-    file_name = f"{roll_no}_result.pdf"
+    # Use latin-1 replacement to avoid crashes for non-latin characters
+    def safe_text(t):
+        return str(t).encode("latin-1", "replace").decode("latin-1")
+
+    pdf.cell(200, 8, txt=safe_text(f"Student Name: {student_name}"), ln=True)
+    pdf.cell(200, 8, txt=safe_text(f"Father's Name: {father_name}"), ln=True)
+    pdf.cell(200, 8, txt=safe_text(f"Roll No: {roll_no}"), ln=True)
+    pdf.ln(6)
+    pdf.cell(200, 8, txt=f"Total Questions: {total}", ln=True)
+    pdf.cell(200, 8, txt=f"Attempted: {attempted}", ln=True)
+    pdf.cell(200, 8, txt=f"Correct: {correct}", ln=True)
+    pdf.cell(200, 8, txt=f"Percentage: {percentage:.2f}%", ln=True)
+
+    # Save file
+    safe_roll = roll_no if roll_no else "student"
+    file_name = f"{safe_roll}_result.pdf"
+    # ensure unique filename to avoid race conditions
+    idx = 0
+    base_name = file_name
+    while os.path.exists(file_name):
+        idx += 1
+        file_name = f"{safe_roll}_result_{idx}.pdf"
+
     pdf.output(file_name)
 
-    result_summary = f"""
-    Student: {student_name}  
-    Father's Name: {father_name}  
-    Roll No: {roll_no}  
-    
-    Attempted: {attempted}  
-    Correct: {correct}  
-    Percentage: {percentage:.2f}%
-    """
+    result_summary = (
+        f"Student: {student_name}\n"
+        f"Father's Name: {father_name}\n"
+        f"Roll No: {roll_no}\n\n"
+        f"Attempted: {attempted}\n"
+        f"Correct: {correct}\n"
+        f"Percentage: {percentage:.2f}%"
+    )
 
     return result_summary, file_name
 
-# Build Gradio interface dynamically
+# Build Gradio interface using Blocks
 def build_interface():
-    def run_test(student_name, father_name, roll_no, *answers, questions):
+    def run_test(*args):
+        """
+        args layout:
+        0: student_name
+        1: father_name
+        2: roll_no
+        3..52: answer values for Q1..Q50
+        53: questions state (list of 50 question dicts)
+        """
+        if len(args) < 4:
+            return "Invalid input.", None
+
+        student_name = args[0]
+        father_name = args[1]
+        roll_no = args[2]
+        # answers are args[3] .. args[-2], last arg is questions
+        if len(args) < 5:
+            # no answers provided
+            answers = []
+            questions = []
+        else:
+            questions = args[-1]
+            answers = list(args[3:-1])
+
+        # Safety: if questions is a single dict (shouldn't be) or None, handle gracefully
+        if not isinstance(questions, list):
+            questions = list(questions) if questions else []
+
         return evaluate_test(student_name, father_name, roll_no, answers, questions)
 
-    # Update UI with fresh random questions
-    def update_questions(questions):
+    def update_questions_ui(questions):
+        """Return 50 gr.update objects to populate radio labels and choices."""
         updates = []
         for i, q in enumerate(questions):
-            updates.append(gr.update(label=f"Q{i+1}: {q['question']}", choices=q["options"], value=None))
+            updates.append(
+                gr.update(label=f"Q{i+1}: {q.get('question','')}", choices=q.get("options", []), value=None)
+            )
         return updates
 
     with gr.Blocks() as demo:
@@ -70,42 +124,42 @@ def build_interface():
         father_name = gr.Textbox(label="Father's Name")
         roll_no = gr.Textbox(label="Roll No")
 
-        # State to store current random questions
+        # State to store current random questions (list of 50 question dicts)
         question_state = gr.State(get_random_questions())
 
+        # Create 50 radio inputs
         answer_inputs = []
         with gr.Accordion("Questions", open=True):
             for i in range(50):
-                q_radio = gr.Radio(label=f"Q{i+1}", choices=[])
-                answer_inputs.append(q_radio)
+                r = gr.Radio(label=f"Q{i+1}", choices=[])
+                answer_inputs.append(r)
 
         output_text = gr.Textbox(label="Result Summary")
         output_file = gr.File(label="Download Result PDF")
 
-        # Buttons
         submit_btn = gr.Button("Submit Test", variant="primary")
         new_test_btn = gr.Button("New Test", variant="secondary")
 
-        # Load first set of questions when app starts
-        demo.load(update_questions, inputs=question_state, outputs=answer_inputs)
+        # On load, populate the 50 radios using the question_state
+        demo.load(update_questions_ui, inputs=question_state, outputs=answer_inputs)
 
-        # Submit button → evaluate answers
+        # Submit test -> run_test which parses args and calls evaluate_test
         submit_btn.click(
             run_test,
             inputs=[student_name, father_name, roll_no] + answer_inputs + [question_state],
-            outputs=[output_text, output_file]
+            outputs=[output_text, output_file],
         )
 
-        # New Test button → refresh with fresh 50 questions
+        # New Test -> generate fresh questions and update state + radios
         def refresh():
             qs = get_random_questions()
-            # return new state + 50 UI updates
-            return [qs] + update_questions(qs)
+            # return list whose first element will set question_state, followed by 50 radio updates
+            return [qs] + update_questions_ui(qs)
 
         new_test_btn.click(
             refresh,
             inputs=None,
-            outputs=[question_state] + answer_inputs
+            outputs=[question_state] + answer_inputs,
         )
 
     return demo