204 lines
7.4 KiB
Python
204 lines
7.4 KiB
Python
import numpy as np
|
|
import pandas as pd
|
|
|
|
from app.comp.moy_sem import comp_ranks_series
|
|
from app.pe import pe_affichage
|
|
|
|
|
|
class Moyenne:
|
|
COLONNES = [
|
|
"note",
|
|
"classement",
|
|
"rang",
|
|
"min",
|
|
"max",
|
|
"moy",
|
|
"nb_etuds",
|
|
"nb_inscrits",
|
|
]
|
|
"""Colonnes du df"""
|
|
|
|
@classmethod
|
|
def get_colonnes_synthese(cls, with_min_max_moy):
|
|
"""Renvoie le nom des colonnes à prendre en compte pour la génération
|
|
d'un dataFrame résumant les données d'un objet pe_moy.Moyenne"""
|
|
if with_min_max_moy:
|
|
return ["note", "rang", "min", "max", "moy"]
|
|
else:
|
|
return ["note", "rang"]
|
|
|
|
def __init__(self, notes: pd.Series, infos: dict[str]):
|
|
"""Classe centralisant la synthèse des moyennes/class/stat d'une série
|
|
de notes pour un groupe d'étudiants (déduits des notes).
|
|
|
|
Sont génerés des Séries/DataFrame donnant :
|
|
|
|
* les "notes" : notes (float),
|
|
* des "classements" : classements (float),
|
|
* des "min" : la note minimum sur tout le groupe d'étudiants,
|
|
* des "max" : la note maximum sur tout le groupe d'étudiants,
|
|
* des "moy" : la moyenne des notes sur tout le groupe d'étudiants,
|
|
* des "nb_inscrits" : le nombre d'étudiants ayant une note (non NaN)
|
|
|
|
Args:
|
|
notes: Une (pandas.)Série de notes
|
|
infos: Un dictionnaire donnant les informations sur la moyenne (aggrégat,
|
|
tag, intitule, cohorte, groupe)
|
|
"""
|
|
self.notes = notes
|
|
"""Les notes"""
|
|
self.etudids = list(notes.index) # calcul à venir
|
|
"""Les id des étudiants"""
|
|
self.inscrits_ids = notes[notes.notnull()].index.to_list()
|
|
"""Les id des étudiants dont la note est non nan/renseignée"""
|
|
self.df: pd.DataFrame = self.comp_moy_et_stat(self.notes)
|
|
"""Le dataframe retraçant les moyennes/classements/statistiques"""
|
|
self.infos = {
|
|
"aggregat": infos["aggregat"],
|
|
"tag": infos["tag"],
|
|
"intitule": infos["intitule"],
|
|
"cohorte": infos["cohorte"],
|
|
}
|
|
"""Dictionnaire donnant des informations sur la note (aggrégat, cohorte, tag, type_de_moyenne)"""
|
|
# self.synthese = self.to_dict()
|
|
# """La synthèse (dictionnaire) des notes/classements/statistiques"""
|
|
|
|
def __repr__(self):
|
|
"""Représentation textuelle d'un objet Moyenne
|
|
sur la base de ses `infos`.
|
|
"""
|
|
repr = get_repr(
|
|
self.infos["aggregat"],
|
|
self.infos["tag"],
|
|
self.infos["intitule"],
|
|
self.infos["cohorte"],
|
|
)
|
|
return f"Moyenne {repr}"
|
|
|
|
def comp_moy_et_stat(self, notes: pd.Series) -> dict:
|
|
"""Calcule et structure les données nécessaires au PE pour une série
|
|
de notes (pouvant être une moyenne d'un tag à une UE ou une moyenne générale
|
|
d'un tag) dans un dictionnaire spécifique.
|
|
|
|
Partant des notes, sont calculés les classements (en ne tenant compte
|
|
que des notes non nulles).
|
|
|
|
Args:
|
|
notes: Une série de notes (avec des éventuels NaN)
|
|
|
|
Returns:
|
|
Un dictionnaire stockant les notes, les classements, le min,
|
|
le max, la moyenne, le nb de notes (donc d'inscrits)
|
|
"""
|
|
df = pd.DataFrame(
|
|
np.nan,
|
|
index=self.etudids,
|
|
columns=Moyenne.COLONNES,
|
|
)
|
|
|
|
# Supprime d'éventuelles chaines de caractères dans les notes
|
|
notes = pd.to_numeric(notes, errors="coerce")
|
|
df["note"] = notes
|
|
|
|
# Les nb d'étudiants & nb d'inscrits
|
|
df["nb_etuds"] = len(self.etudids)
|
|
df["nb_etuds"] = df["nb_etuds"].astype(int)
|
|
|
|
# Les étudiants dont la note n'est pas nulle
|
|
inscrits_ids = notes[notes.notnull()].index.to_list()
|
|
df.loc[inscrits_ids, "nb_inscrits"] = len(inscrits_ids)
|
|
# df["nb_inscrits"] = df["nb_inscrits"].astype(int)
|
|
|
|
# Le classement des inscrits
|
|
notes_non_nulles = notes[inscrits_ids]
|
|
(class_str, class_int) = comp_ranks_series(notes_non_nulles)
|
|
df.loc[inscrits_ids, "classement"] = class_int
|
|
# df["classement"] = df["classement"].astype(int)
|
|
|
|
# Le rang (classement/nb_inscrit)
|
|
df["rang"] = df["rang"].astype(str)
|
|
df.loc[inscrits_ids, "rang"] = (
|
|
df.loc[inscrits_ids, "classement"].astype(int).astype(str)
|
|
+ "/"
|
|
+ df.loc[inscrits_ids, "nb_inscrits"].astype(int).astype(str)
|
|
)
|
|
|
|
# Les stat (des inscrits)
|
|
df.loc[inscrits_ids, "min"] = notes.min()
|
|
df.loc[inscrits_ids, "max"] = notes.max()
|
|
df.loc[inscrits_ids, "moy"] = notes.mean()
|
|
|
|
return df
|
|
|
|
def to_df(self, with_min_max_moy=None):
|
|
"""Renvoie le df de synthèse (tel qu'attendu dans les exports Excel),
|
|
en limitant les colonnes à celles attendues (dépendantes de l'option
|
|
``with_min_max_moy``)
|
|
"""
|
|
colonnes_synthese = Moyenne.get_colonnes_synthese(
|
|
with_min_max_moy=with_min_max_moy
|
|
)
|
|
# Copie le df modélisant les données
|
|
df = self.df[colonnes_synthese].copy()
|
|
df["rang"] = df["rang"].replace("nan", "")
|
|
|
|
# Remplace les noms de colonnes par leur intitulé dans le tableur excel
|
|
cols = []
|
|
for critere in colonnes_synthese:
|
|
nom_col = get_colonne_df(
|
|
self.infos["aggregat"],
|
|
self.infos["tag"],
|
|
self.infos["intitule"], # UEs ou compétences
|
|
self.infos["cohorte"],
|
|
critere,
|
|
)
|
|
cols += [nom_col]
|
|
df.columns = cols
|
|
return df
|
|
|
|
def to_json(self) -> dict:
|
|
"""Renvoie un dictionnaire de synthèse des moyennes/classements/statistiques générale (but)"""
|
|
df = self.to_df(with_min_max_moy=True)
|
|
resultat = df.to_json(orient="index")
|
|
return resultat
|
|
|
|
def has_notes(self) -> bool:
|
|
"""Indique si la moyenne est significative (c'est-à-dire à des notes) et/ou des inscrits"""
|
|
return len(self.inscrits_ids) > 0
|
|
|
|
|
|
def get_repr(aggregat, tag, intitule, cohorte):
|
|
"""Renvoie une représentation textuelle "aggregat|tag|intitule|cohorte"
|
|
pour représenter une moyenne
|
|
"""
|
|
liste_champs = []
|
|
if aggregat != None:
|
|
liste_champs += [aggregat]
|
|
liste_champs += [tag, intitule]
|
|
if cohorte != None:
|
|
liste_champs += [cohorte]
|
|
return "|".join(liste_champs)
|
|
|
|
|
|
def get_colonne_df(aggregat, tag, intitule, cohorte, critere):
|
|
"""Renvoie la chaine de caractère "aggregat|tag|intitule|cohorte|critere"
|
|
utilisé pour désigner les colonnes du df.
|
|
|
|
Args:
|
|
aggregat: Un nom d'aggrégat (généralement "S1" ou "3S")
|
|
pouvant être optionnel (si `None`)
|
|
tag: Un nom de tags (par ex. "maths")
|
|
intitule: Un nom d'UE ou de compétences ou "Général"
|
|
cohorte: Une cohorte pour les interclassements (généralement
|
|
Groupe ou Promo
|
|
pouvant être optionnel (si `None`)
|
|
critere: Un critère correspondant à l'une des colonnes
|
|
d'une pe_moy.Moyenne
|
|
Returns:
|
|
Une chaine de caractères indiquant les champs séparés par
|
|
un ``"|"``, généralement de la forme
|
|
"S1|maths|UE|Groupe|note"
|
|
"""
|
|
liste_champs = [get_repr(aggregat, tag, intitule, cohorte), critere]
|
|
return "|".join(liste_champs)
|