Update app.py

app.py

@@ -325,121 +325,183 @@ def create_optimized_gradio_interface():
                     show_safety_output = gr.Markdown(label="Safety Check")
 
 
-            # Scenario Generator Tab
             with gr.Tab("🧪 Scenario Generator"):
-                scenario_query_input = gr.Textbox(label="Enter a medical topic")
-                num_questions_slider = gr.Slider(1, 10, value=5, step=1, label="Number of Questions")
-                scenario_submit = gr.Button("🚀 Generate Scenario")
-                # -- Output containers --
-                scenario_quiz_block = gr.Column(visible=False)
-                scenario_result_output = gr.Markdown(visible=False, elem_classes=["quiz-result-output"])
-                questions_state = gr.State()
-                
-                # -- Pre-allocate up to 10 quiz slots --
-                quiz_questions = []
-                with scenario_quiz_block:
-                    for i in range(10):
-                        q_md = gr.Markdown(visible=False)
-                        q_radio = gr.Radio(choices=[], type="index", visible=False)
-                        quiz_questions.append((q_md, q_radio))
-                    submit_quiz_btn = gr.Button("✅ Submit Answers")
-
-                
-
-
-                def on_generate_click(query, num_q):
-                    questions = get_mcq_data(query, num_q)
+                gr.Markdown("### Generate an Interactive Medical Scenario")
+            # Input controls
+            scenario_query_input = gr.Textbox(
+                label="Enter a medical topic", 
+                placeholder="e.g., 'burns', 'fractures', 'CPR'",
+                value=""
+            )
+            num_questions_slider = gr.Slider(
+                minimum=1, 
+                maximum=10, 
+                value=5, 
+                step=1, 
+                label="Number of Questions"
+            )
+            scenario_submit = gr.Button("🚀 Generate Scenario", variant="primary")
+            
+            # Status display
+            scenario_status = gr.Markdown("Ready to generate quiz...")
+            
+            # Output containers
+            scenario_quiz_block = gr.Column(visible=False)
+            scenario_result_output = gr.Markdown(visible=False, elem_classes=["quiz-result-output"])
+            questions_state = gr.State()
+            
+            # Pre-allocate quiz components (up to 10 questions)
+            quiz_questions = []
+            with scenario_quiz_block:
+                gr.Markdown("## 🧪 Interactive Medical Quiz")
+                for i in range(10):
+                    q_md = gr.Markdown(visible=False)
+                    q_radio = gr.Radio(choices=[], type="index", visible=False)
+                    quiz_questions.append((q_md, q_radio))
+                submit_quiz_btn = gr.Button("✅ Submit Answers", variant="primary")
+
+            def on_generate_click(query, num_q):
+                try:
+                    if not query.strip():
+                        return generate_error_response("Please enter a medical topic")
+                    if num_q < 1 or num_q > 10:
+                        return generate_error_response("Number of questions must be between 1 and 10")
+                    questions = get_mcq_data(query.strip(), num_q)
                     if isinstance(questions, dict) and "error" in questions:
-                        updates = []
-                        for _ in range(10):  # Hide all markdowns
-                            updates.append(gr.update(visible=False))
-                        for _ in range(10):  # Hide all radios
-                            updates.append(gr.update(visible=False))
-                    updates.extend([
-                        gr.update(visible=False),  # scenario_quiz_block
-                        gr.update(value=f"❌ Error: {questions['error']} – {questions['details']}", visible=True),  # scenario_result_output
-                        None  # questions_state
-                    ])
-                    return tuple(updates)
-                    # Success path
-                    updates = []
-                    for i in range(10):
-                        if i < len(questions):
-                            q = questions[i]
-                            updates.append(gr.update(value=f"**Q{i+1}: {q['question']}**", visible=True))  # markdown
-                        else:
-                            updates.append(gr.update(visible=False))  # markdown fallback
-                    for i in range(10):
-                        if i < len(questions):
-                            q = questions[i]
-                            choices = [f"{k}: {v}" for k, v in q["options"].items()]
-                            updates.append(gr.update(choices=choices, visible=True, value=None))  # radio
-                        else:
-                            updates.append(gr.update(visible=False))  # radio fallback
-                    updates.extend([
-                        gr.update(visible=True),       # scenario_quiz_block
-                        gr.update(value="", visible=False),  # scenario_result_output
-                        questions                     # questions_state
-                    ])
-                    return tuple(updates)
-
-
-
-                def evaluate_quiz(*args):
+                        error_msg = f"❌ Error: {questions['error']}"
+                        if "details" in questions:
+                            error_msg += f" – {questions['details']}"
+                        return generate_error_response(error_msg)
+                    if not questions or not isinstance(questions, list):
+                        return generate_error_response("No valid questions were generated")
+                    return generate_success_response(questions, query)
+                except Exception as e:
+                    logger.error(f"Error in on_generate_click: {e}")
+                    return generate_error_response(f"Unexpected error: {str(e)}")
+
+            def generate_error_response(error_message):
+                updates = []
+                for _ in range(10):
+                    updates.append(gr.update(visible=False))
+                for _ in range(10):
+                    updates.append(gr.update(visible=False))
+                updates.extend([
+                    gr.update(visible=False),
+                    gr.update(value=error_message, visible=True),
+                    None,
+                    gr.update(value=error_message)
+                ])
+                return tuple(updates)
+
+            def generate_success_response(questions, query):
+                updates = []
+                for i in range(10):
+                    if i < len(questions):
+                        q = questions[i]
+                        updates.append(gr.update(value=f"**Question {i+1}:** {q['question']}", visible=True))
+                    else:
+                        updates.append(gr.update(visible=False))
+                for i in range(10):
+                    if i < len(questions):
+                        q = questions[i]
+                        choices = [f"{k}: {v}" for k, v in q["options"].items()]
+                        updates.append(gr.update(choices=choices, visible=True, value=None, label=f"Select your answer for Question {i+1}:"))
+                    else:
+                        updates.append(gr.update(visible=False, choices=[]))
+                updates.extend([
+                    gr.update(visible=True),
+                    gr.update(value="", visible=False),
+                    questions,
+                    gr.update(value=f"✅ Generated {len(questions)} questions about '{query}'. Answer the questions below and click Submit!")
+                ])
+                return tuple(updates)
+
+            def evaluate_quiz(*args):
+                try:
+                    if not args:
+                        return gr.update(value="❌ No data received for evaluation", visible=True)
                     questions = args[-1]
                     selections = args[:-1]
                     if not questions:
-                        return gr.update(value="❌ No questions to evaluate", visible=True)
+                        return gr.update(value="❌ No questions available for evaluation", visible=True)
                     results = []
                     score = 0
                     total = len(questions)
                     for i, selected_index in enumerate(selections):
                         if i >= len(questions):
                             break
-                        q = questions[i]
-                        correct_key = q["correct_answer"]
-                        correct_label = f"{correct_key}: {q['options'][correct_key]}"
-                        if selected_index is not None:
-                            user_key = list(q["options"].keys())[selected_index]
-                            user_label = f"{user_key}: {q['options'][user_key]}"
-                            correct = user_key == correct_key
+                        question = questions[i]
+                        correct_key = question["correct_answer"]
+                        correct_answer = f"{correct_key}: {question['options'][correct_key]}"
+                        if selected_index is not None and selected_index < len(question["options"]):
+                            user_key = list(question["options"].keys())[selected_index]
+                            user_answer = f"{user_key}: {question['options'][user_key]}"
+                            is_correct = user_key == correct_key
                         else:
-                            user_label = "No answer selected"
-                            correct = False
-                        if correct:
+                            user_answer = "No answer selected"
+                            is_correct = False
+                        if is_correct:
                             score += 1
+                        status_icon = "✅" if is_correct else "❌"
                         results.append(f"""
-                        ### Question {i+1}
-                        **Your Answer:** {user_label}  
-                        **Correct Answer:** {correct_label}  
-                        {"✅ Correct!" if correct else "❌ Incorrect."}  
-                        💡 **Explanation:** {q['feedback']}
-                        ---""")
-                        percentage = (score / total) * 100 if total > 0 else 0
-                        summary = f"""
-                        # 📊 Quiz Results
-                        **Final Score: {score}/{total} ({percentage:.0f}%)**
-                        {'🎉 Excellent!' if percentage >= 80 else '👍 Good job!' if percentage >= 60 else '📚 Keep practicing!'}
-                        ---
-                        ## Detailed Feedback:
-                        """
-                    return gr.update(value=summary + "\n".join(results), visible=True), gr.HTML.update(value="<script>scrollToQuizResult()</script>")
-
-                        
-
-                # Event handlers for scenario generator
-                scenario_submit.click(
-                    fn=on_generate_click,
-                    inputs=[scenario_query_input, num_questions_slider],
-                    outputs=[q[0] for q in quiz_questions] + [q[1] for q in quiz_questions] +
-                    [scenario_quiz_block, scenario_result_output, questions_state],
-                    show_progress=True
-                )   
-                submit_quiz_btn.click(
-                    fn=evaluate_quiz,
-                    inputs=[q[1] for q in quiz_questions] + [questions_state],
-                    outputs=[scenario_result_output]
-                )
+### Question {i + 1}
+**{question['question']}**
+
+🔹 **Your Answer:** {user_answer}  
+🔹 **Correct Answer:** {correct_answer}  
+🔹 **Result:** {status_icon} {'Correct!' if is_correct else 'Incorrect'}
+
+💡 **Explanation:** {question.get('feedback', 'No explanation provided.')}
+
+---
+""")
+                    percentage = (score / total) * 100 if total > 0 else 0
+                    if percentage >= 90:
+                        grade_emoji, grade_text = "🏆", "Outstanding!"
+                    elif percentage >= 80:
+                        grade_emoji, grade_text = "🎉", "Excellent work!"
+                    elif percentage >= 70:
+                        grade_emoji, grade_text = "👍", "Good job!"
+                    elif percentage >= 60:
+                        grade_emoji, grade_text = "📚", "Keep studying!"
+                    else:
+                        grade_emoji, grade_text = "💪", "More practice needed!"
+                    summary = f"""
+# 📊 Quiz Results
+
+## {grade_emoji} Final Score: {score}/{total} ({percentage:.0f}%)
+
+**{grade_text}**
+
+---
+
+## 📝 Detailed Feedback:
+
+"""
+                    return gr.update(value=summary + "\n".join(results), visible=True)
+                except Exception as e:
+                    logger.error(f"Error in evaluate_quiz: {e}")
+                    return gr.update(value=f"❌ Error evaluating quiz: {str(e)}", visible=True)
+
+            scenario_submit.click(
+                fn=on_generate_click,
+                inputs=[scenario_query_input, num_questions_slider],
+                outputs=[
+                    quiz_questions[0][0], quiz_questions[1][0], quiz_questions[2][0], quiz_questions[3][0], quiz_questions[4][0],
+                    quiz_questions[5][0], quiz_questions[6][0], quiz_questions[7][0], quiz_questions[8][0], quiz_questions[9][0],
+                    quiz_questions[0][1], quiz_questions[1][1], quiz_questions[2][1], quiz_questions[3][1], quiz_questions[4][1],
+                    quiz_questions[5][1], quiz_questions[6][1], quiz_questions[7][1], quiz_questions[8][1], quiz_questions[9][1],
+                    scenario_quiz_block, scenario_result_output, questions_state, scenario_status
+                ],
+                show_progress=True
+            )
+
+            submit_quiz_btn.click(
+                fn=evaluate_quiz,
+                inputs=[q[1] for q in quiz_questions] + [questions_state],
+                outputs=[scenario_result_output]
+            )
+
 
 
         gr.HTML("""