# -*- mode: python -*- # -*- coding: utf-8 -*- ############################################################################## # # Gestion scolarite IUT # # Copyright (c) 1999 - 2024 Emmanuel Viennet. All rights reserved. # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # # Emmanuel Viennet emmanuel.viennet@viennet.net # ############################################################################## ############################################################################## # Module "Avis de poursuite d'étude" # conçu et développé par Cléo Baras (IUT de Grenoble) ############################################################################## """ Created on Fri Sep 9 09:15:05 2016 @author: barasc """ from app.comp.res_sem import load_formsemestre_results from app.pe import pe_affichage import pandas as pd import numpy as np import app.pe.rcss.pe_rcs as pe_rcs import app.pe.rcss.pe_rcrcf as pe_rcrcf import app.pe.pe_sxtag as pe_sxtag from app.pe.pe_tabletags import TableTag from app.pe.pe_moytag import MoyennesTag class RCSTag(TableTag): def __init__(self, rcrcf: pe_rcs.RCS, sxstags: dict[(str, int): pe_sxtag.SxTag]): """Calcule les moyennes par tag (orientées compétences) d'un regroupement de SxTag (RCRCF), pour extraire les classements par tag pour un groupe d'étudiants donnés. Le groupe d'étudiants est formé par ceux ayant tous participé au même semestre terminal. Args: rcs: Un RCS (identifié par un nom et l'id de son semestre terminal) sxstags: Les données sur les RCF taggués """ TableTag.__init__(self) self.rcs_id: tuple(str, int) = rcrcf.rcs_id """Identifiant du RCS taggué (identique au RCS sur lequel il s'appuie)""" self.rcrcf: pe_rcrcf.RCRCF = rcrcf """RCRCF associé au RCS taggué""" self.nom = self.get_repr() """Représentation textuelle du RCS taggué""" self.formsemestre_terminal = rcrcf.formsemestre_final """Le formsemestre terminal""" pe_affichage.pe_print(f"-> {self.get_repr(verbose=True)}") # Les résultats du formsemestre terminal nt = load_formsemestre_results(self.formsemestre_terminal) self.rcfs_aggreges = rcrcf.rcfs_aggreges """Les RCFs aggrégés""" self.sxstags = {} """Les SxTag associés aux RCF aggrégés""" try: for rcf_id in self.rcfs_aggreges: self.sxstags[rcf_id] = sxstags[rcf_id] except: raise ValueError("Semestres SxTag manquants") # Les étudiants (etuds, états civils & etudis) self.etuds = nt.etuds self.add_etuds(nt.etuds) # Les compétences (extraites de tous les Sxtags) self.association_ues_comp = self.mapping_ue_competences() print(self.association_ues_comp) """Association indiquant pour chaque UE , quelle compétence lui correspond""" self.competences_sorted = self.do_complist() """Liste des compétences triées""" """Compétences extraites de tous les SxTag aggrégés""" pe_affichage.pe_print(f"* Compétences : {', '.join(self.competences_sorted)}") # Les tags self.tags_sorted = self.do_taglist() """Tags extraits de tous les SxTag aggrégés""" pe_affichage.pe_print(f"* Tags : {', '.join(self.tags_sorted)}") # Les moyennes self.moyennes_tags: dict[str, MoyennesTag] = {} """Synthétise les moyennes/classements par tag (qu'ils soient personnalisé ou de compétences)""" for tag in self.tags_sorted: # Cube de note notes_cube, coeffs_cube = self.compute_notes_comps_cube(tag) # Calcule des moyennes/coeffs sous forme d'un dataframe""" moys_competences, coeffs_competences = compute_notes_competences( notes_cube, coeffs_cube, self.etudids, self.competences_sorted ) # Les moyennes self.moyennes_tags[tag] = MoyennesTag(tag, moys_competences, coeffs_competences) def __eq__(self, other): """Egalité de 2 RCS taggués sur la base de leur identifiant""" return self.rcs_id == other.sxtag_id def get_repr(self, verbose=True) -> str: """Renvoie une représentation textuelle (celle de la trajectoire sur laquelle elle est basée)""" if verbose: return self.rcrcf.get_repr(verbose=verbose) else: return f"{self.__class__.__name__} ({self.rcs_id})" def compute_notes_comps_cube(self, tag): """Pour un tag donné, construit : * le cube de notes (etudid x competences x SxTag) nécessaire au calcul des moyennes, en remplaçant les données d'UE (obtenus du SxTag) par les compétences * le cube de coeffs (etudid x competences x SxTag) (traduisant les inscriptions) appliqué au calcul des différents SxTag """ # nb_tags = len(self.tags_sorted) # nb_etudiants = len(self.etuds) # nb_semestres = len(self.semestres_tags_aggreges) # Index du cube (etudids -> dim 0, tags -> dim 1) etudids = [etud.etudid for etud in self.etuds] competences_sorted = self.competences_sorted sxstags_ids = list(self.sxstags.keys()) notes_dfs = {} coeffs_dfs = {} for sxtag_id, sxtag in self.sxstags.items(): # Partant d'un dataframe vierge notes_df = pd.DataFrame(np.nan, index=etudids, columns=competences_sorted) coeffs_df = pd.DataFrame(np.nan, index=etudids, columns=competences_sorted) moys_tag = sxtag.moyennes_tags[tag] # Charge les notes et les coeffs du semestre tag notes = moys_tag.matrice_notes.copy() # avec une copie coeffs = moys_tag.matrice_coeffs_moy_gen.copy() # les coeffs # Traduction des UE en compétences ues_columns_df = notes.columns comp_associes_aux_ues = [self.association_ues_comp[ue] for ue in ues_columns_df] notes.columns = comp_associes_aux_ues coeffs.columns = comp_associes_aux_ues # Compétences communes comp_communes = list(set(competences_sorted) & set(comp_associes_aux_ues)) # Etudiants communs etudids_communs = notes_df.index.intersection(notes.index) # Recopie des notes et des coeffs notes_df.loc[etudids_communs, comp_communes] = notes.loc[ etudids_communs, comp_communes ] coeffs_df.loc[etudids_communs, comp_communes] = coeffs.loc[ etudids_communs, comp_communes ] # Supprime tout ce qui n'est pas numérique for col in notes_df.columns: notes_df[col] = pd.to_numeric(notes_df[col], errors="coerce") # Stocke les dfs notes_dfs[sxtag_id] = notes_df coeffs_dfs[sxtag_id] = coeffs_df """Réunit les notes sous forme d'un cube etudids x competences x semestres""" sxtag_x_etudids_x_comps = [notes_dfs[fid].values for fid in notes_dfs] notes_etudids_x_comps_x_sxtag = np.stack(sxtag_x_etudids_x_comps, axis=-1) """Réunit les coeffs sous forme d'un cube etudids x competences x semestres""" sxtag_x_etudids_x_comps = [coeffs_dfs[fid].values for fid in notes_dfs] coeffs_etudids_x_comps_x_sxtag = np.stack(sxtag_x_etudids_x_comps, axis=-1) return notes_etudids_x_comps_x_sxtag, coeffs_etudids_x_comps_x_sxtag def do_taglist(self): """Synthétise les tags à partir des Sxtags aggrégés Returns: Une liste de tags triés par ordre alphabétique """ tags = [] for frmsem_id in self.sxstags: tags.extend(self.sxstags[frmsem_id].tags_sorted) return sorted(set(tags)) def mapping_ue_competences(self): """Dictionnaire {ue: competences} extrait des SxTags""" dict_competences = {} for sxtag_id, sxtag in self.sxstags.items(): comp = sxtag.competences dict_competences |= comp return dict_competences def do_complist(self): """Synthétise les compétences à partir des Sxtags aggrégés""" dict_competences = self.mapping_ue_competences() return sorted(set(dict_competences.values())) def compute_notes_competences( set_cube: np.array, coeff_cube: np.array, etudids: list, competences: list ): """Calcule: * la moyenne par compétences à un tag donné sur plusieurs semestres (partant du set_cube). * la somme des coeffs à utiliser pour la moyenne générale. La moyenne est un nombre (note/20), ou NaN si pas de notes disponibles *Remarque* : Adaptation de moy_ue.compute_ue_moys_apc au cas des moyennes de tag par aggrégat de plusieurs semestres. Args: set_cube: notes moyennes aux modules ndarray (etuds x UEs|compétences x sxtags), des floats avec des NaN coeffs_cube: somme des coeffs impliqués dans la moyennes etudids: liste des étudiants (dim. 0 du cube) competences: list tags: liste des tags (dim. 1 du cube) Returns: Un DataFrame avec pour columns les moyennes par tags, et pour rows les etudid """ nb_etuds, nb_comps, nb_semestres = set_cube.shape assert nb_etuds == len(etudids) assert nb_comps == len(competences) # Quelles entrées du cube contiennent des notes ? mask = ~np.isnan(set_cube) # Enlève les NaN du cube de notes pour les entrées manquantes set_cube_no_nan = np.nan_to_num(set_cube, nan=0.0) coeffs_cube_no_nan = np.nan_to_num(coeff_cube, nan=0.0) # Les moyennes par tag with np.errstate(invalid="ignore"): # ignore les 0/0 (-> NaN) etud_moy_tag = np.sum(set_cube_no_nan, axis=2) / np.sum(mask, axis=2) # La somme des coeffs coeff_tag = np.sum(coeffs_cube_no_nan, axis=2) # Le dataFrame des notes moyennes etud_moy_tag_df = pd.DataFrame( etud_moy_tag, index=etudids, # les etudids columns=competences, # les competences ) etud_moy_tag_df.fillna(np.nan) coeffs_df = pd.DataFrame(coeff_tag, index=etudids, columns=competences) coeffs_df.fillna(np.nan) return etud_moy_tag_df, coeffs_df