231 lines
9.3 KiB
Python
231 lines
9.3 KiB
Python
import numpy as np
|
|
import pandas as pd
|
|
|
|
from app import comp
|
|
from app.comp.moy_sem import comp_ranks_series
|
|
from app.pe.moys import pe_moy
|
|
from app.scodoc.sco_utils import ModuleType
|
|
|
|
CODE_MOY_UE = "UEs"
|
|
CODE_MOY_COMPETENCES = "Compétences"
|
|
CHAMP_GENERAL = "Général" # Nom du champ de la moyenne générale
|
|
|
|
|
|
class MoyennesTag:
|
|
def __init__(
|
|
self,
|
|
tag: str,
|
|
type_moyenne: str,
|
|
matrice_notes_gen: pd.DataFrame, # etudids x colonnes
|
|
matrice_notes_res: pd.DataFrame,
|
|
matrice_notes_saes: pd.DataFrame,
|
|
matrice_coeffs: pd.DataFrame, # etudids x colonnes
|
|
):
|
|
"""Classe centralisant la synthèse des moyennes/classements d'une série
|
|
d'étudiants à un tag donné, en différenciant les notes
|
|
obtenues aux UE et au général (toutes UEs confondues)
|
|
|
|
|
|
Args:
|
|
tag: Un tag
|
|
matrice_notes_gen: Les moyennes (etudid x acronymes_ues ou etudid x compétences)
|
|
aux différentes UEs ou compétences (indépendamment des ressources
|
|
ou SAEs)
|
|
matrice_notes_res: Les moyennes limitées aux ressources
|
|
matrice_notes_saes: Les moyennes limitées aux saes
|
|
matrice_coeffs: Les coeff à appliquer pour le calcul de la moyenne générale
|
|
# notes_gen: Une série de notes (moyenne) sous forme d'un ``pd.Series`` (toutes UEs confondues)
|
|
"""
|
|
self.tag = tag
|
|
"""Le tag associé aux moyennes"""
|
|
|
|
self.type = type_moyenne
|
|
"""Le type de moyennes (par UEs ou par compétences)"""
|
|
|
|
# Les moyennes par UE/compétences (ressources/SAEs confondues)
|
|
self.matrice_notes_gen: pd.DataFrame = matrice_notes_gen
|
|
"""Les notes par UEs ou Compétences (DataFrame)"""
|
|
|
|
# Les moyennes par UE/compétences (limitées aux ressources)
|
|
self.matrice_notes_res: pd.DataFrame = matrice_notes_res
|
|
"""Les notes aux ressources par UEs ou Compétences"""
|
|
|
|
# Les moyennes par UE/compétences (limitées aux SAEs)
|
|
self.matrice_notes_saes: pd.DataFrame = matrice_notes_saes
|
|
"""Les notes aux SAEs par UEs ou Compétences"""
|
|
|
|
self.matrice_coeffs_moy_gen: pd.DataFrame = matrice_coeffs
|
|
"""Les coeffs à appliquer pour le calcul des moyennes générales
|
|
(toutes UE ou compétences confondues). NaN si étudiant non inscrit"""
|
|
|
|
self.moyennes_gen: dict[int, pd.DataFrame] = {}
|
|
"""Dataframes retraçant les moyennes/classements/statistiques des étudiants aux UEs"""
|
|
|
|
self.moyennes_res: dict[int, pd.DataFrame] = {}
|
|
"""Dataframes retraçant les moyennes/classements/statistiques des étudiants, limitées aux ressources"""
|
|
|
|
self.moyennes_saes: dict[int, pd.DataFrame] = {}
|
|
"""Dataframes retraçant les moyennes/classements/statistiques des étudiants, limitées aux SAEs"""
|
|
|
|
self.etudids = self.matrice_notes_gen.index
|
|
"""Les étudids renseignés dans les moyennes"""
|
|
|
|
self.champs = self.matrice_notes_gen.columns
|
|
"""Les champs (acronymes d'UE ou compétences) renseignés dans les moyennes"""
|
|
for col in self.champs: # if ue.type != UE_SPORT:
|
|
# Les moyennes tous modules confondus
|
|
notes = matrice_notes_gen[col]
|
|
self.moyennes_gen[col] = pe_moy.Moyenne(notes)
|
|
# par ressources
|
|
notes = matrice_notes_res[col]
|
|
self.moyennes_res[col] = pe_moy.Moyenne(notes)
|
|
# par SAEs
|
|
notes = matrice_notes_saes[col]
|
|
self.moyennes_saes[col] = pe_moy.Moyenne(notes)
|
|
|
|
# Les moyennes générales (toutes UEs confondues)
|
|
self.notes_gen = pd.Series(np.nan, index=self.matrice_notes_gen.index)
|
|
if self.has_notes(pole=None):
|
|
self.notes_gen = self.compute_moy_gen(
|
|
self.matrice_notes_gen, self.matrice_coeffs_moy_gen
|
|
)
|
|
self.moyenne_gen = pe_moy.Moyenne(self.notes_gen)
|
|
"""Dataframe retraçant les moyennes/classements/statistiques général (toutes UESs confondues et modules confondus)"""
|
|
|
|
self.notes_res = pd.Series(np.nan, index=self.matrice_notes_res.index)
|
|
if self.has_notes(pole=ModuleType.RESSOURCE):
|
|
self.notes_res = self.compute_moy_gen(
|
|
self.matrice_notes_res, self.matrice_coeffs_moy_gen
|
|
)
|
|
self.moyenne_res = pe_moy.Moyenne(self.notes_res)
|
|
"""Dataframe retraçant les moyennes/classements/statistiques général (toutes UESs confondues et uniquement sur les ressources)"""
|
|
|
|
self.notes_saes = pd.Series(np.nan, index=self.matrice_notes_saes.index)
|
|
if self.has_notes(pole=ModuleType.SAE):
|
|
self.notes_saes = self.compute_moy_gen(
|
|
self.matrice_notes_saes, self.matrice_coeffs_moy_gen
|
|
)
|
|
self.moyenne_saes = pe_moy.Moyenne(self.notes_saes)
|
|
"""Dataframe retraçant les moyennes/classements/statistiques général (toutes UESs confondues et uniquement sur les SAEs)"""
|
|
|
|
def has_notes(self, pole):
|
|
"""Détermine si les moyennes (aux UEs ou aux compétences)
|
|
ont des notes
|
|
|
|
`pole` détermine les modules pris en compte :
|
|
|
|
* si `pole` vaut `ModuleType.RESSOURCE`, seules les ressources sont prises
|
|
en compte (moyenne de ressources par UEs)
|
|
* si `pole` vaut `ModuleType.SAE`, seules les SAEs sont prises en compte
|
|
* si `pole` vaut `None` (ou toute autre valeur),
|
|
tous les modules sont pris en compte (moyenne d'UEs)
|
|
|
|
|
|
Returns:
|
|
True si la moytag a des notes, False sinon
|
|
"""
|
|
if pole == ModuleType.RESSOURCE:
|
|
notes = self.matrice_notes_res
|
|
elif pole == ModuleType.SAE:
|
|
notes = self.matrice_notes_saes
|
|
else:
|
|
notes = self.matrice_notes_gen
|
|
nbre_nan = notes.isna().sum().sum()
|
|
nbre_notes_potentielles = len(notes.index) * len(notes.columns)
|
|
if nbre_nan == nbre_notes_potentielles:
|
|
return False
|
|
else:
|
|
return True
|
|
|
|
def compute_moy_gen(self, moys: pd.DataFrame, coeffs: pd.DataFrame) -> pd.Series:
|
|
"""Calcule la moyenne générale (toutes UE/compétences confondus)
|
|
pour le tag considéré, en pondérant les notes obtenues au UE
|
|
par les coeff (généralement les crédits ECTS).
|
|
|
|
Args:
|
|
moys: Les moyennes etudids x acronymes_ues/compétences
|
|
coeff: Les coeff etudids x ueids/compétences
|
|
"""
|
|
|
|
# Calcule la moyenne générale dans le semestre (pondérée par le ECTS)
|
|
try:
|
|
moy_gen_tag = comp.moy_sem.compute_sem_moys_apc_using_ects(
|
|
moys,
|
|
coeffs.fillna(0.0),
|
|
# formation_id=self.formsemestre.formation_id,
|
|
skip_empty_ues=True,
|
|
)
|
|
except TypeError as e:
|
|
raise TypeError(
|
|
"Pb dans le calcul de la moyenne toutes UEs/compétences confondues"
|
|
)
|
|
|
|
return moy_gen_tag
|
|
|
|
def to_df(self, pole, aggregat=None, cohorte=None) -> pd.DataFrame:
|
|
"""Renvoie le df synthétisant l'ensemble des données
|
|
connues
|
|
Adapte les intitulés des colonnes aux données fournies
|
|
(nom d'aggrégat, type de cohorte).
|
|
|
|
`pole` détermine les modules à prendre en compte dans la moyenne (None=tous,
|
|
RESSOURCES ou SAES)
|
|
"""
|
|
|
|
etudids_sorted = sorted(self.etudids)
|
|
|
|
df = pd.DataFrame(index=etudids_sorted)
|
|
|
|
# Ajout des notes pour tous les champs
|
|
champs = list(self.champs)
|
|
for champ in champs:
|
|
if pole == ModuleType.RESSOURCE:
|
|
df_champ = self.moyennes_res[champ].get_df_synthese()
|
|
elif pole == ModuleType.SAE:
|
|
df_champ = self.moyennes_saes[champ].get_df_synthese()
|
|
else:
|
|
df_champ = self.moyennes_gen[champ].get_df_synthese() # le dataframe
|
|
# Renomme les colonnes
|
|
cols = [
|
|
get_colonne_df(aggregat, pole, self.tag, champ, cohorte, critere)
|
|
for critere in pe_moy.Moyenne.COLONNES_SYNTHESE
|
|
]
|
|
df_champ.columns = cols
|
|
df = df.join(df_champ)
|
|
|
|
# Ajoute la moy générale
|
|
df_moy_gen: pd.DataFrame = None
|
|
if pole == ModuleType.RESSOURCE:
|
|
df_moy_gen = self.moyenne_res.get_df_synthese()
|
|
elif pole == ModuleType.SAE:
|
|
df_moy_gen = self.moyenne_saes.get_df_synthese()
|
|
else:
|
|
df_moy_gen = self.moyenne_gen.get_df_synthese()
|
|
cols = [
|
|
get_colonne_df(aggregat, pole, self.tag, CHAMP_GENERAL, cohorte, critere)
|
|
for critere in pe_moy.Moyenne.COLONNES_SYNTHESE
|
|
]
|
|
df_moy_gen.columns = cols
|
|
df = df.join(df_moy_gen)
|
|
|
|
return df
|
|
|
|
|
|
def get_colonne_df(aggregat, pole, tag, champ, cohorte, critere):
|
|
"""Renvoie le tuple (aggregat, tag, champ, cohorte, critere)
|
|
utilisé pour désigner les colonnes du df"""
|
|
liste_champs = []
|
|
if aggregat != None:
|
|
liste_champs += [aggregat]
|
|
if pole == ModuleType.RESSOURCE:
|
|
liste_champs += ["ressources"]
|
|
elif pole == ModuleType.SAE:
|
|
liste_champs += ["saes"]
|
|
else:
|
|
liste_champs += ["global"]
|
|
liste_champs += [tag, champ]
|
|
if cohorte != None:
|
|
liste_champs += [cohorte]
|
|
liste_champs += [critere]
|
|
return "|".join(liste_champs)
|