211 lines
7.9 KiB
Python
211 lines
7.9 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.pe.moys.pe_moy import get_colonne_df
|
|
import re
|
|
|
|
CODE_MOY_UE = "UEs"
|
|
CODE_MOY_COMPETENCES = "Compétences"
|
|
CHAMP_GENERAL = "Général" # Nom du champ de la moyenne générale
|
|
CHAMP_GROUPE = "groupe"
|
|
CHAMP_PROMO = "promo"
|
|
|
|
|
|
class MoyennesTag:
|
|
def __init__(
|
|
self,
|
|
tag: str,
|
|
type_moyenne: str,
|
|
matrice_notes: pd.DataFrame, # etudids x UEs|comp
|
|
matrice_coeffs: pd.DataFrame, # etudids x UEs|comp
|
|
infos: dict,
|
|
):
|
|
"""Classe centralisant un ensemble de moyennes/class/stat,
|
|
obtenu par un groupe d'étudiants, à un tag donné,
|
|
en stockant les moyennes aux UEs|Compétences
|
|
et la moyenne générale (toutes UEs confondues).
|
|
|
|
|
|
|
|
Args:
|
|
tag: Un tag
|
|
matrice_notes: Les moyennes (etudid x acronymes_ues|compétences)
|
|
aux différentes UEs ou compétences
|
|
matrice_coeffs: Les coeffs (etudid x acronymes_ues|compétences)
|
|
aux différentes UEs ou compétences
|
|
infos: Informations (aggrégat, cohorte ayant servi à calculer les moyennes)
|
|
"""
|
|
self.tag = tag
|
|
"""Le tag associé aux moyennes"""
|
|
|
|
self.type = type_moyenne
|
|
"""Le type de moyennes (par UEs ou par compétences)"""
|
|
|
|
self.infos = {
|
|
"aggregat": infos["aggregat"],
|
|
"tag": tag,
|
|
"cohorte": infos["cohorte"],
|
|
}
|
|
"""Info sur les éléments (aggrégat, cohorte) ayant servi à calculer les moyennes"""
|
|
|
|
# Les moyennes par UE/compétences (ressources/SAEs confondues)
|
|
self.matrice_notes: pd.DataFrame = matrice_notes
|
|
"""Les notes par UEs ou Compétences (DataFrame etudids x UEs|comp)"""
|
|
|
|
self.matrice_coeffs: 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.intitules: list[str] = list(self.matrice_notes.columns)
|
|
"""Les intitules (acronymes d'UE ou compétences) renseignés dans les moyennes"""
|
|
assert len(self.intitules) == len(
|
|
set(self.intitules)
|
|
), "Des champs de moyennes en doublons"
|
|
|
|
self.etudids: list[int] = list(self.matrice_notes.index)
|
|
"""Les étudids renseignés dans les moyennes"""
|
|
|
|
self.moyennes_dict: dict[str, pe_moy.Moyenne] = {}
|
|
"""Dictionnaire associant à chaque UE|Compétence ses données moyenne/class/stat"""
|
|
for col in self.intitules: # if ue.type != UE_SPORT:
|
|
# Les moyennes tous modules confondus
|
|
notes = matrice_notes[col]
|
|
infos = self.infos | {"intitule": col}
|
|
self.moyennes_dict[col] = pe_moy.Moyenne(notes, infos)
|
|
|
|
# Les moyennes générales (toutes UEs confondues)
|
|
self.notes_gen = pd.Series(np.nan, index=self.matrice_notes.index)
|
|
"""Notes de la moyenne générale (toutes UEs|Comp confondues)"""
|
|
if self.has_notes():
|
|
self.notes_gen = self.compute_moy_gen(
|
|
self.matrice_notes, self.matrice_coeffs
|
|
)
|
|
infos = self.infos | {"intitule": CHAMP_GENERAL}
|
|
self.moyenne_gen = pe_moy.Moyenne(self.notes_gen, infos)
|
|
"""Dataframe retraçant les moyennes/classements/statistiques général (toutes UESs confondues et modules confondus)"""
|
|
|
|
def has_notes(self):
|
|
"""Détermine si les moyennes (aux UEs ou aux compétences)
|
|
ont des notes
|
|
|
|
Returns:
|
|
True si la moytag a des notes, False sinon
|
|
"""
|
|
for col, moy in self.moyennes_dict.items():
|
|
if not moy.has_notes():
|
|
return False
|
|
return True
|
|
# notes = self.matrice_notes
|
|
|
|
# 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), en pondérant
|
|
les notes obtenues aux UEs|Compétences par les coeff (ici les crédits ECTS).
|
|
|
|
Args:
|
|
moys: Les moyennes (etudids x acronymes_ues/compétences)
|
|
coeff: Les coeff (etudids x acronymes_ues/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,
|
|
)
|
|
return moy_gen_tag
|
|
except TypeError as e:
|
|
raise TypeError(
|
|
"Pb dans le calcul de la moyenne toutes UEs/compétences confondues"
|
|
)
|
|
|
|
def to_df(self, options={"min_max_moy": True}) -> pd.DataFrame:
|
|
"""Renvoie le df synthétisant l'ensemble des données connues.
|
|
|
|
Adapte :
|
|
* les noms des colonnes aux données fournies dans l'attribut
|
|
``infos`` (nom d'aggrégat, type de cohorte).
|
|
* à l'option ``min_max_moy`` (limitant les colonnes)
|
|
"""
|
|
if "min_max_moy" not in options or options["min_max_moy"]:
|
|
with_min_max_moy = True
|
|
else:
|
|
with_min_max_moy = False
|
|
|
|
# Les étudiants triés par etudid
|
|
etudids_sorted = sorted(self.etudids)
|
|
|
|
# Le dataFrame à générer
|
|
df = pd.DataFrame(index=etudids_sorted)
|
|
|
|
# Ajout des notes pour tous les champs
|
|
champs = list(self.intitules)
|
|
for champ in champs:
|
|
moy: pe_moy.Moyenne = self.moyennes_dict[champ]
|
|
df_champ = moy.to_df(
|
|
with_min_max_moy=with_min_max_moy
|
|
) # le dataframe (les colonnes ayant été renommées)
|
|
colonnes_renommees = ajout_numero_a_colonnes(
|
|
list(df.columns), list(df_champ.columns)
|
|
)
|
|
if colonnes_renommees:
|
|
df_champ.columns = colonnes_renommees
|
|
df = df.join(df_champ)
|
|
|
|
# Ajoute la moy générale
|
|
df_moy_gen = self.moyenne_gen.to_df(with_min_max_moy=with_min_max_moy)
|
|
colonnes_renommees = ajout_numero_a_colonnes(
|
|
list(df.columns), list(df_moy_gen.columns)
|
|
)
|
|
if colonnes_renommees:
|
|
df_moy_gen.columns = colonnes_renommees
|
|
df = df.join(df_moy_gen)
|
|
|
|
return df
|
|
|
|
|
|
def ajout_numero_a_colonnes(colonnes, colonnes_a_ajouter):
|
|
"""Partant d'une liste de noms de colonnes, vérifie si les noms des colonnes_a_ajouter
|
|
n'entre pas en conflit (aka ne sont pas déjà présent dans colonnes).
|
|
Si nom, renvoie `None`.
|
|
Si oui, propose une liste de noms de colonnes_a_ajouter dans laquelle chaque nom
|
|
est suivi d'un `"(X)"` (où X est un numéro choisi au regard des noms de colonnes).
|
|
Les noms des colonnes sont de la forme "S1|maths|UE|Groupe|note (1)"
|
|
|
|
Devrait être supprimé à terme, car les noms des colonnes sont théoriquement prévus pour être
|
|
unique/sans doublons.
|
|
"""
|
|
assert len(colonnes) == len(set(colonnes)), "Il y a déjà des doublons dans colonnes"
|
|
colonnes_sans_numero = [col.split(" (")[0] for col in colonnes]
|
|
|
|
conflits = set(colonnes_sans_numero).intersection(colonnes_a_ajouter)
|
|
if not conflits:
|
|
# Pas de conflit
|
|
return None
|
|
|
|
pattern = r"\((\d*)\)"
|
|
p = re.compile(pattern)
|
|
numeros = []
|
|
for col in colonnes:
|
|
numeros.extend(p.findall(col))
|
|
|
|
if numeros:
|
|
numeros = [int(num) for num in numeros]
|
|
num_max = max(numeros)
|
|
else:
|
|
num_max = 0
|
|
|
|
ajouts = [f"{col} ({num_max+1})" for col in colonnes_a_ajouter]
|
|
return ajouts
|