Update app.py

app.py

@@ -1,15 +1,16 @@
 import gradio as gr
+import pandas as pd
 from ortools.sat.python import cp_model
 import concurrent.futures
 
-def solve_exam_schedule(exams_text, rooms_text, num_slots, conflicts_text, availability_text):
+def solve_exam_schedule(exams_text, rooms_text, num_slots, conflicts_text, availability_text, invigilators):
     # --- 1. Parsing des données ---
-    # Ensembles des filières et promotions autorisées
+    # Ensembles autorisés
     allowed_filiere = {"IA", "SEIOT", "IM", "SI", "GL"}
     allowed_promotions = {"1ere", "2eme", "3eme", "master1", "master2"}
     
-    # Chaque ligne des examens doit être sous la forme :
-    # exam_id, nb_etudiants, durée, filière[;filière2...], promotion(s)[;promotion2...], reprise (optionnel)
+    # Format attendu pour les examens :
+    # exam_id, nb_etudiants, durée, filière[;...], promotion(s)[;...], reprise (optionnel)
     exams = []
     for line in exams_text.strip().splitlines():
         if not line.strip():
@@ -23,10 +24,12 @@ def solve_exam_schedule(exams_text, rooms_text, num_slots, conflicts_text, avail
             duration = int(parts[2].strip())
         except ValueError:
             return "Erreur : exam_id, nb_etudiants et durée doivent être des nombres."
+        # Extraction et vérification des filières
         filiere_str = parts[3].strip()
         filiere_set = {f.strip() for f in filiere_str.split(';')}
         if not filiere_set.issubset(allowed_filiere):
             return f"Erreur : filière(s) non autorisée(s). Autorisées : {', '.join(allowed_filiere)}."
+        # Extraction et vérification des promotions
         promotion_str = parts[4].strip()
         promotion_set = {p.strip() for p in promotion_str.split(';')}
         if not promotion_set.issubset(allowed_promotions):
@@ -40,7 +43,7 @@ def solve_exam_schedule(exams_text, rooms_text, num_slots, conflicts_text, avail
         exams.append((exam_id, nb_students, duration, filiere_set, promotion_set, reprise))
     num_exams = len(exams)
     
-    # Création d'un mapping exam_id -> index (pour les conflits saisis manuellement)
+    # Mapping exam_id -> index (pour conflits manuels)
     exam_id_to_index = {exam[0]: idx for idx, exam in enumerate(exams)}
     
     # Lecture des salles : chaque ligne "room_id, capacité"
@@ -57,7 +60,7 @@ def solve_exam_schedule(exams_text, rooms_text, num_slots, conflicts_text, avail
         rooms.append((room_id, capacity))
     num_rooms = len(rooms)
     
-    # Conflits supplémentaires (saisie manuelle, chaque ligne : exam1, exam2)
+    # Conflits supplémentaires (manuels) : chaque ligne "exam1, exam2"
     user_conflicts = []
     for line in conflicts_text.strip().splitlines():
         if not line.strip():
@@ -70,17 +73,16 @@ def solve_exam_schedule(exams_text, rooms_text, num_slots, conflicts_text, avail
         except (KeyError, ValueError):
             return "Erreur dans les conflits : vérifiez que les exam_id existent et sont valides."
     
-    # Conflits automatiques : deux examens sont en conflit s'ils partagent au moins une filière ou une promotion
+    # Conflits automatiques :
+    # Deux examens sont en conflit s'ils partagent au moins une filière ou au moins une promotion.
     auto_conflicts = []
     for i in range(num_exams):
         for j in range(i + 1, num_exams):
             if exams[i][3].intersection(exams[j][3]) or exams[i][4].intersection(exams[j][4]):
                 auto_conflicts.append((i, j))
-    
-    # Union des conflits
     all_conflicts = set(user_conflicts + auto_conflicts)
     
-    # Disponibilité des salles : chaque ligne "room_id, slot1, slot2, ..." (1 = disponible, 0 = non disponible)
+    # Disponibilité des salles : chaque ligne "room_id, slot1, slot2, ..." (1 = dispo, 0 = non dispo)
     availability = {}
     for line in availability_text.strip().splitlines():
         if not line.strip():
@@ -110,19 +112,19 @@ def solve_exam_schedule(exams_text, rooms_text, num_slots, conflicts_text, avail
     model = cp_model.CpModel()
     
     # Variable de décision :
-    # x[i, j, k] = 1 si l'examen i est programmé au créneau j dans la salle k
+    # x[i, j, k] = 1 si l'examen i est programmé au créneau j dans la salle k.
     x = {}
     for i in range(num_exams):
         for j in range(num_slots):
             for k in range(num_rooms):
                 x[(i, j, k)] = model.NewBoolVar(f'x_{i}_{j}_{k}')
     
-    # Chaque examen doit être programmé exactement une fois
+    # Chaque examen doit être programmé exactement une fois.
     for i in range(num_exams):
         model.Add(sum(x[(i, j, k)] for j in range(num_slots) for k in range(num_rooms)) == 1)
     
     # Contrainte de capacité :
-    # La somme (nb d'étudiants + reprise) pour les examens programmés dans une salle à un créneau doit être ≤ capacité de la salle
+    # Le nombre total d'étudiants (inscrits + reprises) pour les examens programmés dans une salle à un créneau ≤ capacité de la salle.
     for j in range(num_slots):
         for k in range(num_rooms):
             model.Add(
@@ -130,7 +132,7 @@ def solve_exam_schedule(exams_text, rooms_text, num_slots, conflicts_text, avail
                 <= rooms[k][1]
             )
     
-    # Contrainte de conflits : deux examens en conflit (défini par les conflits manuels et automatiques) ne peuvent être au même créneau
+    # Contrainte de conflits : deux examens en conflit ne peuvent être programmés au même créneau.
     for (i, l) in all_conflicts:
         for j in range(num_slots):
             model.Add(
@@ -139,13 +141,36 @@ def solve_exam_schedule(exams_text, rooms_text, num_slots, conflicts_text, avail
                 <= 1
             )
     
-    # Contrainte de disponibilité des salles
+    # Contrainte de disponibilité des salles.
     for j in range(num_slots):
         for k in range(num_rooms):
             if avail_matrix[k][j] == 0:
                 for i in range(num_exams):
                     model.Add(x[(i, j, k)] == 0)
     
+    # --- Nouvelles contraintes supplémentaires ---
+    
+    # 1. Disponibilité des ressources humaines (enseignants surveillants)
+    # Chaque examen requiert un enseignant, donc le nombre total d'examens simultanés ≤ nombre d'enseignants disponibles.
+    for j in range(num_slots):
+        model.Add(sum(x[(i, j, k)] for i in range(num_exams) for k in range(num_rooms)) <= invigilators)
+    
+    # 2. Un étudiant (promotion) ne peut être inscrit à deux examens simultanément
+    # Pour chaque promotion et chaque créneau, au plus un examen (contenant cette promotion) peut être programmé.
+    for p in allowed_promotions:
+        for j in range(num_slots):
+            model.Add(sum(x[(i, j, k)] for i in range(num_exams) if p in exams[i][4] for k in range(num_rooms)) <= 1)
+    
+    # 3. Marges de transition dans chaque salle
+    # Si une salle est utilisée au créneau j, elle doit rester libre au créneau j+1.
+    for k in range(num_rooms):
+        for j in range(num_slots - 1):
+            model.Add(
+                sum(x[(i, j, k)] for i in range(num_exams)) +
+                sum(x[(i, j+1, k)] for i in range(num_exams))
+                <= 1
+            )
+    
     # Objectif : Minimiser le dernier créneau utilisé (T_max)
     T_max = model.NewIntVar(0, num_slots - 1, 'T_max')
     y = {}
@@ -189,30 +214,28 @@ def solve_exam_schedule(exams_text, rooms_text, num_slots, conflicts_text, avail
                             "Durée (h)": duration
                         })
         schedule = sorted(schedule, key=lambda item: item["Créneau"])
-        output_text = "### Calendrier des Examens\n"
-        for item in schedule:
-            output_text += (
-                f"**Examen {item['Examen']}** | Filière: {item['Filière']} | Promotion: {item['Promotion']} | Créneau: {item['Créneau']} | "
-                f"Salle: {item['Salle']} | Étudiants: {item['Nb Étudiants']} | Reprise: {item['Reprise']} | Durée: {item['Durée (h)']}h\n\n"
-            )
-        return output_text
+        df = pd.DataFrame(schedule)
+        return df
     else:
-        return "Aucune solution trouvée."
+        # En cas d'erreur, on retourne un DataFrame avec un message
+        return pd.DataFrame([{"Message": "Aucune solution trouvée."}])
 
-# Utilisation d'un ThreadPoolExecutor pour exécuter la fonction dans un thread séparé
+# Exécution dans un thread séparé
 executor = concurrent.futures.ThreadPoolExecutor(max_workers=4)
 def solve_in_thread(*args, **kwargs):
     future = executor.submit(solve_exam_schedule, *args, **kwargs)
     return future.result()
 
-with gr.Blocks() as demo:
-    gr.Markdown("# Planification des Examens Multi-Promotions et Filières")
+# Interface Gradio
+with gr.Blocks(css=".gradio-container {max-width: 900px; margin: auto;}") as demo:
+    gr.Markdown("# Planification des Examens Multi-Promotions, Filières et Contraintes de Ressources")
     gr.Markdown(
         "Format des examens :<br>"
         "`exam_id, nb_etudiants, durée, filière[;...], promotion(s)[;...], reprise (optionnel)`<br>"
         "Exemples :<br>"
         "`0, 30, 2, IA, 1ere, 5`<br>"
-        "`1, 25, 1, SEIOT;GL, 2eme;3eme`"
+        "`1, 25, 1, SEIOT;GL, 2eme;3eme`<br><br>"
+        "Vous pouvez modifier directement le planning dans le tableau ci-dessous une fois généré."
     )
     
     with gr.Row():
@@ -243,13 +266,20 @@ with gr.Blocks() as demo:
             lines=2,
             value="0, 1, 1, 1, 1\n1, 1, 1, 0, 1"
         )
+    with gr.Row():
+        invigilators_input = gr.Slider(
+            label="Nombre d'enseignants disponibles par créneau", minimum=1, maximum=10, step=1, value=3
+        )
+    
+    # Composant DataFrame interactif pour afficher et modifier le planning
+    schedule_output = gr.Dataframe(headers=["Examen", "Filière", "Promotion", "Créneau", "Salle", "Nb Étudiants", "Reprise", "Durée (h)"],
+                                   label="Calendrier des examens (modifiable)", interactive=True)
     
-    output = gr.Markdown(label="Calendrier des examens")
     solve_btn = gr.Button("Planifier les examens")
     solve_btn.click(
         fn=solve_in_thread,
-        inputs=[exams_input, rooms_input, num_slots_input, conflicts_input, availability_input],
-        outputs=output
+        inputs=[exams_input, rooms_input, num_slots_input, conflicts_input, availability_input, invigilators_input],
+        outputs=schedule_output
     )
     
 demo.launch()