forked from ScoDoc/ScoDoc
407 lines
17 KiB
Python
407 lines
17 KiB
Python
##############################################################################
|
|
# ScoDoc
|
|
# Copyright (c) 1999 - 2022 Emmanuel Viennet. All rights reserved.
|
|
# See LICENSE
|
|
##############################################################################
|
|
|
|
"""Résultats semestres BUT
|
|
"""
|
|
import time
|
|
import numpy as np
|
|
import pandas as pd
|
|
|
|
from app import log
|
|
from app.comp import moy_ue, moy_sem, inscr_mod
|
|
from app.comp.res_common import NotesTableCompat
|
|
from app.comp.bonus_spo import BonusSport
|
|
from app.models import ScoDocSiteConfig
|
|
from app.models.etudiants import Identite
|
|
from app.models.moduleimpls import ModuleImpl
|
|
from app.models.ues import UniteEns
|
|
from app.scodoc import sco_groups
|
|
from app.scodoc import sco_preferences
|
|
from app.scodoc import sco_codes_parcours
|
|
from app.scodoc.sco_codes_parcours import UE_SPORT
|
|
import app.scodoc.sco_utils as scu
|
|
|
|
|
|
class ResultatsSemestreBUT(NotesTableCompat):
|
|
"""Résultats BUT: organisation des calculs"""
|
|
|
|
_cached_attrs = NotesTableCompat._cached_attrs + (
|
|
"modimpl_coefs_df",
|
|
"modimpls_evals_poids",
|
|
"sem_cube",
|
|
)
|
|
|
|
def __init__(self, formsemestre):
|
|
super().__init__(formsemestre)
|
|
self.modimpl_coefs_df = None
|
|
"""DataFrame, row UEs(sans bonus), cols modimplid, value coef"""
|
|
self.sem_cube = None
|
|
"""ndarray (etuds x modimpl x ue)"""
|
|
|
|
if not self.load_cached():
|
|
t0 = time.time()
|
|
self.compute()
|
|
t1 = time.time()
|
|
self.store()
|
|
t2 = time.time()
|
|
log(
|
|
f"ResultatsSemestreBUT: cached formsemestre_id={formsemestre.id} ({(t1-t0):g}s +{(t2-t1):g}s)"
|
|
)
|
|
|
|
def compute(self):
|
|
"Charge les notes et inscriptions et calcule les moyennes d'UE et gen."
|
|
(
|
|
self.sem_cube,
|
|
self.modimpls_evals_poids,
|
|
self.modimpls_results,
|
|
) = moy_ue.notes_sem_load_cube(self.formsemestre)
|
|
self.modimpl_inscr_df = inscr_mod.df_load_modimpl_inscr(self.formsemestre)
|
|
self.modimpl_coefs_df, _, _ = moy_ue.df_load_modimpl_coefs(
|
|
self.formsemestre, modimpls=self.formsemestre.modimpls_sorted
|
|
)
|
|
# l'idx de la colonne du mod modimpl.id est
|
|
# modimpl_coefs_df.columns.get_loc(modimpl.id)
|
|
# idx de l'UE: modimpl_coefs_df.index.get_loc(ue.id)
|
|
|
|
# Masque de tous les modules _sauf_ les bonus (sport)
|
|
modimpls_mask = [
|
|
modimpl.module.ue.type != UE_SPORT
|
|
for modimpl in self.formsemestre.modimpls_sorted
|
|
]
|
|
|
|
self.etud_moy_ue = moy_ue.compute_ue_moys_apc(
|
|
self.sem_cube,
|
|
self.etuds,
|
|
self.formsemestre.modimpls_sorted,
|
|
self.ues,
|
|
self.modimpl_inscr_df,
|
|
self.modimpl_coefs_df,
|
|
modimpls_mask,
|
|
)
|
|
# Les coefficients d'UE ne sont pas utilisés en APC
|
|
self.etud_coef_ue_df = pd.DataFrame(
|
|
0.0, index=self.etud_moy_ue.index, columns=self.etud_moy_ue.columns
|
|
)
|
|
|
|
# --- Modules de MALUS sur les UEs
|
|
self.malus = moy_ue.compute_malus(
|
|
self.formsemestre, self.sem_cube, self.ues, self.modimpl_inscr_df
|
|
)
|
|
self.etud_moy_ue -= self.malus
|
|
|
|
# --- Bonus Sport & Culture
|
|
if not all(modimpls_mask): # au moins un module bonus
|
|
bonus_class = ScoDocSiteConfig.get_bonus_sport_class()
|
|
if bonus_class is not None:
|
|
bonus: BonusSport = bonus_class(
|
|
self.formsemestre,
|
|
self.sem_cube,
|
|
self.ues,
|
|
self.modimpl_inscr_df,
|
|
self.modimpl_coefs_df.transpose(),
|
|
self.etud_moy_gen,
|
|
self.etud_moy_ue,
|
|
)
|
|
self.bonus_ues = bonus.get_bonus_ues()
|
|
if self.bonus_ues is not None:
|
|
self.etud_moy_ue += self.bonus_ues # somme les dataframes
|
|
|
|
# Clippe toutes les moyennes d'UE dans [0,20]
|
|
self.etud_moy_ue.clip(lower=0.0, upper=20.0, inplace=True)
|
|
|
|
# Moyenne générale indicative:
|
|
# (note: le bonus sport a déjà été appliqué aux moyennes d'UE, et impacte
|
|
# donc la moyenne indicative)
|
|
# self.etud_moy_gen = moy_sem.compute_sem_moys_apc_using_coefs(
|
|
# self.etud_moy_ue, self.modimpl_coefs_df
|
|
# )
|
|
self.etud_moy_gen = moy_sem.compute_sem_moys_apc_using_ects(
|
|
self.etud_moy_ue,
|
|
[ue.ects for ue in self.ues if ue.type != UE_SPORT],
|
|
formation_id=self.formsemestre.formation_id,
|
|
skip_empty_ues=sco_preferences.get_preference(
|
|
"but_moy_skip_empty_ues", self.formsemestre.id
|
|
),
|
|
)
|
|
# --- UE capitalisées
|
|
self.apply_capitalisation()
|
|
|
|
# --- Classements:
|
|
self.compute_rangs()
|
|
|
|
def get_etud_mod_moy(self, moduleimpl_id: int, etudid: int) -> float:
|
|
"""La moyenne de l'étudiant dans le moduleimpl
|
|
En APC, il s'agit d'une moyenne indicative sans valeur.
|
|
Result: valeur float (peut être naN) ou chaîne "NI" (non inscrit ou DEM)
|
|
"""
|
|
mod_idx = self.modimpl_coefs_df.columns.get_loc(moduleimpl_id)
|
|
etud_idx = self.etud_index[etudid]
|
|
# moyenne sur les UE:
|
|
if len(self.sem_cube[etud_idx, mod_idx]):
|
|
return np.nanmean(self.sem_cube[etud_idx, mod_idx])
|
|
return np.nan
|
|
|
|
def compute_etud_ue_coef(self, etudid: int, ue: UniteEns) -> float:
|
|
"""Détermine le coefficient de l'UE pour cet étudiant.
|
|
N'est utilisé que pour l'injection des UE capitalisées dans la
|
|
moyenne générale.
|
|
En BUT, c'est simple: Coef = somme des coefs des modules vers cette UE.
|
|
(ne dépend pas des modules auxquels est inscrit l'étudiant, ).
|
|
"""
|
|
return self.modimpl_coefs_df.loc[ue.id].sum()
|
|
|
|
def modimpls_in_ue(self, ue_id, etudid, with_bonus=True) -> list[ModuleImpl]:
|
|
"""Liste des modimpl ayant des coefs non nuls vers cette UE
|
|
et auxquels l'étudiant est inscrit. Inclus modules bonus le cas échéant.
|
|
"""
|
|
# sert pour l'affichage ou non de l'UE sur le bulletin et la table recap
|
|
coefs = self.modimpl_coefs_df # row UE, cols modimpl
|
|
modimpls = [
|
|
modimpl
|
|
for modimpl in self.formsemestre.modimpls_sorted
|
|
if (coefs[modimpl.id][ue_id] != 0)
|
|
and self.modimpl_inscr_df[modimpl.id][etudid]
|
|
]
|
|
if not with_bonus:
|
|
return [
|
|
modimpl for modimpl in modimpls if modimpl.module.ue.type != UE_SPORT
|
|
]
|
|
return modimpls
|
|
|
|
def get_table_moyennes_triees(self, convert_values=False) -> list:
|
|
"""Result: tuple avec
|
|
- rows: liste de dicts { column_id : value }
|
|
- titles: { column_id : title }
|
|
- columns_ids: (liste des id de colonnes)
|
|
|
|
. Si convert_values, transforme les notes en chaines ("12.34").
|
|
Les colonnes générées sont:
|
|
etudid
|
|
rang : rang indicatif (basé sur moy gen)
|
|
moy_gen : moy gen indicative
|
|
moy_ue_<ue_id>, ..., les moyennes d'UE
|
|
moy_res_<modimpl_id>_<ue_id>, ... les moyennes de ressources dans l'UE
|
|
moy_sae_<modimpl_id>_<ue_id>, ... les moyennes de SAE dans l'UE
|
|
|
|
On ajoute aussi des attributs:
|
|
- pour les lignes:
|
|
_css_row_class (inutilisé pour le monent)
|
|
_<column_id>_class classe css:
|
|
- la moyenne générale a la classe col_moy_gen
|
|
- les colonnes SAE ont la classe col_sae
|
|
- les colonnes Resources ont la classe col_res
|
|
- les colonnes d'UE ont la classe col_ue
|
|
- les colonnes de modules (SAE ou res.) d'une UE ont la classe mod_ue_<ue_id>
|
|
_<column_id>_order : clé de tri
|
|
"""
|
|
|
|
def fmt_note(x):
|
|
return scu.fmt_note(x) if convert_values else x
|
|
|
|
barre_moy = (
|
|
self.formsemestre.formation.get_parcours().BARRE_MOY - scu.NOTES_TOLERANCE
|
|
)
|
|
barre_valid_ue = self.formsemestre.formation.get_parcours().NOTES_BARRE_VALID_UE
|
|
NO_NOTE = "-" # contenu des cellules sans notes
|
|
rows = []
|
|
titles = {"rang": "Rg"} # column_id : title
|
|
|
|
def add_cell(
|
|
row: dict, col_id: str, title: str, content: str, classes: str = ""
|
|
):
|
|
"Add a row to our table. classes is a list of css class names"
|
|
row[col_id] = content
|
|
if classes:
|
|
row[f"_{col_id}_class"] = classes
|
|
if not col_id in titles:
|
|
titles[col_id] = title
|
|
if classes:
|
|
titles[f"_{col_id}_class"] = classes
|
|
|
|
etuds_inscriptions = self.formsemestre.etuds_inscriptions
|
|
ues = self.formsemestre.query_ues(with_sport=True) # avec bonus
|
|
modimpl_ids = set() # modimpl effectivement présents dans la table
|
|
for etudid in etuds_inscriptions:
|
|
etud = Identite.query.get(etudid)
|
|
row = {"etudid": etudid}
|
|
# --- Rang
|
|
add_cell(row, "rang", "Rg", self.etud_moy_gen_ranks[etudid], "rang")
|
|
row["_rang_order"] = f"{self.etud_moy_gen_ranks_int[etudid]:05d}"
|
|
# --- Identité étudiant
|
|
add_cell(row, "civilite_str", "Civ.", etud.civilite_str, "identite_detail")
|
|
add_cell(row, "nom_disp", "Nom", etud.nom_disp(), "identite_detail")
|
|
add_cell(row, "prenom", "Prénom", etud.prenom, "identite_detail")
|
|
add_cell(row, "nom_short", "Nom", etud.nom_short, "identite_court")
|
|
self._recap_etud_groups_infos(etudid, row, titles)
|
|
# --- Moyenne générale
|
|
moy_gen = self.etud_moy_gen.get(etudid, False)
|
|
note_class = ""
|
|
if moy_gen is False:
|
|
moy_gen = NO_NOTE
|
|
elif isinstance(moy_gen, float) and moy_gen < barre_moy:
|
|
note_class = " moy_inf"
|
|
add_cell(
|
|
row,
|
|
"moy_gen",
|
|
"Moy",
|
|
fmt_note(moy_gen),
|
|
"col_moy_gen" + note_class,
|
|
)
|
|
# --- Moyenne d'UE
|
|
for ue in [ue for ue in ues if ue.type != UE_SPORT]:
|
|
ue_status = self.get_etud_ue_status(etudid, ue.id)
|
|
if ue_status is not None:
|
|
col_id = f"moy_ue_{ue.id}"
|
|
val = ue_status["moy"]
|
|
note_class = ""
|
|
if isinstance(val, float):
|
|
if val < barre_moy:
|
|
note_class = " moy_inf"
|
|
elif val >= barre_valid_ue:
|
|
note_class = " moy_ue_valid"
|
|
add_cell(
|
|
row,
|
|
col_id,
|
|
ue.acronyme,
|
|
fmt_note(val),
|
|
"col_ue" + note_class,
|
|
)
|
|
# Les moyennes des ressources et SAÉs dans cette UE
|
|
for modimpl in self.modimpls_in_ue(ue.id, etudid, with_bonus=False):
|
|
if ue_status["is_capitalized"]:
|
|
val = "-c-"
|
|
else:
|
|
modimpl_results = self.modimpls_results.get(modimpl.id)
|
|
if modimpl_results: # pas bonus
|
|
moys_vers_ue = modimpl_results.etuds_moy_module.get(
|
|
ue.id
|
|
)
|
|
val = (
|
|
moys_vers_ue.get(etudid, "?")
|
|
if moys_vers_ue is not None
|
|
else ""
|
|
)
|
|
else:
|
|
val = ""
|
|
|
|
col_id = (
|
|
f"moy_{modimpl.module.type_abbrv()}_{modimpl.id}_{ue.id}"
|
|
)
|
|
add_cell(
|
|
row,
|
|
col_id,
|
|
modimpl.module.code,
|
|
fmt_note(val),
|
|
# class col_res mod_ue_123
|
|
f"col_{modimpl.module.type_abbrv()} mod_ue_{ue.id}",
|
|
)
|
|
modimpl_ids.add(modimpl.id)
|
|
|
|
rows.append(row)
|
|
|
|
# tri par rang croissant
|
|
rows.sort(key=lambda e: e["_rang_order"])
|
|
|
|
# INFOS POUR FOOTER
|
|
bottom_infos = self._recap_bottom_infos(
|
|
[ue for ue in ues if ue.type != UE_SPORT], modimpl_ids, fmt_note
|
|
)
|
|
|
|
# --- TABLE FOOTER: ECTS, moyennes, min, max...
|
|
footer_rows = []
|
|
for bottom_line in bottom_infos:
|
|
row = bottom_infos[bottom_line]
|
|
# Cases vides à styler:
|
|
row["moy_gen"] = row.get("moy_gen", "")
|
|
row["_moy_gen_class"] = "col_moy_gen"
|
|
# titre de la ligne:
|
|
row["prenom"] = row["nom_short"] = bottom_line.capitalize()
|
|
row["_tr_class"] = bottom_line.lower()
|
|
footer_rows.append(row)
|
|
return (
|
|
rows,
|
|
footer_rows,
|
|
titles,
|
|
[title for title in titles if not title.startswith("_")],
|
|
)
|
|
|
|
def _recap_bottom_infos(self, ues, modimpl_ids: set, fmt_note) -> dict:
|
|
"""Les informations à mettre en bas de la table: min, max, moy, ECTS"""
|
|
bottom_infos = { # { key : row } avec key = min, max, moy, coef
|
|
"min": {},
|
|
"max": {},
|
|
"moy": {},
|
|
"coef": {},
|
|
}
|
|
# --- ECTS
|
|
row = {}
|
|
for ue in ues:
|
|
row[f"moy_ue_{ue.id}"] = ue.ects
|
|
row[f"_moy_ue_{ue.id}_class"] = "col_ue"
|
|
# style cases vides pour borders verticales
|
|
bottom_infos["coef"][f"moy_ue_{ue.id}"] = ""
|
|
bottom_infos["coef"][f"_moy_ue_{ue.id}_class"] = "col_ue"
|
|
row["moy_gen"] = sum([ue.ects or 0 for ue in ues if ue.type != UE_SPORT])
|
|
row["_moy_gen_class"] = "col_moy_gen"
|
|
bottom_infos["ects"] = row
|
|
|
|
# --- MIN, MAX, MOY
|
|
row_min, row_max, row_moy = {}, {}, {}
|
|
row_min["moy_gen"] = fmt_note(self.etud_moy_gen.min())
|
|
row_max["moy_gen"] = fmt_note(self.etud_moy_gen.max())
|
|
row_moy["moy_gen"] = fmt_note(self.etud_moy_gen.mean())
|
|
for ue in [ue for ue in ues if ue.type != UE_SPORT]:
|
|
col_id = f"moy_ue_{ue.id}"
|
|
row_min[col_id] = fmt_note(self.etud_moy_ue[ue.id].min())
|
|
row_max[col_id] = fmt_note(self.etud_moy_ue[ue.id].max())
|
|
row_moy[col_id] = fmt_note(self.etud_moy_ue[ue.id].mean())
|
|
row_min[f"_{col_id}_class"] = "col_ue"
|
|
row_max[f"_{col_id}_class"] = "col_ue"
|
|
row_moy[f"_{col_id}_class"] = "col_ue"
|
|
|
|
for modimpl in self.formsemestre.modimpls_sorted:
|
|
if modimpl.id in modimpl_ids:
|
|
col_id = f"moy_{modimpl.module.type_abbrv()}_{modimpl.id}_{ue.id}"
|
|
bottom_infos["coef"][col_id] = fmt_note(
|
|
self.modimpl_coefs_df[modimpl.id][ue.id]
|
|
)
|
|
i = self.modimpl_coefs_df.columns.get_loc(modimpl.id)
|
|
j = self.modimpl_coefs_df.index.get_loc(ue.id)
|
|
notes = self.sem_cube[:, i, j]
|
|
row_min[col_id] = fmt_note(np.nanmin(notes))
|
|
row_max[col_id] = fmt_note(np.nanmax(notes))
|
|
row_moy[col_id] = fmt_note(np.nanmean(notes))
|
|
|
|
bottom_infos["min"] = row_min
|
|
bottom_infos["max"] = row_max
|
|
bottom_infos["moy"] = row_moy
|
|
return bottom_infos
|
|
|
|
def _recap_etud_groups_infos(self, etudid: int, row: dict, titles: dict):
|
|
"""Ajoute à row les colonnes sur les groupes pour etud"""
|
|
# XXX à remonter dans res_common
|
|
# dec = self.get_etud_decision_sem(etudid)
|
|
# if dec:
|
|
# codes_nb[dec["code"]] += 1
|
|
row_class = ""
|
|
etud_etat = self.get_etud_etat(etudid)
|
|
if etud_etat == sco_codes_parcours.DEM:
|
|
gr_name = "Dém."
|
|
row_class = "dem"
|
|
elif etud_etat == sco_codes_parcours.DEF:
|
|
gr_name = "Déf."
|
|
row_class = "def"
|
|
else:
|
|
# XXX probablement à revoir pour utiliser données cachées,
|
|
# via get_etud_groups_in_partition ou autre
|
|
group = sco_groups.get_etud_main_group(etudid, self.formsemestre.id)
|
|
gr_name = group["group_name"] or ""
|
|
row["group"] = gr_name
|
|
row["_group_class"] = "group"
|
|
if row_class:
|
|
row["_tr_class"] = " ".join([row.get("_tr_class", ""), row_class])
|
|
titles["group"] = "Gr"
|