first version

app.py

@@ -0,0 +1,208 @@
+import gradio as gr
+from ortools.sat.python import cp_model
+import concurrent.futures
+
+def solve_exam_schedule(exams_text, rooms_text, num_slots, conflicts_text, availability_text):
+    # --- 1. Parsing des données ---
+    allowed_filiere = {"IA", "SEIOT", "IM", "SI", "GL"}
+    exams = []
+    for line in exams_text.strip().splitlines():
+        if 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))
+    num_exams = len(exams)
+    
+    exam_id_to_index = {exam[0]: idx for idx, exam in enumerate(exams)}
+    
+    rooms = []
+    for line in rooms_text.strip().splitlines():
+        if line.strip() == "":
+            continue
+        parts = line.split(',')
+        room_id = int(parts[0].strip())
+        capacity = int(parts[1].strip())
+        rooms.append((room_id, capacity))
+    num_rooms = len(rooms)
+    
+    user_conflicts = []
+    for line in conflicts_text.strip().splitlines():
+        if 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."
+    
+    auto_conflicts = []
+    for i in range(num_exams):
+        for j in range(i + 1, num_exams):
+            if exams[i][3] == exams[j][3]:
+                auto_conflicts.append((i, j))
+    
+    all_conflicts = set(user_conflicts + auto_conflicts)
+    
+    availability = {}
+    for line in availability_text.strip().splitlines():
+        if line.strip() == "":
+            continue
+        parts = line.split(',')
+        room_id = int(parts[0].strip())
+        slots = [int(s.strip()) for s in parts[1:]]
+        availability[room_id] = slots
+    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. Modélisation avec OR-Tools ---
+    model = cp_model.CpModel()
+    
+    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}')
+    
+    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)
+    
+    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))
+                <= rooms[k][1]
+            )
+    
+    for (i, l) in all_conflicts:
+        for j in range(num_slots):
+            model.Add(
+                sum(x[(i, j, k)] for k in range(num_rooms)) +
+                sum(x[(l, j, k)] for k in range(num_rooms))
+                <= 1
+            )
+    
+    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)
+    
+    T_max = model.NewIntVar(0, num_slots - 1, 'T_max')
+    y = {}
+    for i in range(num_exams):
+        for j in range(num_slots):
+            y[(i, j)] = model.NewBoolVar(f'y_{i}_{j}')
+            model.Add(sum(x[(i, j, k)] for k in range(num_rooms)) == y[(i, j)])
+    
+    for i in range(num_exams):
+        for j in range(num_slots):
+            model.Add(T_max >= j).OnlyEnforceIf(y[(i, j)])
+    
+    model.Minimize(T_max)
+    
+    solver = cp_model.CpSolver()
+    # Limite de temps pour éviter un blocage trop long
+    solver.parameters.max_time_in_seconds = 10
+    status = solver.Solve(model)
+    
+    if status == cp_model.OPTIMAL or status == cp_model.FEASIBLE:
+        schedule = []
+        for i in range(num_exams):
+            for j in range(num_slots):
+                for k in range(num_rooms):
+                    if solver.Value(x[(i, j, k)]) == 1:
+                        exam_id = exams[i][0]
+                        nb_students = exams[i][1]
+                        duration = exams[i][2]
+                        filiere = exams[i][3]
+                        room_id = rooms[k][0]
+                        schedule.append({
+                            "Examen": exam_id,
+                            "Filière": filiere,
+                            "Créneau": j,
+                            "Salle": room_id,
+                            "Nb Étudiants": nb_students,
+                            "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"
+            )
+        return output_text
+    else:
+        return "Aucune solution trouvée."
+
+# 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(
+        "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`"
+    )
+    
+    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"
+        )
+    with gr.Row():
+        rooms_input = gr.Textbox(
+            label="Liste des salles (chaque ligne: room_id, capacité)",
+            lines=2,
+            value="0, 50\n1, 30"
+        )
+    with gr.Row():
+        num_slots_input = gr.Slider(
+            label="Nombre de créneaux", minimum=1, maximum=10, step=1, value=4
+        )
+    with gr.Row():
+        conflicts_input = gr.Textbox(
+            label="Conflits supplémentaires (chaque ligne: 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)"),
+            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,
+        inputs=[exams_input, rooms_input, num_slots_input, conflicts_input, availability_input],
+        outputs=output
+    )
+    
+demo.launch()