Update app.py

app.py

@@ -43,14 +43,8 @@ class QuizApp:
         try:
             response = client.chat.completions.create(
                 messages=[
-                    {
-                        "role": "system",
-                        "content": "You are a quiz generator. Create clear questions with concise answer options."
-                    },
-                    {
-                        "role": "user",
-                        "content": prompt
-                    }
+                    {"role": "system", "content": "You are a quiz generator. Create clear questions with concise answer options."},
+                    {"role": "user", "content": prompt}
                 ],
                 model="llama-3.2-3b-preview",
                 temperature=0.3,
@@ -67,11 +61,9 @@ class QuizApp:
             for q in questions:
                 if not all(key in q for key in ["question", "options", "correct_answer"]):
                     continue
-                
                 clean_options = [opt.strip()[:100] for opt in q["options"] if isinstance(opt, str)]
                 if len(clean_options) != 4:
                     continue
-                
                 clean_q = {
                     "question": q["question"].strip(),
                     "options": clean_options,
@@ -92,7 +84,7 @@ class QuizApp:
         
         total = len(self.current_questions)
         correct = 0
-        results = []  # Store whether each answer was correct
+        results = []
         
         for i, (q, a) in enumerate(zip(self.current_questions, answers)):
             try:
@@ -102,25 +94,19 @@ class QuizApp:
                     if is_correct:
                         correct += 1
                     results.append({
-                        "question_index": i,
-                        "selected_index": selected_index,
-                        "correct_index": q["correct_answer"],
-                        "is_correct": is_correct
+                        "is_correct": is_correct,
+                        "correct_answer": q["options"][q["correct_answer"]]
                     })
                 else:
                     results.append({
-                        "question_index": i,
-                        "selected_index": None,
-                        "correct_index": q["correct_answer"],
-                        "is_correct": False
+                        "is_correct": False,
+                        "correct_answer": q["options"][q["correct_answer"]]
                     })
             except (ValueError, TypeError) as e:
                 print(f"Error processing answer {i}: {e}")
                 results.append({
-                    "question_index": i,
-                    "selected_index": None,
-                    "correct_index": q["correct_answer"],
-                    "is_correct": False
+                    "is_correct": False,
+                    "correct_answer": q["options"][q["correct_answer"]]
                 })
         
         return (correct / total) * 100, results
@@ -129,8 +115,6 @@ def create_quiz_interface():
     quiz_app = QuizApp()
     
     with gr.Blocks(title="CertifyMe AI", theme=gr.themes.Soft()) as demo:
-        current_questions = gr.State([])
-        
         # Header
         gr.Markdown("""
         # 🎓 CertifyMe AI
@@ -139,7 +123,7 @@ def create_quiz_interface():
         
         # Tabs
         with gr.Tabs() as tabs:
-            # Step 1: Profile Setup (remains largely the same)
+            # Step 1: Profile Setup
             with gr.Tab("📋 Step 1: Profile Setup") as tab1:
                 with gr.Row():
                     name = gr.Textbox(label="Full Name", placeholder="Enter your full name")
@@ -167,139 +151,170 @@ def create_quiz_interface():
             
             # Step 2: Take Assessment
             with gr.Tab("📝 Step 2: Take Assessment") as tab2:
-                assessment_status = gr.Markdown("")
-                with gr.Group() as question_group:
-                    questions = []
-                    for i in range(5):
-                        with gr.Group(visible=False) as qgroup:
-                            question_md = gr.Markdown("", elem_id=f"question_{i}")
-                            radio = gr.Radio(
-                                choices=[],
-                                label="Select your answer:",
-                                interactive=True,
-                                elem_id=f"answer_{i}"
-                            )
-                            result_md = gr.Markdown("", elem_id=f"result_{i}")
-                            questions.append({"group": qgroup, "md": question_md, "radio": radio, "result": result_md})
+                question_box = gr.Markdown("")
+                answers = []
+                feedback = []
+                
+                for i in range(5):
+                    radio = gr.Radio(
+                        choices=[],
+                        label=f"Question {i+1}",
+                        visible=False
+                    )
+                    answers.append(radio)
+                    fb = gr.Markdown(visible=False)
+                    feedback.append(fb)
                 
                 submit_btn = gr.Button("Submit Assessment", variant="primary", size="lg")
-                result_modal = gr.Markdown("")
+                result_message = gr.Markdown("")
             
             # Step 3: Get Certified
             with gr.Tab("🎓 Step 3: Get Certified") as tab3:
                 score_display = gr.Number(label="Your Score")
-                result_message = gr.Markdown("")
+                completion_message = gr.Markdown("")
                 course_name = gr.Textbox(
                     label="Certification Title",
                     value="Professional Assessment Certification"
                 )
                 certificate_display = gr.Image(label="Your Certificate")
 
+        # Store questions state
+        questions_state = gr.State([])
+        
         def update_questions(text, num_questions):
             if not text.strip():
-                return [
-                    gr.update(visible=False) for _ in range(5)
-                ], "⚠️ Please enter some text content to generate questions.", [], 0
+                return (
+                    gr.update(value="Please enter content to generate questions."),
+                    *[gr.update(visible=False) for _ in range(5)],  # Radio buttons
+                    *[gr.update(visible=False) for _ in range(5)],  # Feedback
+                    [],  # questions state
+                    1,   # tab index
+                    "Please enter content to generate questions."  # result message
+                )
+            
+            success, questions = quiz_app.generate_questions(text, num_questions)
+            if not success:
+                return (
+                    gr.update(value="Failed to generate questions. Please try again."),
+                    *[gr.update(visible=False) for _ in range(5)],
+                    *[gr.update(visible=False) for _ in range(5)],
+                    [],
+                    1,
+                    "Failed to generate questions. Please try again."
+                )
             
-            success, generated_questions = quiz_app.generate_questions(text, num_questions)
+            # Create question display with embedded radio buttons
+            questions_md = "# 📝 Assessment Questions\n\n"
             
-            if not success or not generated_questions:
-                return [
-                    gr.update(visible=False) for _ in range(5)
-                ], "❌ Failed to generate questions. Please try again.", [], 0
+            # Update radio buttons and create question display
+            radio_updates = []
+            feedback_updates = []
             
-            updates = []
-            for i in range(5):
-                if i < len(generated_questions):
-                    q = generated_questions[i]
-                    updates.append(gr.update(
-                        visible=True,
-                        value={
-                            "md": f"### Question {i+1}\n{q['question']}",
-                            "radio": gr.update(choices=q["options"], value=None),
-                            "result": ""
-                        }
-                    ))
-                else:
-                    updates.append(gr.update(visible=False))
+            for i, q in enumerate(questions):
+                questions_md += f"### Question {i+1}\n{q['question']}\n\n"
+                radio_updates.append(gr.update(
+                    choices=q["options"],
+                    label=f"Select your answer for Question {i+1}:",
+                    visible=True,
+                    value=None
+                ))
+                feedback_updates.append(gr.update(visible=False, value=""))
             
-            return updates, "", generated_questions, 1
-
-        def submit_quiz(answers, questions):
-            if not all(a is not None for a in answers[:len(questions)]):
-                return (
-                    gr.update(value="⚠️ Please answer all questions before submitting."),
-                    score_display.value,
-                    0
-                )
+            # Hide unused radio buttons
+            for i in range(len(questions), 5):
+                radio_updates.append(gr.update(visible=False))
+                feedback_updates.append(gr.update(visible=False))
+            
+            return (
+                gr.update(value=questions_md),
+                *radio_updates,
+                *feedback_updates,
+                questions,
+                1,
+                ""
+            )
+        
+        def submit_answers(q1, q2, q3, q4, q5, questions):
+            answers = [q1, q2, q3, q4, q5][:len(questions)]
+            
+            if not all(a is not None for a in answers):
+                return [gr.update() for _ in range(5)], 0, "Please answer all questions before submitting."
             
             score, results = quiz_app.calculate_score(answers)
             
-            # Update result display for each question
-            updates = []
+            # Create feedback for each answer
+            feedback_updates = []
             for i, result in enumerate(results):
                 if result["is_correct"]:
-                    status = "✅ Correct!"
-                    color = "green"
+                    feedback_updates.append(gr.update(
+                        visible=True,
+                        value='<div style="color: green; margin-top: 10px;">✅ Correct!</div>'
+                    ))
                 else:
-                    status = f"❌ Incorrect. Correct answer: {questions[i]['options'][result['correct_index']]}"
-                    color = "red"
-                
-                updates.append(gr.update(
-                    visible=True,
-                    value=f'<div style="color: {color};">{status}</div>'
-                ))
+                    feedback_updates.append(gr.update(
+                        visible=True,
+                        value=f'<div style="color: red; margin-top: 10px;">❌ Incorrect. Correct answer: {result["correct_answer"]}</div>'
+                    ))
+            
+            # Add empty updates for unused feedback slots
+            for _ in range(len(results), 5):
+                feedback_updates.append(gr.update(visible=False))
             
-            # Add result message
+            # Create result message
             if score >= 80:
                 message = f"""
-                ## 🎉 Congratulations!
+                ### 🎉 Congratulations!
                 You passed the assessment with a score of {score:.1f}%
                 Your certificate has been generated.
                 """
             else:
                 message = f"""
-                ## Try Again
+                ### Please Try Again
                 Your score: {score:.1f}%
                 You need 80% or higher to pass and receive a certificate.
                 """
             
-            return updates, message, score, 2
-
+            return feedback_updates, score, message
+        
         # Event handlers
         generate_btn.click(
             fn=update_questions,
             inputs=[text_input, num_questions],
             outputs=[
-                *[q["group"] for q in questions],
-                assessment_status,
-                current_questions,
-                gr.State(1)
+                question_box,
+                *answers,
+                *feedback,
+                questions_state,
+                gr.State(1),
+                result_message
             ]
         ).then(
             fn=lambda x: gr.update(selected=x),
-            inputs=[gr.State(1)],
+            inputs=gr.State(1),
             outputs=tabs
         )
         
         submit_btn.click(
-            fn=submit_quiz,
-            inputs=[
-                *[q["radio"] for q in questions],
-                current_questions
-            ],
+            fn=submit_answers,
+            inputs=[*answers, questions_state],
             outputs=[
-                *[q["result"] for q in questions],
-                result_modal,
+                *feedback,
                 score_display,
-                gr.State(2)
+                result_message
             ]
         ).then(
             fn=lambda x: gr.update(selected=x),
-            inputs=[gr.State(2)],
+            inputs=gr.State(2),
             outputs=tabs
         )
         
+        # Certificate generation event handler
+        score_display.change(
+            fn=generate_certificate,
+            inputs=[score_display, name, course_name, company_logo, participant_photo],
+            outputs=[certificate_display, completion_message]
+        )
+        
         def generate_certificate(score, name, course_name, company_logo=None, participant_photo=None):
             """
             Generate a certificate with custom styling and optional logo/photo