new files

app.py

@@ -0,0 +1,256 @@
+import gradio as gr
+import pandas as pd
+from pulp import LpProblem, LpMinimize, LpVariable, lpSum, LpBinary, LpStatus
+import concurrent.futures
+
+def solve_exam_schedule_mip(exams_text, rooms_text, num_slots, conflicts_text, availability_text, invigilators):
+    # --- 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
+        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
+        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
+        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
+        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}"
+    
+    # --- 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."}])
+
+# 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()
+
+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
+    )
+    
+demo.launch()

requirements.txt

@@ -0,0 +1 @@
+pulp