############################################################################## # ScoDoc # Copyright (c) 1999 - 2022 Emmanuel Viennet. All rights reserved. # See LICENSE ############################################################################## """Résultats semestres classiques (non APC) """ import time import numpy as np import pandas as pd from sqlalchemy.sql import text from flask import g, url_for from app import db from app import log from app.comp import moy_mat, moy_mod, moy_sem, moy_ue, inscr_mod from app.comp.res_compat import NotesTableCompat from app.comp.bonus_spo import BonusSport from app.models import ScoDocSiteConfig from app.models.etudiants import Identite from app.models.formsemestre import FormSemestre from app.models.ues import UniteEns from app.scodoc.sco_codes_parcours import UE_SPORT from app.scodoc.sco_exceptions import ScoValueError from app.scodoc import sco_preferences from app.scodoc.sco_utils import ModuleType class ResultatsSemestreClassic(NotesTableCompat): """Résultats du semestre (formation classique): organisation des calculs.""" _cached_attrs = NotesTableCompat._cached_attrs + ( "modimpl_coefs", "modimpl_idx", "sem_matrix", "mod_rangs", ) def __init__(self, formsemestre): super().__init__(formsemestre) self.sem_matrix: np.ndarray = None "sem_matrix : 2d-array (etuds x modimpls)" if not self.load_cached(): t0 = time.time() self.compute() t1 = time.time() self.store() t2 = time.time() log( f"""ResultatsSemestreClassic: cached formsemestre_id={ formsemestre.id} ({(t1-t0):g}s +{(t2-t1):g}s)""" ) # recalculé (aussi rapide que de les cacher) self.moy_min = self.etud_moy_gen.min() self.moy_max = self.etud_moy_gen.max() self.moy_moy = self.etud_moy_gen.mean() def compute(self): "Charge les notes et inscriptions et calcule les moyennes d'UE et gen." self.sem_matrix, self.modimpls_results = notes_sem_load_matrix( self.formsemestre ) self.modimpl_inscr_df = inscr_mod.df_load_modimpl_inscr(self.formsemestre) self.modimpl_coefs = np.array( [m.module.coefficient or 0.0 for m in self.formsemestre.modimpls_sorted] ) self.modimpl_idx = { m.id: i for i, m in enumerate(self.formsemestre.modimpls_sorted) } "l'idx de la colonne du mod modimpl.id est modimpl_idx[modimpl.id]" modimpl_standards_mask = np.array( [ (m.module.module_type == ModuleType.STANDARD) and (m.module.ue.type != UE_SPORT) for m in self.formsemestre.modimpls_sorted ] ) ( self.etud_moy_gen, self.etud_moy_ue, self.etud_coef_ue_df, ) = moy_ue.compute_ue_moys_classic( self.formsemestre, self.sem_matrix, self.ues, self.modimpl_inscr_df, self.modimpl_coefs, modimpl_standards_mask, ) # --- Modules de MALUS sur les UEs et la moyenne générale self.malus = moy_ue.compute_malus( self.formsemestre, self.sem_matrix, self.ues, self.modimpl_inscr_df ) self.etud_moy_ue -= self.malus # ajuste la moyenne générale (à l'aide des coefs d'UE) self.etud_moy_gen -= (self.etud_coef_ue_df * self.malus).sum( axis=1 ) / self.etud_coef_ue_df.sum(axis=1) # --- Bonus Sport & Culture bonus_class = ScoDocSiteConfig.get_bonus_sport_class() if bonus_class is not None: bonus: BonusSport = bonus_class( self.formsemestre, self.sem_matrix, self.ues, self.modimpl_inscr_df, self.modimpl_coefs, 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 self.etud_moy_ue.clip(lower=0.0, upper=20.0, inplace=True) bonus_mg = bonus.get_bonus_moy_gen() if bonus_mg is None and self.bonus_ues is not None: # pas de bonus explicite sur la moyenne générale # on l'ajuste pour refléter les modifs d'UE, à l'aide des coefs d'UE. bonus_mg = (self.etud_coef_ue_df * self.bonus_ues).sum( axis=1 ) / self.etud_coef_ue_df.sum(axis=1) self.etud_moy_gen += bonus_mg elif bonus_mg is not None: # Applique le bonus moyenne générale renvoyé self.etud_moy_gen += bonus_mg # compat nt, utilisé pour l'afficher sur les bulletins: self.bonus = bonus_mg # --- UE capitalisées self.apply_capitalisation() # Clippe toutes les moyennes dans [0,20] self.etud_moy_ue.clip(lower=0.0, upper=20.0, inplace=True) self.etud_moy_gen.clip(lower=0.0, upper=20.0, inplace=True) # --- Classements: self.compute_rangs() # --- En option, moyennes par matières if sco_preferences.get_preference("bul_show_matieres", self.formsemestre.id): self.compute_moyennes_matieres() def compute_rangs(self): """Calcul des rangs (classements) dans le semestre (moy. gen.), les UE et les modules. """ # rangs moy gen et UEs sont calculées par la méthode commune à toutes les formations: super().compute_rangs() # les rangs des modules n'existent que dans les formations classiques: self.mod_rangs = {} for modimpl_result in self.modimpls_results.values(): # ne prend que les rangs sous forme de chaines: rangs = moy_sem.comp_ranks_series(modimpl_result.etuds_moy_module)[0] self.mod_rangs[modimpl_result.moduleimpl_id] = ( rangs, modimpl_result.nb_inscrits_module, ) def get_etud_mod_moy(self, moduleimpl_id: int, etudid: int) -> float: """La moyenne de l'étudiant dans le moduleimpl Result: valeur float (peut être NaN) ou chaîne "NI" (non inscrit ou DEM) """ try: if self.modimpl_inscr_df[moduleimpl_id][etudid]: return self.modimpls_results[moduleimpl_id].etuds_moy_module[etudid] except KeyError: pass return "NI" def get_mod_stats(self, moduleimpl_id: int) -> dict: """Stats sur les notes obtenues dans un modimpl""" notes_series: pd.Series = self.modimpls_results[moduleimpl_id].etuds_moy_module nb_notes = len(notes_series) if not nb_notes: super().get_mod_stats(moduleimpl_id) return { # Series: Statistical methods from ndarray have been overridden to automatically # exclude missing data (currently represented as NaN) "moy": notes_series.mean(), # donc sans prendre en compte les NaN "max": notes_series.max(), "min": notes_series.min(), "nb_notes": nb_notes, "nb_missing": sum(notes_series.isna()), "nb_valid_evals": sum( self.modimpls_results[moduleimpl_id].evaluations_completes ), } def modimpl_notes( self, modimpl_id: int, ue_id: int = None, ) -> np.ndarray: """Les notes moyennes des étudiants du sem. à ce modimpl dans cette ue. Utile pour stats bottom tableau recap. ue_id n'est pas utilisé ici (formations classiques) Résultat: 1d array of float """ i = self.modimpl_idx[modimpl_id] return self.sem_matrix[:, i] def compute_moyennes_matieres(self): """Calcul les moyennes par matière. Doit être appelée au besoin, en fin de compute.""" self.moyennes_matieres = moy_mat.compute_mat_moys_classic( self.formsemestre, self.sem_matrix, self.ues, self.modimpl_inscr_df, self.modimpl_coefs, ) 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. Coef = somme des coefs des modules de l'UE auxquels il est inscrit """ coef = comp_etud_sum_coef_modules_ue(self.formsemestre.id, etudid, ue["ue_id"]) if coef is not None: # inscrit à au moins un module de cette UE return coef # arfff: aucun moyen de déterminer le coefficient de façon sûre log( f"""* oups: calcul coef UE impossible\nformsemestre_id='{self.formsemestre.id }'\netudid='{etudid}'\nue={ue}""" ) etud: Identite = Identite.query.get(etudid) raise ScoValueError( f"""<div class="scovalueerror"><p>Coefficient de l'UE capitalisée {ue.acronyme} impossible à déterminer pour l'étudiant <a href="{ url_for("scolar.ficheEtud", scodoc_dept=g.scodoc_dept, etudid=etudid) }" class="discretelink">{etud.nom_disp()}</a></p> <p>Il faut <a href="{ url_for("notes.formsemestre_edit_uecoefs", scodoc_dept=g.scodoc_dept, formsemestre_id=self.formsemestre.id, err_ue_id=ue["ue_id"], ) }">saisir le coefficient de cette UE avant de continuer</a></p> </div> """ ) def notes_sem_load_matrix(formsemestre: FormSemestre) -> tuple[np.ndarray, dict]: """Calcule la matrice des notes du semestre (charge toutes les notes, calcule les moyennes des modules et assemble la matrice) Resultat: sem_matrix : 2d-array (etuds x modimpls) modimpls_results dict { modimpl.id : ModuleImplResultsClassic } """ modimpls_results = {} modimpls_notes = [] for modimpl in formsemestre.modimpls_sorted: mod_results = moy_mod.ModuleImplResultsClassic(modimpl) etuds_moy_module = mod_results.compute_module_moy() modimpls_results[modimpl.id] = mod_results modimpls_notes.append(etuds_moy_module) return ( notes_sem_assemble_matrix(modimpls_notes), modimpls_results, ) def notes_sem_assemble_matrix(modimpls_notes: list[pd.Series]) -> np.ndarray: """Réuni les notes moyennes des modules du semestre en une matrice modimpls_notes : liste des moyennes de module (Series rendus par compute_module_moy, index: etud) Resultat: ndarray (etud x module) """ if not modimpls_notes: return np.zeros((0, 0), dtype=float) modimpls_notes_arr = [s.values for s in modimpls_notes] modimpls_notes = np.stack(modimpls_notes_arr) # passe de (mod x etud) à (etud x mod) return modimpls_notes.T def comp_etud_sum_coef_modules_ue(formsemestre_id, etudid, ue_id): """Somme des coefficients des modules de l'UE dans lesquels cet étudiant est inscrit ou None s'il n'y a aucun module. """ # comme l'ancien notes_table.comp_etud_sum_coef_modules_ue # mais en raw sqlalchemy et la somme en SQL sql = text( """ SELECT sum(mod.coefficient) FROM notes_modules mod, notes_moduleimpl mi, notes_moduleimpl_inscription ins WHERE mod.id = mi.module_id and ins.etudid = :etudid and ins.moduleimpl_id = mi.id and mi.formsemestre_id = :formsemestre_id and mod.ue_id = :ue_id """ ) cursor = db.session.execute( sql, {"etudid": etudid, "formsemestre_id": formsemestre_id, "ue_id": ue_id} ) r = cursor.fetchone() if r is None: return None return r[0]