Update app.py

app.py

@@ -38,7 +38,6 @@ class QuizApp:
                 "correct_answer": 0
             }}
         ]
-        Keep all options concise (10 words or less each).
         """
         
         try:
@@ -58,48 +57,28 @@ class QuizApp:
                 max_tokens=2048
             )
             
-            # Clean and parse response
             response_text = response.choices[0].message.content.strip()
             response_text = response_text.replace("```json", "").replace("```", "").strip()
+            response_text = response_text[response_text.find("["):response_text.rfind("]")+1]
             
-            # Extract JSON array
-            start_idx = response_text.find("[")
-            end_idx = response_text.rfind("]")
-            
-            if start_idx == -1 or end_idx == -1:
-                raise ValueError("No valid JSON array found in response")
-                
-            response_text = response_text[start_idx:end_idx + 1]
             questions = json.loads(response_text)
-            
-            # Validate and clean up questions
             validated_questions = []
+            
             for q in questions:
                 if not all(key in q for key in ["question", "options", "correct_answer"]):
                     continue
-                    
-                # Ensure options are strings and reasonably sized
-                clean_options = []
-                for opt in q["options"]:
-                    if isinstance(opt, str):
-                        # Limit option length and clean up formatting
-                        clean_opt = opt.strip()[:100]  # Limit length
-                        clean_options.append(clean_opt)
                 
+                clean_options = [opt.strip()[:100] for opt in q["options"] if isinstance(opt, str)]
                 if len(clean_options) != 4:
                     continue
-                    
-                # Create clean question
+                
                 clean_q = {
                     "question": q["question"].strip(),
                     "options": clean_options,
-                    "correct_answer": int(q["correct_answer"]) % 4  # Ensure valid index
+                    "correct_answer": int(q["correct_answer"]) % 4
                 }
                 validated_questions.append(clean_q)
             
-            if not validated_questions:
-                raise ValueError("No valid questions after validation")
-                
             self.current_questions = validated_questions[:num_questions]
             return True, self.current_questions
             
@@ -109,29 +88,47 @@ class QuizApp:
 
     def calculate_score(self, answers):
         if not answers or not self.current_questions:
-            return 0
+            return 0, []
         
         total = len(self.current_questions)
         correct = 0
+        results = []  # Store whether each answer was correct
+        
         for i, (q, a) in enumerate(zip(self.current_questions, answers)):
             try:
                 if a is not None:
-                    # Find the index of the selected answer in the options list
                     selected_index = q["options"].index(a)
-                    if selected_index == q["correct_answer"]:
+                    is_correct = selected_index == q["correct_answer"]
+                    if is_correct:
                         correct += 1
+                    results.append({
+                        "question_index": i,
+                        "selected_index": selected_index,
+                        "correct_index": q["correct_answer"],
+                        "is_correct": is_correct
+                    })
+                else:
+                    results.append({
+                        "question_index": i,
+                        "selected_index": None,
+                        "correct_index": q["correct_answer"],
+                        "is_correct": False
+                    })
             except (ValueError, TypeError) as e:
                 print(f"Error processing answer {i}: {e}")
-                continue
+                results.append({
+                    "question_index": i,
+                    "selected_index": None,
+                    "correct_index": q["correct_answer"],
+                    "is_correct": False
+                })
         
-        return (correct / total) * 100
-
+        return (correct / total) * 100, results
 
 def create_quiz_interface():
     quiz_app = QuizApp()
     
     with gr.Blocks(title="CertifyMe AI", theme=gr.themes.Soft()) as demo:
-        # State variables
         current_questions = gr.State([])
         
         # Header
@@ -142,7 +139,7 @@ def create_quiz_interface():
         
         # Tabs
         with gr.Tabs() as tabs:
-            # Step 1: Profile Setup
+            # Step 1: Profile Setup (remains largely the same)
             with gr.Tab("📋 Step 1: Profile Setup") as tab1:
                 with gr.Row():
                     name = gr.Textbox(label="Full Name", placeholder="Enter your full name")
@@ -170,36 +167,28 @@ def create_quiz_interface():
             
             # Step 2: Take Assessment
             with gr.Tab("📝 Step 2: Take Assessment") as tab2:
-                questions_markdown = gr.Markdown("")
-                answers = []
-                for i in range(5):
-                    with gr.Group():
-                        radio = gr.Radio(
-                            choices=[],
-                            label=f"Question {i+1}",
-                            visible=False,
-                            interactive=True
-                        )
-                        answers.append(radio)
-                
-                submit_btn = gr.Button(
-                    "Submit Assessment", 
-                    variant="primary",
-                    size="lg"
-                )
+                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})
                 
-                gr.Markdown("""
-                ### Instructions:
-                - Read each question carefully
-                - Select one answer for each question
-                - Click Submit Assessment when you're done
-                - You need 80% or higher to earn your certificate
-                """)
-            
+                submit_btn = gr.Button("Submit Assessment", variant="primary", size="lg")
+                result_modal = 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("")
                 course_name = gr.Textbox(
                     label="Certification Title",
                     value="Professional Assessment Certification"
@@ -208,57 +197,85 @@ def create_quiz_interface():
 
         def update_questions(text, num_questions):
             if not text.strip():
-                return (
-                    gr.update(value="⚠️ Please enter some text content to generate questions."),
-                    *[gr.update(visible=False, choices=[]) for _ in range(5)],
-                    [],
-                    0
-                )
+                return [
+                    gr.update(visible=False) for _ in range(5)
+                ], "⚠️ Please enter some text content to generate questions.", [], 0
+            
+            success, generated_questions = quiz_app.generate_questions(text, num_questions)
             
-            success, questions = quiz_app.generate_questions(text, num_questions)
+            if not success or not generated_questions:
+                return [
+                    gr.update(visible=False) for _ in range(5)
+                ], "❌ Failed to generate questions. Please try again.", [], 0
             
-            if not success or not questions:
+            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))
+            
+            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="❌ Failed to generate questions. Please try again with different content."),
-                    *[gr.update(visible=False, choices=[]) for _ in range(5)],
-                    [],
+                    gr.update(value="⚠️ Please answer all questions before submitting."),
+                    score_display.value,
                     0
                 )
             
-            # Update question display with answers immediately following each question
-            questions_html = "# 📝 Assessment Questions\n\n"
-            questions_html += "> Please select one answer for each question below.\n\n"
+            score, results = quiz_app.calculate_score(answers)
             
-            # Update radio buttons
+            # Update result display for each question
             updates = []
-            for i, q in enumerate(questions):
-                questions_html += f"### Question {i+1}\n{q['question']}\n\n"
-                # Create radio button update for this question
+            for i, result in enumerate(results):
+                if result["is_correct"]:
+                    status = "✅ Correct!"
+                    color = "green"
+                else:
+                    status = f"❌ Incorrect. Correct answer: {questions[i]['options'][result['correct_index']]}"
+                    color = "red"
+                
                 updates.append(gr.update(
                     visible=True,
-                    choices=q["options"],
-                    value=None,
-                    label=f"Select your answer:"
+                    value=f'<div style="color: {color};">{status}</div>'
                 ))
-                questions_html += "\n\n" # Add space between questions
             
-            # Fill remaining radio buttons with hidden updates
-            for i in range(len(questions), 5):
-                updates.append(gr.update(visible=False, choices=[]))
+            # Add result message
+            if score >= 80:
+                message = f"""
+                ## 🎉 Congratulations!
+                You passed the assessment with a score of {score:.1f}%
+                Your certificate has been generated.
+                """
+            else:
+                message = f"""
+                ## Try Again
+                Your score: {score:.1f}%
+                You need 80% or higher to pass and receive a certificate.
+                """
             
-            return (gr.update(value=questions_html), *updates, questions, 1)
-        
-     
-        def submit_quiz(q1, q2, q3, q4, q5, questions):
-            answers = [q1, q2, q3, q4, q5][:len(questions)]
-            score = quiz_app.calculate_score(answers)
-            return score, 2
+            return updates, message, score, 2
 
         # Event handlers
         generate_btn.click(
             fn=update_questions,
             inputs=[text_input, num_questions],
-            outputs=[questions_markdown, *answers, current_questions, gr.State(1)]
+            outputs=[
+                *[q["group"] for q in questions],
+                assessment_status,
+                current_questions,
+                gr.State(1)
+            ]
         ).then(
             fn=lambda x: gr.update(selected=x),
             inputs=[gr.State(1)],
@@ -267,8 +284,16 @@ def create_quiz_interface():
         
         submit_btn.click(
             fn=submit_quiz,
-            inputs=[*answers, current_questions],
-            outputs=[score_display, gr.State(2)]
+            inputs=[
+                *[q["radio"] for q in questions],
+                current_questions
+            ],
+            outputs=[
+                *[q["result"] for q in questions],
+                result_modal,
+                score_display,
+                gr.State(2)
+            ]
         ).then(
             fn=lambda x: gr.update(selected=x),
             inputs=[gr.State(2)],