############################################################################## # ScoDoc # Copyright (c) 1999 - 2022 Emmanuel Viennet. All rights reserved. # See LICENSE ############################################################################## """Résultats semestre: méthodes communes aux formations classiques et APC """ from collections import Counter from functools import cached_property import numpy as np import pandas as pd from flask import g, url_for from app.auth.models import User from app.comp.res_cache import ResultatsCache from app.comp import res_sem from app.comp.moy_mod import ModuleImplResults from app.models import FormSemestre, FormSemestreUECoef, formsemestre from app.models import Identite from app.models import ModuleImpl, ModuleImplInscription from app.models.ues import UniteEns from app.scodoc.sco_cache import ResultatsSemestreCache from app.scodoc.sco_codes_parcours import UE_SPORT, DEF, DEM from app.scodoc import sco_evaluation_db from app.scodoc.sco_exceptions import ScoValueError from app.scodoc import sco_groups from app.scodoc import sco_utils as scu # Il faut bien distinguer # - ce qui est caché de façon persistente (via redis): # ce sont les attributs listés dans `_cached_attrs` # le stockage et l'invalidation sont gérés dans sco_cache.py # # - les valeurs cachées durant le temps d'une requête # (durée de vie de l'instance de ResultatsSemestre) # qui sont notamment les attributs décorés par `@cached_property`` # class ResultatsSemestre(ResultatsCache): """Les résultats (notes, ...) d'un formsemestre Classe commune à toutes les formations (classiques, BUT) """ _cached_attrs = ( "bonus", "bonus_ues", "etud_moy_gen_ranks", "etud_moy_gen", "etud_moy_ue", "modimpl_inscr_df", "modimpls_results", "etud_coef_ue_df", "moyennes_matieres", ) def __init__(self, formsemestre: FormSemestre): super().__init__(formsemestre, ResultatsSemestreCache) # BUT ou standard ? (apc == "approche par compétences") self.is_apc = formsemestre.formation.is_apc() # Attributs "virtuels", définis dans les sous-classes self.bonus: pd.Series = None # virtuel "Bonus sur moy. gen. Series de float, index etudid" self.bonus_ues: pd.DataFrame = None # virtuel "DataFrame de float, index etudid, columns: ue.id" # ResultatsSemestreBUT ou ResultatsSemestreClassic self.etud_moy_ue = {} "etud_moy_ue: DataFrame columns UE, rows etudid" self.etud_moy_gen: pd.Series = None self.etud_moy_gen_ranks = {} self.etud_moy_gen_ranks_int = {} self.modimpl_inscr_df: pd.DataFrame = None "Inscriptions: row etudid, col modimlpl_id" self.modimpls_results: ModuleImplResults = None "Résultats de chaque modimpl: dict { modimpl.id : ModuleImplResults(Classique ou BUT) }" self.etud_coef_ue_df = None """coefs d'UE effectifs pour chaque étudiant (pour form. classiques)""" self.modimpl_coefs_df: pd.DataFrame = None """Coefs APC: rows = UEs (sans bonus), columns = modimpl, value = coef.""" self.validations = None self.moyennes_matieres = {} """Moyennes de matières, si calculées. { matiere_id : Series, index etudid }""" def __repr__(self): return f"<{self.__class__.__name__}(formsemestre='{self.formsemestre}')>" def compute(self): "Charge les notes et inscriptions et calcule toutes les moyennes" # voir ce qui est chargé / calculé ici et dans les sous-classes raise NotImplementedError() def get_inscriptions_counts(self) -> Counter: """Nombre d'inscrits, défaillants, démissionnaires. Exemple: res.get_inscriptions_counts()[scu.INSCRIT] Result: a collections.Counter instance """ return Counter(ins.etat for ins in self.formsemestre.inscriptions) @cached_property def etuds(self) -> list[Identite]: "Liste des inscrits au semestre, avec les démissionnaires et les défaillants" # nb: si la liste des inscrits change, ResultatsSemestre devient invalide return self.formsemestre.get_inscrits(include_demdef=True) @cached_property def etud_index(self) -> dict[int, int]: "dict { etudid : indice dans les inscrits }" return {e.id: idx for idx, e in enumerate(self.etuds)} def modimpl_notes(self, modimpl_id: int, ue_id: int) -> np.ndarray: """Les notes moyennes des étudiants du sem. à ce modimpl dans cette ue. Utile pour stats bottom tableau recap. Résultat: 1d array of float """ # différent en BUT et classique: virtuelle raise NotImplementedError @cached_property def etuds_dict(self) -> dict[int, Identite]: """dict { etudid : Identite } inscrits au semestre, avec les démissionnaires et defs.""" return {etud.id: etud for etud in self.etuds} @cached_property def ues(self) -> list[UniteEns]: """Liste des UEs du semestre (avec les UE bonus sport) (indices des DataFrames). Note: un étudiant n'est pas nécessairement inscrit dans toutes ces UEs. """ return self.formsemestre.query_ues(with_sport=True).all() @cached_property def ressources(self): "Liste des ressources du semestre, triées par numéro de module" return [ m for m in self.formsemestre.modimpls_sorted if m.module.module_type == scu.ModuleType.RESSOURCE ] @cached_property def saes(self): "Liste des SAÉs du semestre, triées par numéro de module" return [ m for m in self.formsemestre.modimpls_sorted if m.module.module_type == scu.ModuleType.SAE ] def get_etud_ue_validables(self, etudid: int) -> list[UniteEns]: """Liste des UEs du semestre qui doivent être validées Rappel: l'étudiant est inscrit à des modimpls et non à des UEs. - En BUT: on considère que l'étudiant va (ou non) valider toutes les UEs des modules du parcours. XXX notion à implémenter, pour l'instant toutes les UE du semestre. - En classique: toutes les UEs des modimpls auxquels l'étudiant est inscrit sont susceptibles d'être validées. Les UE "bonus" (sport) ne sont jamais "validables". """ if self.is_apc: # TODO: introduire la notion de parcours (#sco93) return self.formsemestre.query_ues().filter(UniteEns.type != UE_SPORT).all() else: # restreint aux UE auxquelles l'étudiant est inscrit (dans l'un des modimpls) ues = { modimpl.module.ue for modimpl in self.formsemestre.modimpls_sorted if self.modimpl_inscr_df[modimpl.id][etudid] } ues = sorted(list(ues), key=lambda x: x.numero or 0) return ues def modimpls_in_ue(self, ue_id, etudid, with_bonus=True) -> list[ModuleImpl]: """Liste des modimpl de cette UE auxquels l'étudiant est inscrit. Utile en formations classiques, surchargée pour le BUT. Inclus modules bonus le cas échéant. """ # sert pour l'affichage ou non de l'UE sur le bulletin # Méthode surchargée en BUT modimpls = [ modimpl for modimpl in self.formsemestre.modimpls_sorted if modimpl.module.ue.id == ue_id 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 @cached_property def ue_au_dessus(self, seuil=10.0) -> pd.DataFrame: """DataFrame columns UE, rows etudid, valeurs: bool Par exemple, pour avoir le nombre d'UE au dessus de 10 pour l'étudiant etudid nb_ues_ok = sum(res.ue_au_dessus().loc[etudid]) """ return self.etud_moy_ue > (seuil - scu.NOTES_TOLERANCE) def apply_capitalisation(self): """Recalcule la moyenne générale pour prendre en compte d'éventuelles UE capitalisées. """ # Supposant qu'il y a peu d'UE capitalisées, # on va soustraire la moyenne d'UE et ajouter celle de l'UE capitalisée. if not self.validations: self.validations = res_sem.load_formsemestre_validations(self.formsemestre) ue_capitalisees = self.validations.ue_capitalisees for etudid in ue_capitalisees.index: recompute_mg = False # ue_codes = set(ue_capitalisees.loc[etudid]["ue_code"]) # for ue_code in ue_codes: # ue = ue_by_code.get(ue_code) # if ue is None: # ue = self.formsemestre.query_ues.filter_by(ue_code=ue_code) # ue_by_code[ue_code] = ue # Quand il y a une capitalisation, vérifie toutes les UEs sum_notes_ue = 0.0 sum_coefs_ue = 0.0 for ue in self.formsemestre.query_ues(): ue_cap = self.get_etud_ue_status(etudid, ue.id) if ue_cap is None: continue if ue_cap["is_capitalized"]: recompute_mg = True coef = ue_cap["coef_ue"] if not np.isnan(ue_cap["moy"]) and coef: sum_notes_ue += ue_cap["moy"] * coef sum_coefs_ue += coef if recompute_mg and sum_coefs_ue > 0.0: # On doit prendre en compte une ou plusieurs UE capitalisées # et donc recalculer la moyenne générale self.etud_moy_gen[etudid] = sum_notes_ue / sum_coefs_ue # Ajoute le bonus sport if self.bonus is not None and self.bonus[etudid]: self.etud_moy_gen[etudid] += self.bonus[etudid] self.etud_moy_gen[etudid] = max( 0.0, min(self.etud_moy_gen[etudid], 20.0) ) def get_etud_etat(self, etudid: int) -> str: "Etat de l'etudiant: 'I', 'D', DEF ou '' (si pas connu dans ce semestre)" ins = self.formsemestre.etuds_inscriptions.get(etudid, None) if ins is None: return "" return ins.etat def _get_etud_ue_cap(self, etudid: int, ue: UniteEns) -> dict: """Donne les informations sur la capitalisation de l'UE ue pour cet étudiant. Résultat: Si pas capitalisée: None Si capitalisée: un dict, avec les colonnes de validation. """ capitalisations = self.validations.ue_capitalisees.loc[etudid] if isinstance(capitalisations, pd.DataFrame): ue_cap = capitalisations[capitalisations["ue_code"] == ue.ue_code] if ue_cap.empty: return None if isinstance(ue_cap, pd.DataFrame): # si plusieurs fois capitalisée, prend le max cap_idx = ue_cap["moy_ue"].values.argmax() ue_cap = ue_cap.iloc[cap_idx] else: if capitalisations["ue_code"] == ue.ue_code: ue_cap = capitalisations else: return None # converti la Series en dict, afin que les np.int64 reviennent en int return ue_cap.to_dict() def get_etud_ue_status(self, etudid: int, ue_id: int) -> dict: """L'état de l'UE pour cet étudiant. Result: dict, ou None si l'UE n'est pas dans ce semestre. """ ue = UniteEns.query.get(ue_id) # TODO cacher nos UEs ? if ue.type == UE_SPORT: return { "is_capitalized": False, "was_capitalized": False, "is_external": False, "coef_ue": 0.0, "cur_moy_ue": 0.0, "moy": 0.0, "event_date": None, "ue": ue.to_dict(), "formsemestre_id": None, "capitalized_ue_id": None, "ects_pot": 0.0, } if not ue_id in self.etud_moy_ue: return None if not self.validations: self.validations = res_sem.load_formsemestre_validations(self.formsemestre) cur_moy_ue = self.etud_moy_ue[ue_id][etudid] moy_ue = cur_moy_ue is_capitalized = False # si l'UE prise en compte est une UE capitalisée # s'il y a precedemment une UE capitalisée (pas forcement meilleure): was_capitalized = False if etudid in self.validations.ue_capitalisees.index: ue_cap = self._get_etud_ue_cap(etudid, ue) if ue_cap and not np.isnan(ue_cap["moy_ue"]): was_capitalized = True if ue_cap["moy_ue"] > cur_moy_ue or np.isnan(cur_moy_ue): moy_ue = ue_cap["moy_ue"] is_capitalized = True # Coef l'UE dans le semestre courant: if self.is_apc: # utilise les ECTS comme coef. coef_ue = ue.ects else: # formations classiques coef_ue = self.etud_coef_ue_df[ue_id][etudid] if (not coef_ue) and is_capitalized: # étudiant non inscrit dans l'UE courante if self.is_apc: # Coefs de l'UE capitalisée en formation APC: donné par ses ECTS ue_capitalized = UniteEns.query.get(ue_cap["ue_id"]) coef_ue = ue_capitalized.ects if coef_ue is None: orig_sem = FormSemestre.query.get(ue_cap["formsemestre_id"]) raise ScoValueError( f"""L'UE capitalisée {ue_capitalized.acronyme} du semestre {orig_sem.titre_annee()} n'a pas d'indication d'ECTS. Corrigez ou faite corriger le programme <a href="{url_for('notes.ue_table', scodoc_dept=g.scodoc_dept, formation_id=ue_capitalized.formation_id)}">via cette page</a>. """ ) else: # Coefs de l'UE capitalisée en formation classique: # va chercher le coef dans le semestre d'origine coef_ue = ModuleImplInscription.sum_coefs_modimpl_ue( ue_cap["formsemestre_id"], etudid, ue_cap["ue_id"] ) return { "is_capitalized": is_capitalized, "was_capitalized": was_capitalized, "is_external": ue_cap["is_external"] if is_capitalized else ue.is_external, "coef_ue": coef_ue, "ects_pot": ue.ects or 0.0, "cur_moy_ue": cur_moy_ue, "moy": moy_ue, "event_date": ue_cap["event_date"] if is_capitalized else None, "ue": ue.to_dict(), "formsemestre_id": ue_cap["formsemestre_id"] if is_capitalized else None, "capitalized_ue_id": ue_cap["ue_id"] if is_capitalized else None, } def compute_etud_ue_coef(self, etudid: int, ue: UniteEns) -> float: "Détermine le coefficient de l'UE pour cet étudiant." # calcul différent en classqiue et BUT raise NotImplementedError() def get_etud_ue_cap_coef(self, etudid, ue, ue_cap): """Calcule le coefficient d'une UE capitalisée, pour cet étudiant, injectée dans le semestre courant. ue : ue du semestre courant ue_cap = resultat de formsemestre_get_etud_capitalisation { 'ue_id' (dans le semestre source), 'ue_code', 'moy', 'event_date','formsemestre_id' } """ # 1- Coefficient explicitement déclaré dans le semestre courant pour cette UE ? ue_coef_db = FormSemestreUECoef.query.filter_by( formsemestre_id=self.formsemestre.id, ue_id=ue.id ).first() if ue_coef_db is not None: return ue_coef_db.coefficient # En APC: somme des coefs des modules vers cette UE # En classique: Capitalisation UE externe: quel coef appliquer ? # En ScoDoc 7, calculait la somme des coefs dans l'UE du semestre d'origine # ici si l'étudiant est inscrit dans le semestre courant, # somme des coefs des modules de l'UE auxquels il est inscrit return self.compute_etud_ue_coef(etudid, ue) # --- TABLEAU RECAP def get_table_recap( self, convert_values=False, include_evaluations=False, modejury=False ): """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 """ if convert_values: fmt_note = scu.fmt_note else: fmt_note = lambda x: x parcours = self.formsemestre.formation.get_parcours() barre_moy = parcours.BARRE_MOY - scu.NOTES_TOLERANCE barre_valid_ue = parcours.NOTES_BARRE_VALID_UE barre_warning_ue = parcours.BARRE_UE_DISPLAY_WARNING NO_NOTE = "-" # contenu des cellules sans notes rows = [] # column_id : title titles = {} # les titres en footer: les mêmes, mais avec des bulles et liens: titles_bot = {} dict_nom_res = {} # cache uid : nomcomplet def add_cell( row: dict, col_id: str, title: str, content: str, classes: str = "", idx: int = 100, ): "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 + f" c{idx}" if not col_id in titles: titles[col_id] = title titles[f"_{col_id}_col_order"] = idx if classes: titles[f"_{col_id}_class"] = classes return idx + 1 etuds_inscriptions = self.formsemestre.etuds_inscriptions ues = self.formsemestre.query_ues(with_sport=True) # avec bonus ues_sans_bonus = [ue for ue in ues if ue.type != UE_SPORT] modimpl_ids = set() # modimpl effectivement présents dans la table for etudid in etuds_inscriptions: idx = 0 # index de la colonne etud = Identite.query.get(etudid) row = {"etudid": etudid} # --- Codes (seront cachés, mais exportés en excel) idx = add_cell(row, "etudid", "etudid", etudid, "codes", idx) idx = add_cell( row, "code_nip", "code_nip", etud.code_nip or "", "codes", idx ) # --- Rang idx = add_cell( row, "rang", "Rg", self.etud_moy_gen_ranks[etudid], "rang", idx ) row["_rang_order"] = f"{self.etud_moy_gen_ranks_int[etudid]:05d}" # --- Identité étudiant idx = add_cell( row, "civilite_str", "Civ.", etud.civilite_str, "identite_detail", idx ) idx = add_cell( row, "nom_disp", "Nom", etud.nom_disp(), "identite_detail", idx ) row["_nom_disp_order"] = etud.sort_key idx = add_cell(row, "prenom", "Prénom", etud.prenom, "identite_detail", idx) idx = add_cell( row, "nom_short", "Nom", etud.nom_short, "identite_court", idx ) row["_nom_short_order"] = etud.sort_key row["_nom_short_target"] = url_for( "notes.formsemestre_bulletinetud", scodoc_dept=g.scodoc_dept, formsemestre_id=self.formsemestre.id, etudid=etudid, ) row["_nom_short_target_attrs"] = f'class="etudinfo" id="{etudid}"' row["_nom_disp_target"] = row["_nom_short_target"] row["_nom_disp_target_attrs"] = row["_nom_short_target_attrs"] idx = 30 # début des colonnes de notes # --- 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_ue_warning" # en rouge idx = add_cell( row, "moy_gen", "Moy", fmt_note(moy_gen), "col_moy_gen" + note_class, idx, ) titles_bot["_moy_gen_target_attrs"] = ( 'title="moyenne indicative"' if self.is_apc else "" ) # --- Moyenne d'UE nb_ues_validables, nb_ues_warning = 0, 0 for ue in ues_sans_bonus: 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" nb_ues_validables += 1 if val < barre_warning_ue: note_class = " moy_ue_warning" # notes très basses nb_ues_warning += 1 idx = add_cell( row, col_id, ue.acronyme, fmt_note(val), "col_ue" + note_class, idx, ) titles_bot[ f"_{col_id}_target_attrs" ] = f"""title="{ue.titre} S{ue.semestre_idx or '?'}" """ if modejury: # pas d'autre colonnes de résultats continue # Bonus (sport) dans cette UE ? # Le bonus sport appliqué sur cette UE if (self.bonus_ues is not None) and (ue.id in self.bonus_ues): val = self.bonus_ues[ue.id][etud.id] or "" val_fmt = val_fmt_html = fmt_note(val) if val: val_fmt_html = f'<span class="green-arrow-up"></span><span class="sp2l">{val_fmt}</span>' idx = add_cell( row, f"bonus_ue_{ue.id}", f"Bonus {ue.acronyme}", val_fmt_html, "col_ue_bonus", idx, ) row[f"_bonus_ue_{ue.id}_xls"] = val_fmt # Les moyennes des modules (ou ressources et SAÉs) dans cette UE idx_malus = idx # place pour colonne malus à gauche des modules idx += 1 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 if self.is_apc: # BUT 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: # classique: Series indépendante de l'UE val = modimpl_results.etuds_moy_module.get( etudid, "?" ) else: val = "" col_id = ( f"moy_{modimpl.module.type_abbrv()}_{modimpl.id}_{ue.id}" ) val_fmt = val_fmt_html = fmt_note(val) if modimpl.module.module_type == scu.ModuleType.MALUS: val_fmt_html = ( (scu.EMO_RED_TRIANGLE_DOWN + val_fmt) if val else "" ) idx = add_cell( row, col_id, modimpl.module.code, val_fmt_html, # class col_res mod_ue_123 f"col_{modimpl.module.type_abbrv()} mod_ue_{ue.id}", idx, ) row[f"_{col_id}_xls"] = val_fmt if modimpl.module.module_type == scu.ModuleType.MALUS: titles[f"_{col_id}_col_order"] = idx_malus titles_bot[f"_{col_id}_target"] = url_for( "notes.moduleimpl_status", scodoc_dept=g.scodoc_dept, moduleimpl_id=modimpl.id, ) nom_resp = dict_nom_res.get(modimpl.responsable_id) if nom_resp is None: user = User.query.get(modimpl.responsable_id) nom_resp = user.get_nomcomplet() if user else "" dict_nom_res[modimpl.responsable_id] = nom_resp titles_bot[ f"_{col_id}_target_attrs" ] = f""" title="{modimpl.module.titre} ({nom_resp})" """ modimpl_ids.add(modimpl.id) ue_valid_txt = ( ue_valid_txt_html ) = f"{nb_ues_validables}/{len(ues_sans_bonus)}" if nb_ues_warning: ue_valid_txt_html += " " + scu.EMO_WARNING add_cell( row, "ues_validables", "UEs", ue_valid_txt_html, "col_ue col_ues_validables", 29, # juste avant moy. gen. ) row["_ues_validables_xls"] = ue_valid_txt if nb_ues_warning: row["_ues_validables_class"] += " moy_ue_warning" elif nb_ues_validables < len(ues_sans_bonus): row["_ues_validables_class"] += " moy_inf" row["_ues_validables_order"] = nb_ues_validables # pour tri if modejury: idx = add_cell( row, "jury_link", "", f"""<a href="{url_for('notes.formsemestre_validation_etud_form', scodoc_dept=g.scodoc_dept, formsemestre_id=self.formsemestre.id, etudid=etudid ) }">saisir décision</a>""", "col_jury_link", 1000, ) rows.append(row) self._recap_add_partitions(rows, titles) self._recap_add_admissions(rows, titles) # tri par rang croissant rows.sort(key=lambda e: e["_rang_order"]) # INFOS POUR FOOTER bottom_infos = self._recap_bottom_infos(ues_sans_bonus, modimpl_ids, fmt_note) if include_evaluations: self._recap_add_evaluations(rows, titles, bottom_infos) # Ajoute style "col_empty" aux colonnes de modules vides for col_id in titles: c_class = f"_{col_id}_class" if "col_empty" in bottom_infos["moy"].get(c_class, ""): for row in rows: row[c_class] = row.get(c_class, "") + " col_empty" titles[c_class] += " col_empty" for row in bottom_infos.values(): row[c_class] = row.get(c_class, "") + " col_empty" # --- TABLE FOOTER: ECTS, moyennes, min, max... footer_rows = [] for (bottom_line, row) in bottom_infos.items(): # 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"] = ( row.get("_title", "") or bottom_line.capitalize() ) row["_tr_class"] = bottom_line.lower() + ( (" " + row["_tr_class"]) if "_tr_class" in row else "" ) footer_rows.append(row) titles_bot.update(titles) footer_rows.append(titles_bot) column_ids = [title for title in titles if not title.startswith("_")] column_ids.sort( key=lambda col_id: titles.get("_" + col_id + "_col_order", 1000) ) return (rows, footer_rows, titles, column_ids) def _recap_bottom_infos(self, ues, modimpl_ids: set, fmt_note) -> dict: """Les informations à mettre en bas de la table: min, max, moy, ECTS""" row_min, row_max, row_moy, row_coef, row_ects, row_apo = ( {"_tr_class": "bottom_info", "_title": "Min."}, {"_tr_class": "bottom_info"}, {"_tr_class": "bottom_info"}, {"_tr_class": "bottom_info"}, {"_tr_class": "bottom_info"}, {"_tr_class": "bottom_info", "_title": "Code Apogée"}, ) # --- ECTS for ue in ues: colid = f"moy_ue_{ue.id}" row_ects[colid] = ue.ects row_ects[f"_{colid}_class"] = "col_ue" # style cases vides pour borders verticales row_coef[colid] = "" row_coef[f"_{colid}_class"] = "col_ue" # row_apo[colid] = ue.code_apogee or "" row_ects["moy_gen"] = sum([ue.ects or 0 for ue in ues if ue.type != UE_SPORT]) row_ects["_moy_gen_class"] = "col_moy_gen" # --- MIN, MAX, MOY, APO 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 ues: colid = f"moy_ue_{ue.id}" row_min[colid] = fmt_note(self.etud_moy_ue[ue.id].min()) row_max[colid] = fmt_note(self.etud_moy_ue[ue.id].max()) row_moy[colid] = fmt_note(self.etud_moy_ue[ue.id].mean()) row_min[f"_{colid}_class"] = "col_ue" row_max[f"_{colid}_class"] = "col_ue" row_moy[f"_{colid}_class"] = "col_ue" row_apo[colid] = ue.code_apogee or "" for modimpl in self.formsemestre.modimpls_sorted: if modimpl.id in modimpl_ids: colid = f"moy_{modimpl.module.type_abbrv()}_{modimpl.id}_{ue.id}" if self.is_apc: coef = self.modimpl_coefs_df[modimpl.id][ue.id] else: coef = modimpl.module.coefficient or 0 row_coef[colid] = fmt_note(coef) notes = self.modimpl_notes(modimpl.id, ue.id) row_min[colid] = fmt_note(np.nanmin(notes)) row_max[colid] = fmt_note(np.nanmax(notes)) moy = np.nanmean(notes) row_moy[colid] = fmt_note(moy) if np.isnan(moy): # aucune note dans ce module row_moy[f"_{colid}_class"] = "col_empty" row_apo[colid] = modimpl.module.code_apogee or "" return { # { key : row } avec key = min, max, moy, coef "min": row_min, "max": row_max, "moy": row_moy, "coef": row_coef, "ects": row_ects, "apo": row_apo, } def _recap_etud_groups_infos(self, etudid: int, row: dict, titles: dict): """Table recap: ajoute à row les colonnes sur les groupes pour cet etud""" # 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 == DEM: gr_name = "Dém." row_class = "dem" elif etud_etat == 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" def _recap_add_admissions(self, rows: list[dict], titles: dict): """Ajoute les colonnes "admission" rows est une liste de dict avec une clé "etudid" Les colonnes ont la classe css "admission" """ fields = { "bac": "Bac", "specialite": "Spécialité", "type_admission": "Type Adm.", "classement": "Rg. Adm.", } first = True for i, cid in enumerate(fields): titles[f"_{cid}_col_order"] = 10000 + i # tout à droite if first: titles[f"_{cid}_class"] = "admission admission_first" first = False else: titles[f"_{cid}_class"] = "admission" titles.update(fields) for row in rows: etud = Identite.query.get(row["etudid"]) admission = etud.admission.first() first = True for cid in fields: row[cid] = getattr(admission, cid) or "" if first: row[f"_{cid}_class"] = "admission admission_first" first = False else: row[f"_{cid}_class"] = "admission" def _recap_add_partitions(self, rows: list[dict], titles: dict): """Ajoute les colonnes indiquant les groupes rows est une liste de dict avec une clé "etudid" Les colonnes ont la classe css "partition" """ partitions, partitions_etud_groups = sco_groups.get_formsemestre_groups( self.formsemestre.id ) first_partition = True for partition in partitions: cid = f"part_{partition['partition_id']}" titles[cid] = partition["partition_name"] if first_partition: klass = "partition" else: klass = "partition partition_aux" titles[f"_{cid}_class"] = klass titles[f"_{cid}_col_order"] = 10 partition_etud_groups = partitions_etud_groups[partition["partition_id"]] for row in rows: # dans NotesTableCompat, à revoir etud_etat = self.get_etud_etat(row["etudid"]) if etud_etat == "D": gr_name = "Dém." row["_tr_class"] = "dem" elif etud_etat == DEF: gr_name = "Déf." row["_tr_class"] = "def" else: group = partition_etud_groups.get(row["etudid"]) gr_name = group["group_name"] if group else "" if gr_name: row[f"{cid}"] = gr_name row[f"_{cid}_class"] = klass first_partition = False def _recap_add_evaluations( self, rows: list[dict], titles: dict, bottom_infos: dict ): """Ajoute les colonnes avec les notes aux évaluations rows est une liste de dict avec une clé "etudid" Les colonnes ont la classe css "evaluation" """ # nouvelle ligne pour description évaluations: bottom_infos["descr_evaluation"] = { "_tr_class": "bottom_info", "_title": "Description évaluation", } first_eval = True index_col = 9000 # à droite for modimpl in self.formsemestre.modimpls_sorted: evals = self.modimpls_results[modimpl.id].get_evaluations_completes(modimpl) eval_index = len(evals) - 1 inscrits = {i.etudid for i in modimpl.inscriptions} first_eval_of_mod = True for e in evals: cid = f"eval_{e.id}" titles[ cid ] = f'{modimpl.module.code} {eval_index} {e.jour.isoformat() if e.jour else ""}' klass = "evaluation" if first_eval: klass += " first" elif first_eval_of_mod: klass += " first_of_mod" titles[f"_{cid}_class"] = klass first_eval_of_mod = first_eval = False titles[f"_{cid}_col_order"] = index_col index_col += 1 eval_index -= 1 notes_db = sco_evaluation_db.do_evaluation_get_all_notes( e.evaluation_id ) for row in rows: etudid = row["etudid"] if etudid in inscrits: if etudid in notes_db: val = notes_db[etudid]["value"] else: # Note manquante mais prise en compte immédiate: affiche ATT val = scu.NOTES_ATTENTE row[cid] = scu.fmt_note(val) row[f"_{cid}_class"] = klass + { "ABS": " abs", "ATT": " att", "EXC": " exc", }.get(row[cid], "") else: row[cid] = "ni" row[f"_{cid}_class"] = klass + " non_inscrit" bottom_infos["coef"][cid] = e.coefficient bottom_infos["min"][cid] = "0" bottom_infos["max"][cid] = scu.fmt_note(e.note_max) bottom_infos["descr_evaluation"][cid] = e.description or "" bottom_infos["descr_evaluation"][f"_{cid}_target"] = url_for( "notes.evaluation_listenotes", scodoc_dept=g.scodoc_dept, evaluation_id=e.id, )