From eff28d64f90509f1b30c1e8b56fea3b3cab56f9c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9o=20BARAS=20=28IUT1=20Grenoble=29?= Date: Sat, 24 Feb 2024 09:31:47 +0100 Subject: [PATCH] Divers --- app/pe/moys/pe_interclasstag.py | 64 ++++++++++++++------------------- app/pe/moys/pe_moytag.py | 6 ++-- app/pe/moys/pe_tabletags.py | 16 +++++---- app/pe/pe_jury.py | 33 +++++++++++++---- 4 files changed, 66 insertions(+), 53 deletions(-) diff --git a/app/pe/moys/pe_interclasstag.py b/app/pe/moys/pe_interclasstag.py index 92114f41d..c7125607e 100644 --- a/app/pe/moys/pe_interclasstag.py +++ b/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) - for col in colonnes: - if "rang" in col: - df[col] = df[col].astype(str) - df.columns = list(range(len(colonnes))) + initialisation = False + df = pd.DataFrame() - for rcstag in self.rcstags.values(): - # Charge les moyennes au tag d'un RCStag (SemX ou RCSXTag) - if tag in rcstag.moyennes_tags: - # Les infos sur les moyennes du tag - moytag: pe_moytag.MoyennesTag = rcstag.moyennes_tags[tag] - df_moytag = moytag.to_df( - aggregat=aggregat, - cohorte="Groupe", - ) - df_moytag.columns = list(range(len(colonnes))) + for etudid in etudids_sorted: + # Charge ses moyennes au RCSTag suivi + rcs = self.suivis[etudid] # Son Sx ou son RCSemX suivi + if rcs: + rcstag = self.rcstags[rcs.rcs_id] # Son SxTag ou RCSTag + # Charge la moyenne + if tag in rcstag.moyennes_tags: + moytag: pd.DataFrame = rcstag.moyennes_tags[tag] + df_moytag = moytag.to_df( + aggregat=aggregat, + cohorte="Groupe", + ) - # Etudiants/Champs communs entre le df et les données interclassées - ( - etudids_communs, - champs_communs, # les colonnes de synthèse - ) = pe_comp.find_index_and_columns_communs(df, df_moytag) + # Modif les colonnes au regard du 1er df_moytag significatif lu + if not initialisation: + df = pd.DataFrame( + np.nan, index=etudids_sorted, columns=df_moytag.columns + ) + 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 - df.loc[etudids_communs, champs_communs] = df_moytag.loc[ - etudids_communs, champs_communs - ] + # Injecte les notes de l'étudiant + df.loc[etudid, :] = df_moytag.loc[etudid, :] - # Refixe les colonnes - df.columns = colonnes return df diff --git a/app/pe/moys/pe_moytag.py b/app/pe/moys/pe_moytag.py index 2870be551..3b7374f2f 100644 --- a/app/pe/moys/pe_moytag.py +++ b/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) diff --git a/app/pe/moys/pe_tabletags.py b/app/pe/moys/pe_tabletags.py index 67564736d..8a093a6b3 100644 --- a/app/pe/moys/pe_tabletags.py +++ b/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) - df = df.join(moy_tag_df) + if tag in self.moyennes_tags: + 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 diff --git a/app/pe/pe_jury.py b/app/pe/pe_jury.py index aa87cc8e5..81382ffac 100644 --- a/app/pe/pe_jury.py +++ b/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} : ") # 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