Update app.py

app.py

@@ -1,256 +1,142 @@
+# -*- coding: utf-8 -*-
+"""optimisation_examen_PMNE.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1Uewn7e8zZiGZdAAYHqXJtl-3TA7sj5eL
+"""
+
+#!pip install pulp
+#!pip install gradio
+
 import gradio as gr
 import pandas as pd
-from pulp import LpProblem, LpMinimize, LpVariable, lpSum, LpBinary, LpStatus
-import concurrent.futures
+from pulp import LpMinimize, LpProblem, LpVariable, lpSum
 
-def solve_exam_schedule_mip(exams_text, rooms_text, num_slots, conflicts_text, availability_text, invigilators):
+def planifier_examens(examens_text, salles_text, jours_text, creneaux_text, disponibilite_salle_text, conflits_text):
     # --- 1. Parsing des données ---
-    # Ensembles autorisés pour filières et promotions
-    allowed_filiere = {"IA", "SEIOT", "IM", "SI", "GL"}
-    allowed_promotions = {"1ere", "2eme", "3eme", "master1", "master2"}
-    
-    # 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():
-            continue
+    # Examens
+    examens = []
+    for line in examens_text.strip().splitlines():
         parts = line.split(',')
-        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_set = {f.strip() for f in parts[3].split(';')}
-        if not filiere_set.issubset(allowed_filiere):
-            return f"Erreur : filière(s) non autorisée(s). Autorisées : {', '.join(allowed_filiere)}."
-        promotion_set = {p.strip() for p in parts[4].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)
-    
-    # Mapping exam_id -> index (pour gérer les conflits manuels)
-    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 not line.strip():
-            continue
+        if len(parts) == 3:
+            exam_id, nb_students, duration = parts
+            examens.append((exam_id.strip(), int(nb_students.strip()), int(duration.strip())))
+
+    # Salles et capacités
+    salles = {}
+    for line in salles_text.strip().splitlines():
         parts = line.split(',')
-        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 (manuels) : chaque ligne "exam1, exam2"
-    manual_conflicts = []
-    for line in conflicts_text.strip().splitlines():
-        if not line.strip():
-            continue
+        if len(parts) == 2:
+            room_id, capacity = parts
+            salles[room_id.strip()] = int(capacity.strip())
+
+    # Jours et créneaux
+    jours = [int(j.strip()) for j in jours_text.split(',')]
+    creneaux = [int(c.strip()) for c in creneaux_text.split(',')]
+
+    # Disponibilité des salles
+    disponibilite_salle = {}
+    for line in disponibilite_salle_text.strip().splitlines():
         parts = line.split(',')
-        try:
-            e1 = exam_id_to_index[int(parts[0].strip())]
-            e2 = exam_id_to_index[int(parts[1].strip())]
-            manual_conflicts.append((e1, e2))
-        except (KeyError, ValueError):
-            return "Erreur dans les conflits manuels : vérifiez que les exam_id existent."
-    
-    # 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))
-    all_conflicts = set(manual_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 not line.strip():
-            continue
+        room_id = parts[0].strip()
+        disponibilite_salle[room_id] = [int(s) for s in parts[1:]]
+
+    # Conflits entre examens
+    conflits = []
+    for line in conflits_text.strip().splitlines():
         parts = line.split(',')
-        try:
-            room_id = int(parts[0].strip())
-            slots = [int(s.strip()) for s in parts[1:]]
-        except:
-            return "Erreur dans la disponibilité : vérifiez le format."
-        availability[room_id] = slots
-    # Construction de la matrice de disponibilité dans l'ordre des salles fournies
-    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)
-    
-    # --- 2. Formulation MILP avec PuLP ---
-    prob = LpProblem("Exam_Scheduling", LpMinimize)
-    
-    # Variables 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)] = LpVariable(f"x_{i}_{j}_{k}", cat=LpBinary)
-    
-    # Pour gérer la marge de transition, on définit y[j,k] = 1 si la salle k est utilisée au créneau j.
-    y = {}
-    for j in range(num_slots):
-        for k in range(num_rooms):
-            y[(j,k)] = LpVariable(f"y_{j}_{k}", cat=LpBinary)
-    
-    # Variables T[j] indiquant si le créneau j est utilisé (pour minimiser le nombre de créneaux)
-    T = {}
-    for j in range(num_slots):
-        T[j] = LpVariable(f"T_{j}", cat=LpBinary)
-    
-    # Objectif : Minimiser le nombre total de créneaux utilisés
-    prob += lpSum([T[j] for j in range(num_slots)]), "Minimize_total_slots"
-    
-    # Contrainte 1 : chaque examen est programmé exactement une fois
-    for i in range(num_exams):
-        prob += lpSum([x[(i,j,k)] for j in range(num_slots) for k in range(num_rooms)]) == 1, f"Exam_{i}_once"
-    
-    # Contrainte 2 : capacité de chaque salle à chaque créneau
-    for j in range(num_slots):
-        for k in range(num_rooms):
-            prob += lpSum([(exams[i][1] + exams[i][5]) * x[(i,j,k)] for i in range(num_exams)]) <= rooms[k][1], f"Capacity_slot_{j}_room_{k}"
-    
-    # Contrainte 3 : 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):
-            prob += lpSum([x[(i,j,k)] for k in range(num_rooms)]) + lpSum([x[(l,j,k)] for k in range(num_rooms)]) <= 1, f"Conflict_{i}_{l}_slot_{j}"
-    
-    # Contrainte 4 : 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):
-                    prob += x[(i,j,k)] == 0, f"Avail_room_{k}_slot_{j}_exam_{i}"
-    
-    # Contrainte 5 : disponibilité des enseignants (ressources humaines)
-    for j in range(num_slots):
-        prob += lpSum([x[(i,j,k)] for i in range(num_exams) for k in range(num_rooms)]) <= invigilators, f"Teachers_slot_{j}"
-    
-    # Contrainte 6 : un étudiant (promotion) ne peut avoir deux examens simultanés
-    for p in allowed_promotions:
-        for j in range(num_slots):
-            prob += lpSum([x[(i,j,k)] for i in range(num_exams) if p in exams[i][4] for k in range(num_rooms)]) <= 1, f"Promotion_{p}_slot_{j}"
-    
-    # Contrainte 7 : marges de transition dans chaque salle
-    # On lie d'abord y[j,k] à l'utilisation de la salle
-    for j in range(num_slots):
-        for k in range(num_rooms):
-            prob += y[(j,k)] >= lpSum([x[(i,j,k)] for i in range(num_exams)])/100.0, f"Link_y_lower_{j}_{k}"
-            prob += y[(j,k)] <= lpSum([x[(i,j,k)] for i in range(num_exams)]), f"Link_y_upper_{j}_{k}"
-    # Puis, pour chaque salle, deux créneaux consécutifs ne peuvent être utilisés
-    for k in range(num_rooms):
-        for j in range(num_slots - 1):
-            prob += y[(j,k)] + y[(j+1,k)] <= 1, f"Transition_room_{k}_slots_{j}_{j+1}"
-    
-    # Contrainte 8 : liaison des variables T[j] : T[j] = 1 si un examen est programmé en slot j
-    for j in range(num_slots):
-        prob += T[j] >= lpSum([x[(i,j,k)] for i in range(num_exams) for k in range(num_rooms)])/100.0, f"Link_T_lower_{j}"
-        prob += T[j] <= lpSum([x[(i,j,k)] for i in range(num_exams) for k in range(num_rooms)]), f"Link_T_upper_{j}"
-    
+        conflits.append((parts[0].strip(), parts[1].strip()))
+
+    # --- 2. Modélisation avec PuLP (PMNE) ---
+    model = LpProblem("Planification_Examens", LpMinimize)
+
+    # Variables de décision
+    X = {(e, d, c, s): LpVariable(f"X_{e}_{d}_{c}_{s}", cat="Binary")
+         for e, _, _ in examens for d in jours for c in creneaux for s in salles}
+    Y = {d: LpVariable(f"Y_{d}", cat="Binary") for d in jours}
+
+    # Contrainte 1 : Chaque examen doit être programmé une seule fois
+    for e, _, _ in examens:
+        model += lpSum(X[e, d, c, s] for d in jours for c in creneaux for s in salles) == 1
+
+    # Contrainte 2 : Capacité des salles respectée
+    for d in jours:
+        for c in creneaux:
+            for s in salles:
+                model += lpSum(nb_students * X[e, d, c, s] for e, nb_students, _ in examens) <= salles[s]
+
+    # Contrainte 3 : Une salle ne peut accueillir qu’un seul examen par créneau
+    for d in jours:
+        for c in creneaux:
+            for s in salles:
+                model += lpSum(X[e, d, c, s] for e, _, _ in examens) <= 1
+
+    # Contrainte 4 : Disponibilité des salles
+    for e, _, _ in examens:
+        for d in jours:
+            for c in creneaux:
+                for s in salles:
+                    if disponibilite_salle[s][c - 1] == 0:
+                        model += X[e, d, c, s] == 0
+
+    # Contrainte 5 : Conflits entre examens (ne pas être en même temps)
+    for e1, e2 in conflits:
+        for d in jours:
+            for c in creneaux:
+                model += lpSum(X[e1, d, c, s] for s in salles) + lpSum(X[e2, d, c, s] for s in salles) <= 1
+
+    # Contrainte 6 : Activation des jours
+    for d in jours:
+        for e, _, _ in examens:
+            for c in creneaux:
+                for s in salles:
+                    model += Y[d] >= X[e, d, c, s]
+
+    # Fonction Objectif : Minimiser le nombre de jours utilisés
+    model += lpSum(Y[d] for d in jours)
+
     # --- 3. Résolution ---
-    prob.solve()
-    
-    if LpStatus[prob.status] in ["Optimal", "Feasible"]:
-        schedule = []
-        for i in range(num_exams):
-            for j in range(num_slots):
-                for k in range(num_rooms):
-                    if x[(i,j,k)].varValue is not None and x[(i,j,k)].varValue > 0.5:
-                        schedule.append({
-                            "Examen": exams[i][0],
-                            "Filière": ";".join(sorted(list(exams[i][3]))),
-                            "Promotion": ";".join(sorted(list(exams[i][4]))),
-                            "Créneau": j,
-                            "Salle": rooms[k][0],
-                            "Nb Étudiants": exams[i][1],
-                            "Reprise": exams[i][5],
-                            "Durée (h)": exams[i][2]
-                        })
-        schedule = sorted(schedule, key=lambda s: s["Créneau"])
-        df = pd.DataFrame(schedule)
-        return df
-    else:
-        return pd.DataFrame([{"Message": "Aucune solution trouvée."}])
+    model.solve()
 
-# Exécuter dans un thread séparé pour ne pas bloquer l'interface Gradio
-executor = concurrent.futures.ThreadPoolExecutor(max_workers=4)
-def solve_in_thread(*args, **kwargs):
-    future = executor.submit(solve_exam_schedule_mip, *args, **kwargs)
-    return future.result()
+    # --- 4. Extraction des résultats ---
+    planning = []
+    for e, _, _ in examens:
+        for d in jours:
+            for c in creneaux:
+                for s in salles:
+                    if X[e, d, c, s].varValue == 1:
+                        planning.append({"Examen": e, "Jour": d, "Créneau": c, "Salle": s})
+
+    df = pd.DataFrame(planning)
+    df.to_csv("planning_examens.csv", index=False)
+
+    return df, "planning_examens.csv"
+
+# Interface avec Gradio
+with gr.Blocks() as demo:
+    gr.Markdown("# 📅 Planification des Examens avec PMNE et Gradio")
+
+    exams_input = gr.Textbox(label="Examens (exam_id, nb_étudiants, durée)", lines=5,
+                             value="E1, 30, 2\nE2, 25, 1\nE3, 40, 2\nE4, 20, 1")
+    rooms_input = gr.Textbox(label="Salles (room_id, capacité)", lines=3,
+                             value="S1, 50\nS2, 30\nS3, 40")
+    jours_input = gr.Textbox(label="Jours disponibles (séparés par des virgules)", value="1, 2, 3")
+    creneaux_input = gr.Textbox(label="Créneaux disponibles (séparés par des virgules)", value="1, 2, 3, 4")
+    disponibilite_input = gr.Textbox(label="Disponibilité des salles (room_id, slot1, slot2, ...)", lines=4,
+                                     value="S1, 1, 1, 1, 1\nS2, 1, 1, 0, 1\nS3, 1, 1, 1, 0")
+    conflits_input = gr.Textbox(label="Conflits entre examens (exam1, exam2)", lines=3,
+                                value="E1, E3")
+
+    output_table = gr.Dataframe(headers=["Examen", "Jour", "Créneau", "Salle"], label="Planning des examens")
+    output_file = gr.File(label="Télécharger le planning")
 
-with gr.Blocks(css=".gradio-container {max-width: 900px; margin: auto;}") as demo:
-    gr.Markdown("# Planification des Examens Multi-Promotions, Filières, avec MIP (PuLP)")
-    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`"
-    )
-    
-    with gr.Row():
-        exams_input = gr.Textbox(
-            label="Liste des examens",
-            lines=5,
-            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 (room_id, capacité)",
-            lines=2,
-            value="0, 50\n1, 30\n2, 40"
-        )
-    with gr.Row():
-        num_slots_input = gr.Slider(
-            label="Nombre de créneaux", minimum=1, maximum=10, step=1, value=5
-        )
-    with gr.Row():
-        conflicts_input = gr.Textbox(
-            label="Conflits supplémentaires (exam1, exam2) [optionnel]",
-            lines=2,
-            value="1, 3"
-        )
-    with gr.Row():
-        availability_input = gr.Textbox(
-            label="Disponibilité des salles (room_id, slot1, slot2, ... avec 1 pour dispo, 0 sinon)",
-            lines=2,
-            value="0, 1, 1, 1, 1, 1\n1, 1, 1, 0, 1, 1\n2, 1, 1, 1, 1, 0"
-        )
-    with gr.Row():
-        invigilators_input = gr.Slider(
-            label="Nombre d'enseignants disponibles par créneau", minimum=1, maximum=10, step=1, value=3
-        )
-    
-    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)
-    
     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, invigilators_input],
-        outputs=schedule_output
+        fn=planifier_examens,
+        inputs=[exams_input, rooms_input, jours_input, creneaux_input, disponibilite_input, conflits_input],
+        outputs=[output_table, output_file]
     )
-    
+
 demo.launch()