Update app.py

app.py

@@ -1,4 +1,3 @@
-# app.py
 import json
 import random
 import csv
@@ -8,26 +7,16 @@ from pathlib import Path
 import gradio as gr
 
 # ---------- Helpers ----------
-def load_questions_from_uploaded_or_repo(uploaded_file, repo_path="questions.json"):
-    """
-    Expect JSON of one of the following shapes:
-    - A list of objects: [{"question":"...","options":["A","B","C","D"],"answer":"A" or 0}, ...]
-    - Or { "questions": [ ... ] }
-    The 'answer' can be index (int) or option text (str).
-    """
-    data = None
+def load_questions_from_uploaded_or_repo(uploaded_file, repo_path="./questions.json"):
     if uploaded_file is not None:
-        # uploaded_file is a tempfile path
         with open(uploaded_file.name, "r", encoding="utf-8") as f:
             data = json.load(f)
     else:
-        # fallback to repo_path
         if not Path(repo_path).exists():
             return []
         with open(repo_path, "r", encoding="utf-8") as f:
             data = json.load(f)
 
-    # Normalize
     if isinstance(data, dict) and "questions" in data:
         data = data["questions"]
     if not isinstance(data, list):
@@ -35,192 +24,124 @@ def load_questions_from_uploaded_or_repo(uploaded_file, repo_path="questions.jso
 
     normalized = []
     for item in data:
-        q = {}
-        q_text = item.get("question") or item.get("q") or item.get("prompt")
-        opts = item.get("options") or item.get("choices") or item.get("opts")
-        ans = item.get("answer") or item.get("correct") or item.get("ans")
+        q_text = item.get("question")
+        opts = item.get("options")
+        ans = item.get("answer")
         if q_text is None or not opts:
             continue
-        # ensure options is list of strings
         opts = [str(o) for o in opts]
-        # canonicalize answer to index if possible
         answer_index = None
-        if isinstance(ans, int):
-            answer_index = ans if 0 <= ans < len(opts) else None
+        if isinstance(ans, int) and 0 <= ans < len(opts):
+            answer_index = ans
         elif isinstance(ans, str):
-            # try exact match first
             if ans in opts:
                 answer_index = opts.index(ans)
             else:
-                # maybe ans is 'A','B','C' or '1','2' etc.
-                mapping = {chr(65+i): i for i in range(len(opts))}  # A->0, B->1...
+                mapping = {chr(65+i): i for i in range(len(opts))}
                 if ans.upper() in mapping:
                     answer_index = mapping[ans.upper()]
-                else:
-                    try:
-                        idx = int(ans) - 1
-                        if 0 <= idx < len(opts):
-                            answer_index = idx
-                    except:
-                        answer_index = None
-        # push normalized
         normalized.append({
-            "question": str(q_text),
+            "question": q_text,
             "options": opts,
-            "answer_index": answer_index  # may be None (we'll treat as ungradable)
+            "answer_index": answer_index
         })
     return normalized
 
 def sample_questions(q_list, n=100):
-    if len(q_list) <= n:
-        return q_list.copy()
-    return random.sample(q_list, n)
+    return q_list if len(q_list) <= n else random.sample(q_list, n)
 
 def score_answers(sampled, answers):
-    # answers: list of chosen index (or None)
-    correct = 0
-    total_gradable = 0
+    correct, total = 0, 0
     per_q = []
     for q, a in zip(sampled, answers):
-        ai = a
         correct_idx = q.get("answer_index")
         if correct_idx is None:
-            # ungradable
             is_correct = None
         else:
-            total_gradable += 1
-            is_correct = (ai == correct_idx)
+            total += 1
+            is_correct = (a == correct_idx)
             if is_correct:
                 correct += 1
-        per_q.append({
-            "question": q["question"],
-            "options": q["options"],
-            "correct_index": correct_idx,
-            "chosen_index": ai,
-            "is_correct": is_correct
-        })
-    percentage = (correct / total_gradable * 100) if total_gradable > 0 else 0.0
-    return correct, total_gradable, percentage, per_q
+        per_q.append({**q, "chosen_index": a, "is_correct": is_correct})
+    percentage = (correct / total * 100) if total > 0 else 0
+    return correct, total, percentage, per_q
 
-def results_to_csv(personal_info, per_q, out_dir="/tmp"):
+def results_to_csv(info, per_q, out_dir="results"):
     ts = int(time.time())
-    fname = f"test_result_{personal_info['name'].replace(' ','_')}_{ts}.csv"
-    path = os.path.join(out_dir, fname)
+    fname = f"test_result_{info['name'].replace(' ','_')}_{ts}.csv"
     os.makedirs(out_dir, exist_ok=True)
-    with open(path, "w", newline='', encoding="utf-8") as csvfile:
-        writer = csv.writer(csvfile)
-        # header
-        writer.writerow(["Name", personal_info.get("name",""),
-                         "Father's Name", personal_info.get("father",""),
-                         "Contact", personal_info.get("contact","")])
+    path = os.path.join(out_dir, fname)
+    with open(path, "w", newline='', encoding="utf-8") as f:
+        writer = csv.writer(f)
+        writer.writerow(["Name", info.get("name",""),
+                         "Father's Name", info.get("father",""),
+                         "Contact", info.get("contact","")])
         writer.writerow([])
-        writer.writerow(["Q#", "Question", "Option_1", "Option_2", "Option_3", "Option_4", "Chosen_Index", "Correct_Index", "Is_Correct"])
-        for i, q in enumerate(per_q, start=1):
-            opts = q["options"] + [""]* (4 - len(q["options"])) if len(q["options"]) < 4 else q["options"]
-            writer.writerow([i, q["question"], opts[0], opts[1], opts[2] if len(opts)>2 else "", opts[3] if len(opts)>3 else "", q["chosen_index"], q["correct_index"], q["is_correct"]])
+        writer.writerow(["Q#", "Question", "Options", "Chosen", "Correct", "Is_Correct"])
+        for i, q in enumerate(per_q, 1):
+            writer.writerow([i, q["question"], "; ".join(q["options"]),
+                             q["chosen_index"], q["answer_index"], q["is_correct"]])
     return path
 
-# ---------- Gradio app ----------
+# ---------- Gradio UI ----------
 with gr.Blocks(title="Chemical Engineering MCQ Tester") as demo:
-    gr.Markdown("# Chemical Engineering MCQ Tester\nUpload your JSON question bank (or keep repo file `questions.json`) → Start test → answer 100 randomized MCQs → download results")
+    gr.Markdown("# Chemical Engineering MCQ Tester")
 
     with gr.Row():
         with gr.Column(scale=1):
-            name = gr.Textbox(label="Name", placeholder="Candidate full name", interactive=True)
-            father = gr.Textbox(label="Father's Name", placeholder="Father's full name", interactive=True)
-            contact = gr.Textbox(label="Contact Number", placeholder="e.g. +92-300-1234567", interactive=True)
-            upload = gr.File(label="Upload JSON question bank (optional)", file_count="single", file_types=[".json"])
-            generate = gr.Button("Start Test (generate 100 random MCQs)")
+            name = gr.Textbox(label="Name")
+            father = gr.Textbox(label="Father's Name")
+            contact = gr.Textbox(label="Contact Number")
+            upload = gr.File(label="Upload JSON question bank (optional)", file_types=[".json"])
+            start_btn = gr.Button("Start Test")
             status = gr.Textbox(label="Status", interactive=False)
         with gr.Column(scale=2):
-            progress_text = gr.Markdown("**Test will appear here after generation.**")
             q_number = gr.Markdown("")
             q_text = gr.Markdown("")
-            options_radios = gr.Radio(choices=[], label="Options", value=None)
-            nav_row = gr.Row()
+            options = gr.Radio(choices=[], label="Options")
+            nav = gr.Row()
             prev_btn = gr.Button("Previous")
             next_btn = gr.Button("Next")
             finish_btn = gr.Button("Finish & Grade")
-            score_out = gr.Textbox(label="Score (percentage)", interactive=False)
-            download_file = gr.File(label="Download results (CSV)", value=None)
+            score_out = gr.Textbox(label="Score", interactive=False)
+            download_file = gr.File(label="Download results")
 
-    # App state
-    sampled_state = gr.State(value=[])
-    answers_state = gr.State(value=[])  # list of chosen indices
-    idx_state = gr.State(value=0)
+    sampled_state = gr.State([])
+    answers_state = gr.State([])
+    idx_state = gr.State(0)
 
-    # Start / Generate
     def start_test(uploaded_file, name_v, father_v, contact_v):
         q_list = load_questions_from_uploaded_or_repo(uploaded_file)
         if not q_list:
-            return gr.update(status="No valid questions found. Make sure JSON is correct or include a repo 'questions.json'."), [], [], 0, "", "", [], None
-        sampled = sample_questions(q_list, n=100)
+            return "No valid questions found.", [], [], 0, "", "", []
+        sampled = sample_questions(q_list, 100)
         answers = [None] * len(sampled)
-        # prepare first question display
-        i = 0
-        q = sampled[i]
-        opts = q["options"]
-        # update status
-        status_msg = f"Generated {len(sampled)} questions. Good luck, {name_v or 'Candidate'}!"
-        qnum_md = f"**Question {i+1} of {len(sampled)}**"
-        qtext_md = f"**{q['question']}**"
-        return status_msg, sampled, answers, i, qnum_md, qtext_md, opts, None
-
-    generate.click(fn=start_test, inputs=[upload, name, father, contact], outputs=[status, sampled_state, answers_state, idx_state, q_number, q_text, options_radios, download_file])
-
-    # Navigation: record current answer then move index
-    def save_and_move(sampled, answers, idx, chosen, move, name_v):
-        # record
+        q = sampled[0]
+        return f"Loaded {len(sampled)} questions.", sampled, answers, 0, f"**Q1 of {len(sampled)}**", q["question"], q["options"]
+
+    start_btn.click(start_test, [upload, name, father, contact],
+                    [status, sampled_state, answers_state, idx_state, q_number, q_text, options])
+
+    def navigate(sampled, answers, idx, chosen, move):
         if sampled and 0 <= idx < len(sampled):
-            answers[idx] = None if chosen is None else int(chosen)
-        # move (move can be -1 or +1 or 0)
-        new_idx = idx + move
-        new_idx = max(0, min(new_idx, len(sampled)-1))
-        # prepare display
+            answers[idx] = chosen
+        new_idx = max(0, min(idx + move, len(sampled)-1))
         q = sampled[new_idx]
-        opts = q["options"]
-        qnum_md = f"**Question {new_idx+1} of {len(sampled)}**"
-        qtext_md = f"**{q['question']}**"
-        # current selected value for radio is answers[new_idx] if not None
-        sel = answers[new_idx]
-        return sampled, answers, new_idx, qnum_md, qtext_md, opts, sel
-
-    prev_btn.click(fn=save_and_move, inputs=[sampled_state, answers_state, idx_state, options_radios, gr.State(-1), name], outputs=[sampled_state, answers_state, idx_state, q_number, q_text, options_radios, options_radios])
-    next_btn.click(fn=save_and_move, inputs=[sampled_state, answers_state, idx_state, options_radios, gr.State(1), name], outputs=[sampled_state, answers_state, idx_state, q_number, q_text, options_radios, options_radios])
-
-    # Finish & grade
-    def finish_and_grade(sampled, answers, idx, chosen, name_v, father_v, contact_v):
-        # save current question answer
+        return answers, new_idx, f"**Q{new_idx+1} of {len(sampled)}**", q["question"], q["options"], answers[new_idx]
+
+    prev_btn.click(navigate, [sampled_state, answers_state, idx_state, options, gr.State(-1)],
+                   [answers_state, idx_state, q_number, q_text, options, options])
+    next_btn.click(navigate, [sampled_state, answers_state, idx_state, options, gr.State(1)],
+                   [answers_state, idx_state, q_number, q_text, options, options])
+
+    def finish(sampled, answers, idx, chosen, name_v, father_v, contact_v):
         if sampled and 0 <= idx < len(sampled):
-            answers[idx] = None if chosen is None else int(chosen)
-        # score
-        correct, total_gradable, percentage, per_q = score_answers(sampled, answers)
-        personal = {"name": name_v or "", "father": father_v or "", "contact": contact_v or ""}
-        csv_path = results_to_csv(personal, per_q, out_dir="results")
-        status_msg = f"Scored {correct} out of {total_gradable} gradable questions. Percentage: {percentage:.2f}%"
-        return f"{percentage:.2f}%", gr.File.update(value=csv_path), status_msg
-
-    finish_btn.click(fn=finish_and_grade, inputs=[sampled_state, answers_state, idx_state, options_radios, name, father, contact], outputs=[score_out, download_file, status])
-
-    # When a question is shown, radio choices must be numeric indices
-    # Prepare radio choices converter: When options change, set radio choices to indices with display labels
-    def options_to_radio_choices(opts):
-        # build display: "0 — Option text" but we prefer "A) text", "B) text"
-        labels = []
-        for i, o in enumerate(opts):
-            label_letter = chr(65 + i)  # A, B, C...
-            labels.append(f"{i}")  # store as numeric string value; display is handled by options text above
-        return gr.update(choices=labels, value=None)
-
-    options_radios.change(fn=lambda opts: gr.update(), inputs=options_radios, outputs=options_radios)
-
-    # Small tweak: when q_text or options update, show options as visible list for readability
-    def display_options_for_readability(opts):
-        if not opts:
-            return ""
-        md = "\n".join([f"**{chr(65+i)})** {o}" for i, o in enumerate(opts)])
-        return md
-
-    options_radios.change(fn=lambda opts: display_options_for_readability(options_radios.value), inputs=[options_radios], outputs=[progress_text])
-
-    demo.launch(server_name="0.0.0.0", share=False)
+            answers[idx] = chosen
+        correct, total, perc, per_q = score_answers(sampled, answers)
+        path = results_to_csv({"name":name_v,"father":father_v,"contact":contact_v}, per_q)
+        return f"{correct}/{total} ({perc:.2f}%)", path, f"Test completed! Score: {perc:.2f}%"
+
+    finish_btn.click(finish, [sampled_state, answers_state, idx_state, options, name, father, contact],
+                     [score_out, download_file, status])
+
+demo.launch(server_name="0.0.0.0", server_port=7860)