dubacq/ScoDoc
1
0
Fork 0
forked from ScoDoc/ScoDoc
Code Pull Requests Activity

Corrige tri etuds/compétences dans traduction SxTag -> RSCTag

Browse Source
This commit is contained in:
Cléo Baras 2024-02-19 20:12:49 +01:00
parent 491d600bd4
commit 8de1a44583
1 changed files with 28 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
app/pe/pe_rcstag.py
View File

@ -43,7 +43,7 @@ import numpy as np
import app.pe.rcss.pe_rcs as pe_rcs import app.pe.rcss.pe_rcs as pe_rcs
import app.pe.rcss.pe_rcrcf as pe_rcrcf import app.pe.rcss.pe_rcrcf as pe_rcrcf
import app.pe.pe_sxtag as pe_sxtag import app.pe.pe_sxtag as pe_sxtag
import app.pe.pe_comp as pe_comp
from app.pe.pe_tabletags import TableTag from app.pe.pe_tabletags import TableTag
from app.pe.pe_moytag import MoyennesTag from app.pe.pe_moytag import MoyennesTag
@ -93,16 +93,16 @@ class RCSTag(TableTag):
# Les étudiants (etuds, états civils & etudis) # Les étudiants (etuds, états civils & etudis)
self.etuds = nt.etuds self.etuds = nt.etuds
self.add_etuds(nt.etuds) self.add_etuds(nt.etuds)
self.etudids_sorted = sorted(self.etudids)
"""Etudids triés"""
# Les compétences (extraites de tous les Sxtags) # Les compétences (extraites de tous les Sxtags)
self.association_ues_comp = self.mapping_ue_competences() self.association_ues_comp = self.mapping_ue_competences()
print(self.association_ues_comp)
"""Association indiquant pour chaque UE , quelle compétence lui correspond""" """Association indiquant pour chaque UE , quelle compétence lui correspond"""
pe_affichage.pe_print(f"* Association UEs -> compétences : {self.association_ues_comp}")
self.competences_sorted = self.do_complist() self.competences_sorted = self.do_complist()
"""Liste des compétences triées""" """Compétences (triées) extraites de tous les SxTag aggrégés"""
"""Compétences extraites de tous les SxTag aggrégés"""
pe_affichage.pe_print(f"* Compétences : {', '.join(self.competences_sorted)}") pe_affichage.pe_print(f"* Compétences : {', '.join(self.competences_sorted)}")
# Les tags # Les tags
@ -116,11 +116,11 @@ class RCSTag(TableTag):
for tag in self.tags_sorted: for tag in self.tags_sorted:
# Cube de note # Cube de note
notes_cube, coeffs_cube = self.compute_notes_comps_cube(tag) notes_cube, coeffs_cube = self.compute_notes_comps_cube(tag, self.etudids_sorted, self.competences_sorted)
# Calcule des moyennes/coeffs sous forme d'un dataframe""" # Calcule des moyennes/coeffs sous forme d'un dataframe"""
moys_competences, coeffs_competences = compute_notes_competences( moys_competences, coeffs_competences = compute_notes_competences(
notes_cube, coeffs_cube, self.etudids, self.competences_sorted notes_cube, coeffs_cube, self.etudids_sorted, self.competences_sorted
) )
# Les moyennes # Les moyennes
@ -139,20 +139,25 @@ class RCSTag(TableTag):
else: else:
return f"{self.__class__.__name__} ({self.rcs_id})" return f"{self.__class__.__name__} ({self.rcs_id})"
def compute_notes_comps_cube(self, tag): def compute_notes_comps_cube(self, tag, etudids_sorted: list[int], competences_sorted: list[str]):
"""Pour un tag donné, construit : """Pour un tag donné, construit :
* le cube de notes (etudid x competences x SxTag) nécessaire au calcul des moyennes, * 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 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) * le cube de coeffs (etudid x competences x SxTag) (traduisant les inscriptions)
appliqué au calcul des différents SxTag appliqué au calcul des différents SxTag
Args:
tag: Le tag visé
etudids_sorted: Les etudis triés
competences_sorted: Les compétences triées
""" """
# nb_tags = len(self.tags_sorted) # nb_tags = len(self.tags_sorted)
# nb_etudiants = len(self.etuds) # nb_etudiants = len(self.etuds)
# nb_semestres = len(self.semestres_tags_aggreges) # nb_semestres = len(self.semestres_tags_aggreges)
# Index du cube (etudids -> dim 0, tags -> dim 1) # Index du cube (etudids -> dim 0, tags -> dim 1)
etudids = [etud.etudid for etud in self.etuds] # etudids = [etud.etudid for etud in self.etuds]
competences_sorted = self.competences_sorted # competences_sorted = self.competences_sorted
sxstags_ids = list(self.sxstags.keys()) sxstags_ids = list(self.sxstags.keys())
notes_dfs = {} notes_dfs = {}
@ -160,8 +165,8 @@ class RCSTag(TableTag):
for sxtag_id, sxtag in self.sxstags.items(): for sxtag_id, sxtag in self.sxstags.items():
# Partant d'un dataframe vierge # Partant d'un dataframe vierge
notes_df = pd.DataFrame(np.nan, index=etudids, columns=competences_sorted) notes_df = pd.DataFrame(np.nan, index=etudids_sorted, columns=competences_sorted)
coeffs_df = pd.DataFrame(np.nan, index=etudids, columns=competences_sorted) coeffs_df = pd.DataFrame(np.nan, index=etudids_sorted, columns=competences_sorted)
moys_tag = sxtag.moyennes_tags[tag] moys_tag = sxtag.moyennes_tags[tag]
@ -175,11 +180,8 @@ class RCSTag(TableTag):
notes.columns = comp_associes_aux_ues notes.columns = comp_associes_aux_ues
coeffs.columns = comp_associes_aux_ues coeffs.columns = comp_associes_aux_ues
# Compétences communes # Les étudiants et les compétences communes
comp_communes = list(set(competences_sorted) & set(comp_associes_aux_ues)) etudids_communs, comp_communes = pe_comp.find_index_and_columns_communs(notes_df, notes)
# Etudiants communs
etudids_communs = notes_df.index.intersection(notes.index)
# Recopie des notes et des coeffs # Recopie des notes et des coeffs
notes_df.loc[etudids_communs, comp_communes] = notes.loc[ notes_df.loc[etudids_communs, comp_communes] = notes.loc[
@ -233,7 +235,7 @@ class RCSTag(TableTag):
def compute_notes_competences( def compute_notes_competences(
set_cube: np.array, coeff_cube: np.array, etudids: list, competences: list set_cube: np.array, coeff_cube: np.array, etudids_sorted: list, competences_sorted: list
): ):
"""Calcule: """Calcule:
* la moyenne par compétences à un tag donné sur plusieurs semestres (partant du set_cube). * la moyenne par compétences à un tag donné sur plusieurs semestres (partant du set_cube).
@ -248,16 +250,16 @@ def compute_notes_competences(
set_cube: notes moyennes aux modules ndarray set_cube: notes moyennes aux modules ndarray
(etuds x UEs|compétences x sxtags), des floats avec des NaN (etuds x UEs|compétences x sxtags), des floats avec des NaN
coeffs_cube: somme des coeffs impliqués dans la moyennes coeffs_cube: somme des coeffs impliqués dans la moyennes
etudids: liste des étudiants (dim. 0 du cube) etudids_sorted: liste des étudiants (dim. 0 du cube)
competences: list competences_sorted: list
tags: liste des tags (dim. 1 du cube) tags: liste des tags (dim. 1 du cube)
Returns: Returns:
Un DataFrame avec pour columns les moyennes par tags, Un DataFrame avec pour columns les moyennes par tags,
et pour rows les etudid et pour rows les etudid
""" """
nb_etuds, nb_comps, nb_semestres = set_cube.shape nb_etuds, nb_comps, nb_semestres = set_cube.shape
assert nb_etuds == len(etudids) assert nb_etuds == len(etudids_sorted)
assert nb_comps == len(competences) assert nb_comps == len(competences_sorted)
# Quelles entrées du cube contiennent des notes ? # Quelles entrées du cube contiennent des notes ?
mask = ~np.isnan(set_cube) mask = ~np.isnan(set_cube)
@ -275,12 +277,12 @@ def compute_notes_competences(
# Le dataFrame des notes moyennes # Le dataFrame des notes moyennes
etud_moy_tag_df = pd.DataFrame( etud_moy_tag_df = pd.DataFrame(
etud_moy_tag, etud_moy_tag,
index=etudids, # les etudids index=etudids_sorted, # les etudids
columns=competences, # les competences columns=competences_sorted, # les competences
) )
etud_moy_tag_df.fillna(np.nan) etud_moy_tag_df.fillna(np.nan)
coeffs_df = pd.DataFrame(coeff_tag, index=etudids, columns=competences) coeffs_df = pd.DataFrame(coeff_tag, index=etudids_sorted, columns=competences_sorted)
coeffs_df.fillna(np.nan) coeffs_df.fillna(np.nan)
return etud_moy_tag_df, coeffs_df return etud_moy_tag_df, coeffs_df