Update app.py

app.py

@@ -4,90 +4,133 @@ import concurrent.futures
 
 def solve_exam_schedule(exams_text, rooms_text, num_slots, conflicts_text, availability_text):
     # --- 1. Parsing des données ---
+    # Ensembles des filières et promotions autorisées
     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)
     exams = []
     for line in exams_text.strip().splitlines():
-        if line.strip() == "":
+        if not line.strip():
             continue
         parts = line.split(',')
-        if len(parts) < 4:
-            return "Erreur dans la saisie des examens. Chaque ligne doit comporter 4 valeurs : exam_id, nb_etudiants, durée, filière."
-        exam_id = int(parts[0].strip())
-        nb_students = int(parts[1].strip())
-        duration = int(parts[2].strip())
-        filiere = parts[3].strip()
-        if filiere not in allowed_filiere:
-            return f"Erreur : la filière '{filiere}' n'est pas autorisée. Les filières autorisées sont : {', '.join(allowed_filiere)}."
-        exams.append((exam_id, nb_students, duration, filiere))
+        if len(parts) < 5:
+            return "Erreur : chaque ligne d'examen doit avoir au moins 5 valeurs : exam_id, nb_etudiants, durée, filière, promotion."
+        try:
+            exam_id = int(parts[0].strip())
+            nb_students = int(parts[1].strip())
+            duration = int(parts[2].strip())
+        except ValueError:
+            return "Erreur : exam_id, nb_etudiants et durée doivent être des nombres."
+        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)}."
+        promotion_str = parts[4].strip()
+        promotion_set = {p.strip() for p in promotion_str.split(';')}
+        if not promotion_set.issubset(allowed_promotions):
+            return f"Erreur : promotion(s) non autorisée(s). Autorisées : {', '.join(allowed_promotions)}."
+        reprise = 0
+        if len(parts) >= 6:
+            try:
+                reprise = int(parts[5].strip())
+            except ValueError:
+                return "Erreur : la reprise doit être un nombre entier."
+        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)
     exam_id_to_index = {exam[0]: idx for idx, exam in enumerate(exams)}
     
+    # Lecture des salles : chaque ligne "room_id, capacité"
     rooms = []
     for line in rooms_text.strip().splitlines():
-        if line.strip() == "":
+        if not line.strip():
             continue
         parts = line.split(',')
-        room_id = int(parts[0].strip())
-        capacity = int(parts[1].strip())
+        try:
+            room_id = int(parts[0].strip())
+            capacity = int(parts[1].strip())
+        except ValueError:
+            return "Erreur : room_id et capacité doivent être des nombres."
         rooms.append((room_id, capacity))
     num_rooms = len(rooms)
     
+    # Conflits supplémentaires (saisie manuelle, chaque ligne : exam1, exam2)
     user_conflicts = []
     for line in conflicts_text.strip().splitlines():
-        if line.strip() == "":
+        if not line.strip():
             continue
         parts = line.split(',')
         try:
             e1 = exam_id_to_index[int(parts[0].strip())]
             e2 = exam_id_to_index[int(parts[1].strip())]
             user_conflicts.append((e1, e2))
-        except KeyError:
-            return "Erreur dans les conflits. Vérifiez que les exam_id existent dans la liste des examens."
+        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
     auto_conflicts = []
     for i in range(num_exams):
         for j in range(i + 1, num_exams):
-            if exams[i][3] == exams[j][3]:
+            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)
     availability = {}
     for line in availability_text.strip().splitlines():
-        if line.strip() == "":
+        if not line.strip():
             continue
         parts = line.split(',')
-        room_id = int(parts[0].strip())
-        slots = [int(s.strip()) for s in parts[1:]]
+        try:
+            room_id = int(parts[0].strip())
+        except ValueError:
+            return "Erreur : room_id dans la disponibilité doit être un nombre."
+        slots = []
+        for s in parts[1:]:
+            try:
+                slots.append(int(s.strip()))
+            except ValueError:
+                return "Erreur : les valeurs de disponibilité doivent être 0 ou 1."
         availability[room_id] = slots
+    # Construction de la matrice de disponibilité dans l'ordre des salles
     avail_matrix = []
     for room in rooms:
         room_id = room[0]
         if room_id in availability:
             avail_matrix.append(availability[room_id])
         else:
-            avail_matrix.append([1]*num_slots)
+            avail_matrix.append([1] * num_slots)
     
     # --- 2. Modélisation avec OR-Tools ---
     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 = {}
     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
     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
     for j in range(num_slots):
         for k in range(num_rooms):
             model.Add(
-                sum(exams[i][1] * x[(i, j, k)] for i in range(num_exams))
+                sum((exams[i][1] + exams[i][5]) * x[(i, j, k)] for i in range(num_exams))
                 <= 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
     for (i, l) in all_conflicts:
         for j in range(num_slots):
             model.Add(
@@ -96,12 +139,14 @@ def solve_exam_schedule(exams_text, rooms_text, num_slots, conflicts_text, avail
                 <= 1
             )
     
+    # 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)
     
+    # Objectif : Minimiser le dernier créneau utilisé (T_max)
     T_max = model.NewIntVar(0, num_slots - 1, 'T_max')
     y = {}
     for i in range(num_exams):
@@ -115,9 +160,9 @@ def solve_exam_schedule(exams_text, rooms_text, num_slots, conflicts_text, avail
     
     model.Minimize(T_max)
     
+    # --- 3. Résolution ---
     solver = cp_model.CpSolver()
-    # Limite de temps pour éviter un blocage trop long
-    solver.parameters.max_time_in_seconds = 10
+    solver.parameters.max_time_in_seconds = 10  # Limite de temps pour éviter un blocage trop long
     status = solver.Solve(model)
     
     if status == cp_model.OPTIMAL or status == cp_model.FEASIBLE:
@@ -129,22 +174,26 @@ def solve_exam_schedule(exams_text, rooms_text, num_slots, conflicts_text, avail
                         exam_id = exams[i][0]
                         nb_students = exams[i][1]
                         duration = exams[i][2]
-                        filiere = exams[i][3]
+                        filiere = ";".join(sorted(list(exams[i][3])))
+                        promotions = ";".join(sorted(list(exams[i][4])))
+                        reprise = exams[i][5]
                         room_id = rooms[k][0]
                         schedule.append({
                             "Examen": exam_id,
                             "Filière": filiere,
+                            "Promotion": promotions,
                             "Créneau": j,
                             "Salle": room_id,
                             "Nb Étudiants": nb_students,
+                            "Reprise": reprise,
                             "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']} | Créneau: {item['Créneau']} | "
-                f"Salle: {item['Salle']} | Étudiants: {item['Nb Étudiants']} | Durée: {item['Durée (h)']}h\n\n"
+                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
     else:
@@ -152,29 +201,29 @@ def solve_exam_schedule(exams_text, rooms_text, num_slots, conflicts_text, avail
 
 # Utilisation d'un ThreadPoolExecutor pour exécuter la fonction 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 avec Filières (IA, SEIOT, IM, SI, GL)")
+    gr.Markdown("# Planification des Examens Multi-Promotions et Filières")
     gr.Markdown(
-        "Remplissez les champs ci-dessous pour définir le problème de planification des examens. "
-        "Pour les examens, chaque ligne doit être sous la forme :<br>"
-        "`exam_id, nb_etudiants, durée, filière`<br>"
-        "Exemple: `0, 30, 2, IA`"
+        "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`"
     )
     
     with gr.Row():
         exams_input = gr.Textbox(
             label="Liste des examens",
             lines=5,
-            value="0, 30, 2, IA\n1, 25, 1, SEIOT\n2, 40, 2, IA\n3, 20, 1, SI"
+            value="0, 30, 2, IA, 1ere, 5\n1, 25, 1, SEIOT, 2eme, 0\n2, 40, 2, IA;GL, 3eme, 0\n3, 20, 1, SI, master1, 0"
         )
     with gr.Row():
         rooms_input = gr.Textbox(
-            label="Liste des salles (chaque ligne: room_id, capacité)",
+            label="Liste des salles (room_id, capacité)",
             lines=2,
             value="0, 50\n1, 30"
         )
@@ -184,20 +233,18 @@ with gr.Blocks() as demo:
         )
     with gr.Row():
         conflicts_input = gr.Textbox(
-            label="Conflits supplémentaires (chaque ligne: exam1, exam2) [optionnel]",
+            label="Conflits supplémentaires (exam1, exam2) [optionnel]",
             lines=2,
             value="1, 3"
         )
     with gr.Row():
         availability_input = gr.Textbox(
-            label=("Disponibilité des salles (chaque ligne: room_id, slot1, slot2, ... "
-                   "avec 1 pour dispo, 0 sinon)"),
+            label="Disponibilité des salles (room_id, slot1, slot2, ... avec 1 pour dispo, 0 sinon)",
             lines=2,
             value="0, 1, 1, 1, 1\n1, 1, 1, 0, 1"
         )
     
     output = gr.Markdown(label="Calendrier des examens")
-    
     solve_btn = gr.Button("Planifier les examens")
     solve_btn.click(
         fn=solve_in_thread,