Ajout de message plus précis avec le code et l'intitulé de l'UE. Correction de...

Ajout de message plus précis avec le code et l'intitulé de l'UE. Correction de bug: 2 groupes d'une même UE et même sillons ne sont pas ajoutée à la théorie des incomp

main.py

 import pandas as pd
 import os
-import openpyxl
 from itertools import combinations
 
 file_groupes_sillons = 'groupes_sillons/VET_Info.xlsx'
 directory_incomp_path = 'incomp_apogee'
 files_incomp_apogee = [os.path.join(directory_incomp_path, file) for file in os.listdir(directory_incomp_path) if file.endswith('.xlsx')]
 
-wb = openpyxl.load_workbook(file_groupes_sillons)
-ws = wb.active
+df = pd.read_excel(file_groupes_sillons)
+df['Sillon'] = df['Sillon'].ffill()
+df['CODE APOGEE'] = df['CODE APOGEE'].ffill()
+df['INTITULE MATIERE'] = df['INTITULE MATIERE'].ffill()
 
 sillon_to_groups = {}
 groupe_to_sillons = {}
 groupe_to_ue = {}
+groupe_to_intitule = {}
 all_incompatibilities_apogee = set()
 all_incompatibilities_theory = set()
 
@@ -20,9 +22,12 @@ all_incompatibilities_theory = set()
 def dic_creator():
     current_sillon = None
     current_ue = None
-    for row in ws.iter_rows(min_row=2, min_col=3, max_col=5, values_only=True):
-        ue, group_name, sillon = row
-        group_name = group_name.strip().upper()
+    current_intitule = None
+    for index, row in df.iterrows():
+        group_name = row['Groupe'].strip().upper()
+        sillon = row['Sillon']
+        ue = row['CODE APOGEE']
+        intitule = row['INTITULE MATIERE']
 
         # si la cellule sillon est vide (cas fusion), on utilisera la dernière valeur connue
         if sillon:
@@ -30,6 +35,10 @@ def dic_creator():
         # si la cellule ue est vide (cas fusion), on utilisera la dernière valeur connue
         if ue:
             current_ue = ue
+        # si la cellule intitulé est vide (cas fusion), on utilisera la dernière valeur connue
+        if intitule:
+            current_intitule = intitule
+
         sillons_list = str(current_sillon).split('+')
 
         for sillon in sillons_list:
@@ -40,22 +49,21 @@ def dic_creator():
                 else:
                     sillon_to_groups[sillon] = [group_name]
             else:
-                print(f"Sillon pas reconnu: {row}")
+                print(f"Sillon pas reconnu pour {group_name}")
         groupe_to_sillons[group_name] = [s.strip().upper() for s in sillons_list]
         groupe_to_ue[group_name] = current_ue
+        groupe_to_intitule[group_name] = current_intitule
 
-
-def afficher_infos():
-    print("Sillons to Groupes:")
+def print_infos():
+    print("--- Liste des groupes pour chaque sillon :")
     for sillon, groupes in sillon_to_groups.items():
         print(f"Sillon {sillon}: {groupes}")
-    print("\nGroupes to Sillons:")
+    print("\n--- Sillons pour chaque groupe :")
     for groupe, sillons in groupe_to_sillons.items():
         print(f"Groupe {groupe}: {sillons}")
-    print("\nGroupes to Cours:")
+    print("\n--- UE pour chaque groupe :")
     for groupe, cours in groupe_to_ue.items():
-        print(f"Groupe {groupe}: {cours}")
-
+        print(f"Groupe {groupe}: {cours}, {groupe_to_intitule[groupe]}")
 
 # fonction pour vérifier si deux groupes donnés sont incompatibles (même sillon
 # en tenant compte des demi-sillons)
@@ -74,7 +82,7 @@ def check_incompatibility(group1, group2, sillon_dict):
     return False, group1_sillons, group2_sillons
 
 # fonction qui vérifie si une incomp enregistrée dans Apogee renseigne 2 groupes qui appartiennent à
-# des sillons incompatibles. Si les groupes sont en théorie compatibles alors un message d'erreur
+# des sillons incompatibles. Si les groupes sont "en théorie" compatibles alors un message d'erreur
 # est affiché.
 def verifier_apogee_vs_theory():
     for file in files_incomp_apogee:
@@ -82,21 +90,29 @@ def verifier_apogee_vs_theory():
         for index, row in df.iterrows():
             group1 = row['COD_EXT_GPE'].upper()
             group2 = row['COD_EXT_GPE1'].upper()
-            # normalisation de l'ordre pour garantir la cohérence
-            group_pair = tuple(sorted((group1, group2)))
 
-            incompatibility, g1_sillons, g2_sillons = check_incompatibility(group1, group2, sillon_to_groups)
-            if incompatibility:
-                all_incompatibilities_apogee.add(group_pair)
-            else:
-                print(f"Erreur trouvée: {group1} et {group2} ne sont pas sur le même sillon mais déclarés incompatibles dans Apogee. Sillon(s) de {group1}: {g1_sillons}, Sillon(s) de {group2}: {g2_sillons}")
+            # on vérifie que les 2 groupes de l'incomp appartiennent à la VET
+            if (group1 in groupe_to_sillons and groupe_to_sillons[group1]
+                    and group2 in groupe_to_sillons and groupe_to_sillons[group2]):
+                # normalisation de l'ordre pour garantir la cohérence
+                group_pair = tuple(sorted((group1, group2)))
+
+                incompatibility, g1_sillons, g2_sillons = check_incompatibility(group1, group2, sillon_to_groups)
+                if incompatibility:
+                    all_incompatibilities_apogee.add(group_pair)
+                else:
+                    print(f"Erreur trouvée: {group1} ({groupe_to_ue[group1]}, {groupe_to_intitule[group1]}) et "
+                          f"{group2} ({groupe_to_ue[group2]}, {groupe_to_intitule[group2]}) "
+                          f"ne sont pas sur le même sillon mais déclarés incompatibles dans Apogee. "
+                          f"Sillon(s) de {group1}: {g1_sillons}, Sillon(s) de {group2}: {g2_sillons}")
 
 # fonction qui génére toutes les incomp d'après la théorie de l'association groupes/sillons
 def incomp_theory_creator():
     for sillon, groups in sillon_to_groups.items():
         # ajout de toutes les paires du même sillon
         for group1, group2 in combinations(groups, 2):
-            all_incompatibilities_theory.add(tuple(sorted((group1, group2))))
+            if (groupe_to_ue[group1] != groupe_to_ue[group2]): # les groupes doivent appartenir à des UE différentes
+                all_incompatibilities_theory.add(tuple(sorted((group1, group2))))
         # ajout des paires entre demi-sillons A et non-A ou B et non-B
         base_sillon = ''.join(filter(str.isdigit, sillon))
         for other_sillon, other_groups in sillon_to_groups.items():
@@ -113,14 +129,16 @@ def verifier_theory_vs_apogee():
     if missing_incompatibilities:
         print("Oublis détectés dans les incompatibilités:")
         for group1, group2 in missing_incompatibilities:
-            print(f"{group1} et {group2} devraient être incompatibles mais ne sont pas listés dans Apogée.")
+            print(f"{group1} ({groupe_to_ue[group1]}, {groupe_to_intitule[group1]}) et "
+                  f"{group2} ({groupe_to_ue[group2]}, {groupe_to_intitule[group2]}) "
+                  f"devraient être incompatibles mais ne sont pas listés dans Apogée.")
     else:
         print("Aucun oubli détecté.")
 
 dic_creator()
-afficher_infos()
-# print("--- Apogee vs. theory ---")
-# verifier_apogee_vs_theory()
-# incomp_theory_creator()
-# print("--- Theory vs. apogee ---")
-# verifier_theory_vs_apogee()
+print_infos()
+print("--- Apogee vs. theory:")
+verifier_apogee_vs_theory()
+print("--- Theory vs. apogee:")
+incomp_theory_creator()
+verifier_theory_vs_apogee()