message de commit

app.py

@@ -558,116 +558,101 @@ questions = [
     }
 ]
 
-# Fonction pour calculer les statistiques
-def calculate_stats(results):
-    if not results:
-        return "Aucune question répondue jusqu'à présent."
+
+
+# Add correct_answers variable
+correct_answers = [q["correct"] for q in questions]
+
+def calculate_score(user_answers):
+    # Convertir les réponses utilisateur de A,B,C,D à 0,1,2,3
+    idx_answers = []
+    for ans in user_answers:
+        if ans == "A":
+            idx_answers.append(0)
+        elif ans == "B":
+            idx_answers.append(1)
+        elif ans == "C":
+            idx_answers.append(2)
+        elif ans == "D":
+            idx_answers.append(3)
+        else:
+            idx_answers.append(None)  # Pour gérer les réponses vides
+    
+    # Convertir les réponses correctes
+    correct_idx = []
+    for ans in correct_answers:
+        if ans == "A":
+            correct_idx.append(0)
+        elif ans == "B":
+            correct_idx.append(1)
+        elif ans == "C":
+            correct_idx.append(2)
+        elif ans == "D":
+            correct_idx.append(3)
     
-    total = len(results)
-    correct = sum(1 for r in results if r['correct'])
-    percentage = (correct / total) * 100 if total > 0 else 0
+    # Calculer le score
+    score = 0
+    user_responses = []
     
-    # Regrouper par catégorie
-    categories = {}
-    for r in results:
-        cat = r['category']
-        if cat not in categories:
-            categories[cat] = {'total': 0, 'correct': 0}
-        categories[cat]['total'] += 1
-        if r['correct']:
-            categories[cat]['correct'] += 1
+    for i in range(len(idx_answers)):
+        if idx_answers[i] is not None and idx_answers[i] == correct_idx[i]:
+            score += 1
+            user_responses.append(f"Question {i+1}: Correct ✓ - Votre réponse: {user_answers[i]}")
+        else:
+            user_responses.append(f"Question {i+1}: Incorrect ✗ - Votre réponse: {user_answers[i] if idx_answers[i] is not None else 'Non répondue'}, Réponse correcte: {correct_answers[i]}")
     
-    # Formater la sortie
-    stats = f"## Résumé\n\n"
-    stats += f"- **Questions répondues:** {total}\n"
-    stats += f"- **Questions correctes:** {correct} ({percentage:.1f}%)\n\n"
-    stats += "## Par catégorie\n\n"
-    for cat, data in categories.items():
-        cat_percentage = (data['correct'] / data['total']) * 100 if data['total'] > 0 else 0
-        stats += f"- **{cat}:** {data['correct']}/{data['total']} ({cat_percentage:.1f}%)\n"
+    # Calculer la note sur 20
+    note_sur_20 = (score / len(correct_answers)) * 20
     
-    return stats
+    return score, note_sur_20, user_responses
 
-# État de l'application
-class AppState:
-    def __init__(self):
-        self.current_questions = []
-        self.current_index = 0
-        self.results = []
-        self.mode = "all"  # "all", "category" ou "wrong"
-        self.selected_category = None
-        
-    def reset_with_questions(self, new_questions, mode="all", category=None):
-        self.current_questions = new_questions.copy()
-        random.shuffle(self.current_questions)
-        self.current_index = 0
-        self.mode = mode
-        self.selected_category = category
-        
-    def get_current_question(self):
-        if not self.current_questions or self.current_index >= len(self.current_questions):
-            return None
-        return self.current_questions[self.current_index]
+# Modified qcm_app to handle multiple arguments from Gradio click event
+def qcm_app(*user_responses):
+    # Convert tuple of responses to list
+    answers = list(user_responses)
+    # Calculer le score
+    score, note, detailed_responses = calculate_score(answers)
     
-    def next_question(self):
-        if self.current_index < len(self.current_questions) - 1:
-            self.current_index += 1
-            return self.current_questions[self.current_index]
-        return None
+    # Formatter la sortie
+    output = f"# Résultats du QCM sur la Gouvernance des Données\n\n"
+    output += f"## Score: {score}/{len(questions)} questions correctes\n"
+    output += f"## Note: {note:.2f}/20\n\n"
     
-    def prev_question(self):
-        if self.current_index > 0:
-            self.current_index -= 1
-            return self.current_questions[self.current_index]
-        return None
+    output += "## Détail des réponses:\n\n"
+    for resp in detailed_responses:
+        output += f"- {resp}\n"
     
-    def add_result(self, question, selected_option, is_correct):
-        result = {
-            'question': question['question'],
-            'selected_option': selected_option,
-            'correct': is_correct,
-            'category': question['category']
-        }
-        self.results.append(result)
-        return result
+    return output
 
-if __name__ == "__main__":
-    # Initialize application state with questions
-    app_state = AppState()
-    app_state.reset_with_questions(questions)
+# Créer l'interface Gradio
+with gr.Blocks(title="QCM - Gouvernance des Données") as demo:
+    gr.Markdown("# Questionnaire à Choix Multiples - Gouvernance des Données")
+    gr.Markdown("Répondez aux questions en sélectionnant la réponse correcte (A, B, C ou D).")
     
-    # Prepare the first question display (show only question text)
-    curr = app_state.get_current_question()
-    init_display = curr['question'] if curr else "Aucune question."
+    user_choices = []
+    with gr.Accordion("Questions", open=True):
+        for i in range(len(questions)):
+            with gr.Row():
+                with gr.Column(scale=10):
+                    gr.Markdown(f"### {questions[i]['question']}")
+                    for opt in questions[i]['options']:
+                        gr.Markdown(f"- {opt}")
+                with gr.Column(scale=1):
+                    # Changed from Dropdown to Radio for clickable answers
+                    user_choice = gr.Radio(
+                        choices=["A", "B", "C", "D"],
+                        label=f"Question {i+1}"
+                    )
+                    user_choices.append(user_choice)
     
-    with gr.Blocks() as demo:
-        gr.Markdown("## Quiz de Deep Learning")
-        q_box = gr.Markdown(init_display)
-        answer_radio = gr.Radio(choices=curr["options"] if curr else [], label="Votre réponse")
-        message = gr.Markdown("")
-        
-        def submit_answer(selected_option):
-            curr_q = app_state.get_current_question()
-            # If no current question, end quiz
-            if curr_q is None:
-                return q_box.update(value="Quiz terminé."), gr.Radio.update(choices=[], value=None, interactive=False), message.update(value="")
-            # Check answer and set result message
-            is_correct = (selected_option == curr_q["correct"])
-            result_msg = "Bonne réponse !" if is_correct else f"Mauvaise réponse. La réponse correcte était {curr_q['correct']}."
-            app_state.add_result(curr_q, selected_option, is_correct)
-            nxt = app_state.next_question()
-            if nxt:
-                return (q_box.update(value=nxt["question"]),
-                        gr.Radio.update(choices=nxt["options"], value=None),
-                        message.update(value=result_msg))
-            else:
-                stats = calculate_stats(app_state.results)
-                final_msg = "Quiz terminé.\n\n" + stats + "\n\n" + result_msg
-                return (q_box.update(value=final_msg),
-                        gr.Radio.update(choices=[], value=None, interactive=False),
-                        message.update(value=""))
-        
-        submit_btn = gr.Button("Submit")
-        submit_btn.click(fn=submit_answer, inputs=answer_radio, outputs=[q_box, answer_radio, message])
+    submit_btn = gr.Button("Soumettre")
+    output = gr.Markdown()
     
-    demo.launch()
+    submit_btn.click(
+        fn=qcm_app,
+        inputs=user_choices,
+        outputs=output
+    )
+
+if __name__ == "__main__":
+    demo.launch()