app/pe/moys/pe_interclasstag.py

@@ -278,48 +278,38 @@ class InterClassTag(pe_tabletags.TableTag):
 
         etudids_sorted = sorted(list(self.diplomes_ids))
 
-        if self.rcstags:
+        if not self.rcstags:
             return None
 
-        # Un rcstag significatif pour initier les colonnes
-        moytag = self._un_rcstag_significatif(self.rcstags)
-        if not moytag:
-            return None
-        df_moytag = moytag.to_df(
-            aggregat=aggregat,
-            cohorte="Groupe",
-        )
-        colonnes = list(df_moytag.columns)
-
         # Partant d'un dataframe vierge
-        df = pd.DataFrame(index=etudids_sorted, columns=colonnes)  # colonnes)
+        initialisation = False
-        for col in colonnes:
+        df = pd.DataFrame()
-            if "rang" in col:
-                df[col] = df[col].astype(str)
-        df.columns = list(range(len(colonnes)))
 
-        for rcstag in self.rcstags.values():
+        for etudid in etudids_sorted:
-            # Charge les moyennes au tag d'un RCStag (SemX ou RCSXTag)
+            # Charge ses moyennes au RCSTag suivi
-            if tag in rcstag.moyennes_tags:
+            rcs = self.suivis[etudid]  # Son Sx ou son RCSemX suivi
-                # Les infos sur les moyennes du tag
+            if rcs:
-                moytag: pe_moytag.MoyennesTag = rcstag.moyennes_tags[tag]
+                rcstag = self.rcstags[rcs.rcs_id]  # Son SxTag ou RCSTag
-                df_moytag = moytag.to_df(
+                # Charge la moyenne
-                    aggregat=aggregat,
+                if tag in rcstag.moyennes_tags:
-                    cohorte="Groupe",
+                    moytag: pd.DataFrame = rcstag.moyennes_tags[tag]
-                )
+                    df_moytag = moytag.to_df(
-                df_moytag.columns = list(range(len(colonnes)))
+                        aggregat=aggregat,
+                        cohorte="Groupe",
+                    )
 
-                # Etudiants/Champs communs entre le df et les données interclassées
+                    # Modif les colonnes au regard du 1er df_moytag significatif lu
-                (
+                    if not initialisation:
-                    etudids_communs,
+                        df = pd.DataFrame(
-                    champs_communs,  # les colonnes de synthèse
+                            np.nan, index=etudids_sorted, columns=df_moytag.columns
-                ) = pe_comp.find_index_and_columns_communs(df, df_moytag)
+                        )
+                        colonnes = list(df_moytag.columns)
+                        for col in colonnes:
+                            if col.endswith("rang"):
+                                df[col] = df[col].astype(str)
+                        initialisation = True
 
-                # Injecte les données par tag
+                    # Injecte les notes de l'étudiant
-                df.loc[etudids_communs, champs_communs] = df_moytag.loc[
+                    df.loc[etudid, :] = df_moytag.loc[etudid, :]
-                    etudids_communs, champs_communs
-                ]
 
-        # Refixe les colonnes
-        df.columns = colonnes
         return df

app/pe/moys/pe_moytag.py

@@ -146,10 +146,10 @@ def get_colonne_df(aggregat, tag, champ, cohorte, critere):
     """Renvoie le tuple (aggregat, tag, champ, cohorte, critere)
     utilisé pour désigner les colonnes du df"""
     liste_champs = []
-    if aggregat:
+    if aggregat != None:
         liste_champs += [aggregat]
     liste_champs += [tag, champ]
-    if cohorte:
+    if cohorte != None:
         liste_champs += [cohorte]
     liste_champs += [critere]
-    return tuple(liste_champs)
+    return "|".join(liste_champs)

app/pe/moys/pe_tabletags.py

@@ -125,8 +125,9 @@ class TableTag(object):
 
         # Ajout des données par tags
         for tag in tags_cibles:
-            moy_tag_df = self.moyennes_tags[tag].to_df(aggregat, cohorte)
+            if tag in self.moyennes_tags:
-            df = df.join(moy_tag_df)
+                moy_tag_df = self.moyennes_tags[tag].to_df(aggregat, cohorte)
+                df = df.join(moy_tag_df)
 
         # Tri par nom, prénom
         if administratif:
@@ -138,7 +139,9 @@ class TableTag(object):
 
         # Conversion des colonnes en multiindex
         if type_colonnes:
-            df.columns = pd.MultiIndex.from_tuples(df.columns)
+            colonnes = list(df.columns)
+            colonnes = [tuple(col.split("|")) for col in colonnes]
+            df.columns = pd.MultiIndex.from_tuples(colonnes)
 
         return df
 
@@ -162,13 +165,13 @@ def _get_champ_administratif(champ, aggregat=None, cohorte=None):
     """Pour un champ donné, renvoie l'index (ou le multindex)
     à intégrer au dataframe"""
     liste = []
-    if aggregat:
+    if aggregat != None:
         liste += [aggregat]
     liste += ["Administratif", "Identité"]
-    if cohorte:
+    if cohorte != None:
         liste += [champ]
     liste += [champ]
-    return tuple(liste)
+    return "|".join(liste)
 
 
 def df_administratif(
@@ -199,6 +202,7 @@ def df_administratif(
         _get_champ_administratif(champ, aggregat, cohorte)
         for champ in CHAMPS_ADMINISTRATIFS
     ]
+
     df = pd.DataFrame.from_dict(donnees, orient="index", columns=colonnes)
     df = df.sort_values(by=colonnes[1:])
     return df

app/pe/pe_jury.py

@@ -422,9 +422,16 @@ class JuryPE(object):
         ) as writer:
             onglets = []
             for onglet, df in synthese.items():
-                onglets += [onglet]
+                if isinstance(onglet, tuple):
+                    if onglet[1] == pe_moytag.CODE_MOY_COMPETENCES:
+                        nom_onglet = onglet[0][: 31 - 5] + "/Comp."
+                    else:
+                        nom_onglet = onglet[0][: 31 - 3] + "/UE"
+                else:
+                    nom_onglet = onglet
+                onglets += [nom_onglet]
                 # écriture dans l'onglet:
-                df.to_excel(writer, onglet, index=True, header=True)
+                df.to_excel(writer, nom_onglet, index=True, header=True)
             pe_affichage.pe_print(f"=> Export excel de {', '.join(onglets)}")
         output.seek(0)
 
@@ -491,7 +498,6 @@ class JuryPE(object):
         tags = self._do_tags_list(self.interclasstags)
         for tag in tags:
             for type_moy in [pe_moytag.CODE_MOY_UE, pe_moytag.CODE_MOY_COMPETENCES]:
-                pe_affichage.pe_print(f"  -> Synthèse du tag {tag} par {type_moy}")
                 synthese[(tag, type_moy)] = self.df_tag_type(tag, type_moy)
         return synthese
 
@@ -520,8 +526,8 @@ class JuryPE(object):
         else:
             aggregats = pe_rcs.TOUS_LES_RCS
 
+        aff_aggregat = []
         for aggregat in aggregats:
-            print(aggregat)
             # Descr de l'aggrégat
             descr = pe_rcs.TYPES_RCS[aggregat]["descr"]
 
@@ -533,7 +539,9 @@ class JuryPE(object):
                 df_groupe = interclass.compute_df_synthese_moyennes_tag(
                     tag, aggregat=aggregat, type_colonnes=False
                 )
-                df = df.join(df_groupe)
+                if not df_groupe.empty:
+                    aff_aggregat += [aggregat]
+                    df = df.join(df_groupe)
 
                 # Le dataframe du classement sur la promo
                 df_promo = interclass.to_df(
@@ -543,11 +551,22 @@ class JuryPE(object):
                     cohorte="Promo",
                     type_colonnes=False,
                 )
-                df = df.join(df_promo)
+                if not df_promo.empty:
+                    aff_aggregat += [aggregat]
+                    df = df.join(df_promo)
 
+        if aff_aggregat:
+            aff_aggregat = sorted(set(aff_aggregat))
+            pe_affichage.pe_print(
+                f"  -> Synthèse de 👜{tag} par {type_moy} avec {', '.join(aff_aggregat)}"
+            )
+        else:
+            pe_affichage.pe_print(f"  -> Synthèse du tag {tag} par {type_moy} : <vide>")
         # Conversion des colonnes en multiindex
         if type_colonnes:
-            df.columns = pd.MultiIndex.from_tuples(df.columns)
+            colonnes = list(df.columns)
+            colonnes = [tuple(col.split("|")) for col in colonnes]
+            df.columns = pd.MultiIndex.from_tuples(colonnes)
         return df
         # Fin de l'aggrégat