app/pe/pe_etudiant.py

@@ -687,7 +687,7 @@ def convert_trajectoire_to_sxtag_id(trajectoire: dict[int:FormSemestre]) -> (int
     if not trajectoire:
         return None
     rangs = [formsemestre.semestre_id for formsemestre in trajectoire.values()]
-    assert rangs == min(rangs), "Les trajectoires doivent être de même rang"
+    assert len(set(rangs)) == 1, "Les trajectoires doivent être de même rang"
     rang = min(rangs)
     fid_terminal = list(trajectoire.values())[0].formsemestre_id
     for fid, formsemestre in trajectoire.items():

app/pe/pe_jury.py

@@ -53,11 +53,12 @@ import pandas as pd
 from app.pe import pe_sxtag
 from app.pe.pe_affichage import NOM_STAT_PROMO, SANS_NOTE, NOM_STAT_GROUPE
 import app.pe.pe_affichage as pe_affichage
-from app.pe.pe_etudiant import *  # TODO A éviter -> pe_etudiant.
+import app.pe.pe_etudiant as pe_etudiant
 import app.pe.pe_rcs as pe_rcs
 from app.pe.pe_rcstag import RCSTag
 from app.pe.pe_ressemtag import ResSemBUTTag
 from app.pe.pe_interclasstag import RCSInterclasseTag
+import app.pe.pe_comp as pe_comp
 
 
 class JuryPE(object):
@@ -87,7 +88,9 @@ class JuryPE(object):
             f"""*** Recherche et chargement des étudiants diplômés en {
                 self.diplome}"""
         )
-        self.etudiants = EtudiantsJuryPE(self.diplome)  # Les infos sur les étudiants
+        self.etudiants = pe_etudiant.EtudiantsJuryPE(
+            self.diplome
+        )  # Les infos sur les étudiants
         self.etudiants.find_etudiants()
         self.diplomes_ids = self.etudiants.diplomes_ids
 
@@ -100,7 +103,7 @@ class JuryPE(object):
 
                 self._gen_xls_ressembuttags(zipfile)
                 self._gen_xls_sxtags(zipfile)
-                self._gen_xls_rcss_tags(zipfile)
+                # self._gen_xls_rcss_tags(zipfile)
                 # self._gen_xls_interclassements_rcss(zipfile)
                 # self._gen_xls_synthese_jury_par_tag(zipfile)
                 # self._gen_xls_synthese_par_etudiant(zipfile)
@@ -136,17 +139,19 @@ class JuryPE(object):
 
     def _gen_xls_ressembuttags(self, zipfile: ZipFile):
         """Calcule les moyennes par tag des résultats des Semestres BUT"""
-        pe_affichage.pe_print("*** Génère les ResSemBUTTag (résultats des semestres BUT taggués)")
+        pe_affichage.pe_print(
+            "*** Génère les ResSemBUTTag (résultats des semestres BUT taggués)"
+        )
 
         formsemestres = get_formsemestres_etudiants(self.etudiants)
-        pe_affichage.pe_print(f" --> {len(formsemestres)} résultats de semestres à considérer")
+        pe_affichage.pe_print(
+            f" --> {len(formsemestres)} résultats de semestres à considérer"
+        )
 
-        ressembuttags = {}
+        self.ressembuttags = {}
         for frmsem_id, formsemestre in formsemestres.items():
             # Crée le semestre_tag et exécute les calculs de moyennes
-            ressembuttags[frmsem_id] = ResSemBUTTag(formsemestre)
+            self.ressembuttags[frmsem_id] = ResSemBUTTag(formsemestre)
-
-        return ressembuttags
 
         # Intègre le bilan des semestres taggués au zip final
         output = io.BytesIO()
@@ -186,18 +191,23 @@ class JuryPE(object):
 
         # Les regroupements de Sx
         self.regroupements = {}
-        for rang in range(1, pe_comp.NBRE_SEMESTRES_DIPLOMANT+1):
+        for rang in range(1, pe_comp.NBRE_SEMESTRES_DIPLOMANT + 1):
             self.regroupements[rang] = {}
             for etudid in self.etudiants.etudiants_ids:
-                trajectoire = self.etudiants.cursus[etudid][f"S{rang}"]
+                trajectoire = self.etudiants.trajectoires[etudid][f"S{rang}"]
-                self.regroupements[rang] |= trajectoire
+                if trajectoire:
+                    sxtag_id = pe_etudiant.convert_trajectoire_to_sxtag_id(trajectoire)
+                    if sxtag_id not in self.regroupements[rang]:
+                        self.regroupements[rang][sxtag_id] = {}
+                    else:
+                        self.regroupements[rang][sxtag_id] |= trajectoire
 
         # Les SxTag
         self.sxtags = {}
-        for rang in range(1, pe_comp.NBRE_SEMESTRES_DIPLOMANT+1):
+        for rang in range(1, pe_comp.NBRE_SEMESTRES_DIPLOMANT + 1):
-            trajectoire = self.regroupements[rang]
+            for sxtag_id in self.regroupements[rang]:
-            sxtag_id = pe_sxtag.get_sxtag_from_semestres(trajectoire)
+                trajectoires = self.regroupements[rang][sxtag_id]
-            ressemstags = {fid: self.ressembuttags[fid] for fid in trajectoire}
+                ressemstags = {fid: self.ressembuttags[fid] for fid in trajectoires}
                 self.sxtags[sxtag_id] = pe_sxtag.SxTag(sxtag_id, ressemstags)
 
         # Intègre le bilan des semestres taggués au zip final
@@ -593,7 +603,7 @@ class JuryPE(object):
         return df
 
 
-def get_formsemestres_etudiants(etudiants: EtudiantsJuryPE) -> dict:
+def get_formsemestres_etudiants(etudiants: pe_etudiant.EtudiantsJuryPE) -> dict:
     """Ayant connaissance des étudiants dont il faut calculer les moyennes pour
     le jury PE (attribut `self.etudiant_ids) et de leurs trajectoires (semestres
     parcourus), renvoie un dictionnaire ``{fid: FormSemestre(fid)}``
@@ -614,12 +624,8 @@ def get_formsemestres_etudiants(etudiants: EtudiantsJuryPE) -> dict:
     return semestres
 
 
-
-
-
-
 def compute_interclassements(
-    etudiants: EtudiantsJuryPE,
+    etudiants: pe_etudiant.EtudiantsJuryPE,
     trajectoires_jury_pe: pe_rcs.RCSsJuryPE,
     trajectoires_tagguees: dict[tuple, pe_rcs.RCS],
 ):

app/pe/pe_sxtag.py

@@ -74,7 +74,7 @@ class SxTag(TableTag):
         """
         TableTag.__init__(self)
 
-        assert sxtag_id and len(sxtag_id) == 2 and sxtag_id in ressembuttags
+        assert sxtag_id and len(sxtag_id) == 2 and sxtag_id[1] in ressembuttags
 
         self.sxtag_id: (int, int) = sxtag_id
         """Identifiant du SxTag de la forme (semestre_id, fid_semestre_final)"""
@@ -91,6 +91,8 @@ class SxTag(TableTag):
         self.etuds = ressembuttags[self.fid_final].etuds
         self.add_etuds(self.etuds)
 
+        pe_affichage.pe_print(f"--> {self.get_repr()}")
+
         # Les tags
         self.tags_sorted = self.ressembuttag_final.tags_sorted
         """Tags (extraits uniquement du semestre final)"""
@@ -104,7 +106,9 @@ class SxTag(TableTag):
 
         # Les inscriptions des étudiants aux UEs
         # => ne conserve que les UEs du semestre final (pour les redoublants)
-        self.ues_inscr_parcours_df = self.ressembuttag_final.moyennes_tags["but"].ues_inscr_parcours_df
+        self.ues_inscr_parcours_df = self.ressembuttag_final.moyennes_tags[
+            "but"
+        ].ues_inscr_parcours_df
 
         # Les moyennes par tag
         self.moyennes_tags: dict[str, pd.DataFrame] = {}
@@ -135,8 +139,8 @@ class SxTag(TableTag):
     def get_repr(self, verbose=False) -> str:
         """Renvoie une représentation textuelle (celle de la trajectoire sur laquelle elle
         est basée)"""
-        affichage = str(fid) for fid in self.res
+        affichage = [str(fid) for fid in self.ressembuttags]
-        return f"S{sxtag_id[0]}Tag ({'+'.join()})"
+        return f"S{self.sxtag_id[0]}Tag ({'+'.join(affichage)})"
 
     def compute_notes_ues_cube(self, tag, acronymes_ues_sorted):
         """Construit le cube de notes des UEs (etudid x accronyme_ue x semestre_aggregé)
@@ -239,16 +243,3 @@ def compute_notes_ues(
     etud_moy_tag_df.fillna(np.nan)
 
     return etud_moy_tag_df
-
-
-def get_sxtag_from_semestres(
-    formsemestres: dict[int:FormSemestre], sxtags: dict[(str, int):SxTag]
-) -> (str, int):
-    """Partant d'un dictionnaire de SxTags, renvoie l'identifiant (str, fid) du
-    sxtag correspondant aux semestres de formsemestres.
-    (Utilisé pour transformer une trajectoire d'étudiants (par ex. S1+S2+S1+S2+S3)
-    en une suite de sxtags (S1+S2+S3)
-    """
-    for sxtag_id, sxtag in sxtags:
-        if set(formsemestres.keys()) == set(sxtag.semestres_aggreges.keys()):
-            return sxtag_id