IDK/ScoDoc
1
0
Fork 0
forked from ScoDoc/ScoDoc
Code Issues Pull Requests Projects Releases Wiki Activity

Génère les RCSTag (mais sont-ils bons ??)

Browse Source
This commit is contained in:
Cléo Baras 2024-02-20 20:52:44 +01:00
parent 0f446fe0d3
commit b5125fa3d7
3 changed files with 103 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
app/pe/pe_jury.py
View File

@ -108,8 +108,8 @@ class JuryPE(object):
self._gen_trajectoires() self._gen_trajectoires()
self._gen_semXs() self._gen_semXs()
self._gen_xls_sxtags(zipfile) self._gen_xls_sxtags(zipfile)
# self._gen_rcsemxs() self._gen_rcsemxs()
# self._gen_xls_rcrcss_tags(zipfile) self._gen_xls_rcstags(zipfile)
# self._gen_xls_interclassements_rcss(zipfile) # self._gen_xls_interclassements_rcss(zipfile)
# self._gen_xls_synthese_jury_par_tag(zipfile) # self._gen_xls_synthese_jury_par_tag(zipfile)
# self._gen_xls_synthese_par_etudiant(zipfile) # self._gen_xls_synthese_par_etudiant(zipfile)
@ -255,7 +255,7 @@ class JuryPE(object):
self.rcss_jury.cree_rcsemxs(self.etudiants) self.rcss_jury.cree_rcsemxs(self.etudiants)
self.rcss_jury._aff_rcsemxs_suivis(self.etudiants) self.rcss_jury._aff_rcsemxs_suivis(self.etudiants)
def _gen_xls_rcrcss_tags(self, zipfile: ZipFile): def _gen_xls_rcstags(self, zipfile: ZipFile):
"""Génère les RCS taggués traduisant les moyennes (orientées compétences) """Génère les RCS taggués traduisant les moyennes (orientées compétences)
de regroupements de semestre de type Sx, xA ou xS. de regroupements de semestre de type Sx, xA ou xS.
@ -278,8 +278,8 @@ class JuryPE(object):
pe_affichage.pe_print("*** Calcule les moyennes des RC de RCFS") pe_affichage.pe_print("*** Calcule les moyennes des RC de RCFS")
self.rcss_tags = {} self.rcss_tags = {}
for rcs_id, rcrcf in self.rcss_jury.rcsemxs.items(): for rcs_id, rcsemx in self.rcss_jury.rcsemxs.items():
self.rcss_tags[rcs_id] = RCSTag(rcrcf, self.sxtags) self.rcss_tags[rcs_id] = RCSTag(rcsemx, self.sxtags)
# Intègre le bilan des trajectoires tagguées au zip final # Intègre le bilan des trajectoires tagguées au zip final
output = io.BytesIO() output = io.BytesIO()

60
app/pe/pe_rcss_jury.py
View File

@ -142,22 +142,25 @@ class RCSsJuryPE:
analysés (trajectoires traduisant son parcours dans les analysés (trajectoires traduisant son parcours dans les
différents semestres) + les mémorise dans les données de l'étudiant différents semestres) + les mémorise dans les données de l'étudiant
""" """
self.rcsemxs_suivis = {nom_rcs: None for nom_rcs in pe_rcs.TOUS_LES_RCS} self.rcsemxs_suivis = {}
self.rcsemxs = {} self.rcsemxs = {}
# Pour tous les étudiants du jury # Pour tous les étudiants du jury
for etudid in self.trajectoires_suivies: for etudid in self.trajectoires_suivies:
self.rcsemxs_suivis[etudid] = {} self.rcsemxs_suivis[etudid] = {
nom_rcs: None for nom_rcs in pe_rcs.TOUS_LES_RCS_AVEC_PLUSIEURS_SEM
}
# Recopie des SemX & des suivis associés # Recopie des SemX & des suivis associés => est-ce utile ?
for nom_rcs in pe_rcs.TOUS_LES_SEMESTRES: # for nom_rcs in pe_rcs.TOUS_LES_SEMESTRES:
trajectoire = self.semXs_suivis[etudid][nom_rcs] # trajectoire = self.semXs_suivis[etudid][nom_rcs]
if trajectoire: # if trajectoire:
self.rcsemxs[trajectoire.rcs_id] = trajectoire # self.rcsemxs[trajectoire.rcs_id] = trajectoire
self.rcsemxs_suivis[etudid][nom_rcs] = trajectoire # self.rcsemxs_suivis[etudid][nom_rcs] = trajectoire
# Pour chaque aggréggat de type xA ou Sx # Pour chaque aggréggat de type xA ou Sx
for nom_rcs in pe_rcs.TOUS_LES_RCS_AVEC_PLUSIEURS_SEM: tous_les_agregats = pe_rcs.TOUS_LES_RCS
for nom_rcs in tous_les_agregats:
trajectoire = self.trajectoires_suivies[etudid][nom_rcs] trajectoire = self.trajectoires_suivies[etudid][nom_rcs]
if not trajectoire: if not trajectoire:
self.rcsemxs_suivis[etudid][nom_rcs] = None self.rcsemxs_suivis[etudid][nom_rcs] = None
@ -179,16 +182,20 @@ class RCSsJuryPE:
semxs_a_aggreger = {} semxs_a_aggreger = {}
for Sx in noms_sems_aggregat: for Sx in noms_sems_aggregat:
semestres_etudiants = etudiants.cursus[etudid][Sx] semestres_etudiants = etudiants.cursus[etudid][Sx]
if not semestres_etudiants:
semx_id = get_semx_from_semestres_aggreges( pe_affichage.pe_print(
self.semXs, semestres_etudiants f"-> ⚠ Pas de semestres {Sx} pour {etudiants.identites[etudid].etat_civil}"
)
if not semx_id:
raise (
"Il manque un SemX pour créer les RCSemX dans cree_rcsemxs"
) )
# Les SemX à ajouter au RCSemX else:
semxs_a_aggreger[semx_id] = self.semXs[semx_id] semx_id = get_semx_from_semestres_aggreges(
self.semXs, semestres_etudiants
)
if not semx_id:
raise (
"Il manque un SemX pour créer les RCSemX dans cree_rcsemxs"
)
# Les SemX à ajouter au RCSemX
semxs_a_aggreger[semx_id] = self.semXs[semx_id]
# Ajout des SemX à ceux à aggréger dans le RCSemX # Ajout des SemX à ceux à aggréger dans le RCSemX
rcsemx = self.rcsemxs[tid] rcsemx = self.rcsemxs[tid]
@ -200,15 +207,16 @@ class RCSsJuryPE:
def _aff_rcsemxs_suivis(self, etudiants): def _aff_rcsemxs_suivis(self, etudiants):
"""Affiche les RCSemX suivis par les étudiants""" """Affiche les RCSemX suivis par les étudiants"""
# Affichage pour debug # Affichage pour debug
jeunes = list(enumerate(self.rcsemxs_suivis)) jeunes = list(enumerate(self.rcsemxs_suivis.keys()))
vides = [] vides = []
for no_etud, etudid in jeunes[:20]: for no_etud, etudid in jeunes:
pe_affichage.pe_print(f"-> {etudiants.identites[etudid].nomprenom} :") if etudid not in etudiants.abandons_ids:
for nom_rcs, rcs in self.rcsemxs_suivis[etudid].items(): pe_affichage.pe_print(f"-> {etudiants.identites[etudid].nomprenom} :")
if rcs: for nom_rcs, rcs in self.rcsemxs_suivis[etudid].items():
pe_affichage.pe_print(f" > RCSemX {nom_rcs}: {rcs.get_repr()}") if rcs:
else: pe_affichage.pe_print(f" > RCSemX {nom_rcs}: {rcs.get_repr()}")
vides += [f"{nom_rcs}"] else:
vides += [f"{nom_rcs}"]
pe_affichage.pe_print(f"-> ⚠ RCSemX vides : {', '.join(list(set(vides)))}") pe_affichage.pe_print(f"-> ⚠ RCSemX vides : {', '.join(list(set(vides)))}")

119
app/pe/pe_rcstag.py
View File

@ -41,8 +41,7 @@ from app.models import FormSemestre
from app.pe import pe_affichage from app.pe import pe_affichage
import pandas as pd import pandas as pd
import numpy as np import numpy as np
import app.pe.rcss.pe_rcs as pe_rcs from app.pe.rcss import pe_rcs, pe_rcsemx
import app.pe.rcss.pe_rcsemx 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 import app.pe.pe_comp as pe_comp
from app.pe.pe_tabletags import TableTag from app.pe.pe_tabletags import TableTag
@ -50,7 +49,9 @@ from app.pe.pe_moytag import MoyennesTag
class RCSTag(TableTag): class RCSTag(TableTag):
def __init__(self, rcrcf: pe_rcs.RCS, sxstags: dict[(str, int) : pe_sxtag.SxTag]): def __init__(
self, rcsemx: pe_rcsemx.RCSemX, sxstags: dict[(str, int) : pe_sxtag.SxTag]
):
"""Calcule les moyennes par tag (orientées compétences) """Calcule les moyennes par tag (orientées compétences)
d'un regroupement de SxTag d'un regroupement de SxTag
(RCRCF), pour extraire les classements par tag pour un (RCRCF), pour extraire les classements par tag pour un
@ -58,42 +59,43 @@ class RCSTag(TableTag):
participé au même semestre terminal. participé au même semestre terminal.
Args: Args:
rcs: Un RCS (identifié par un nom et l'id de son semestre terminal) rcsemx: Le RCSemX (identifié par un nom et l'id de son semestre terminal)
sxstags: Les données sur les RCF taggués sxstags: Les données sur les SemX taggués
""" """
TableTag.__init__(self) TableTag.__init__(self)
self.rcs_id: tuple(str, int) = rcrcf.rcs_id self.rcs_id: tuple(str, int) = rcsemx.rcs_id
"""Identifiant du RCS taggué (identique au RCS sur lequel il s'appuie)""" """Identifiant du RCSTag (identique au RCSemX sur lequel il s'appuie)"""
self.rcrcf: pe_rcrcf.RCSemX = rcrcf self.rcsemx: pe_rcsemx.RCSemX = rcsemx
"""RCRCF associé au RCS taggué""" """RCSemX associé au RCSTag"""
self.nom = self.get_repr() self.nom = self.get_repr()
"""Représentation textuelle du RCS taggué""" """Représentation textuelle du RSCtag"""
# Les données du semestre final # Les données du semestre final
self.formsemestre_terminal: FormSemestre = rcrcf.formsemestre_final self.formsemestre_final: FormSemestre = rcsemx.formsemestre_final
"""Le semestre final""" """Le semestre final"""
self.fid_final: int = rcrcf.formsemestre_final.formsemestre_id self.fid_final: int = rcsemx.formsemestre_final.formsemestre_id
"""Le fid du semestre final""" """Le fid du semestre final"""
# Affichage pour debug # Affichage pour debug
pe_affichage.pe_print(f"-> {self.get_repr(verbose=True)}") pe_affichage.pe_print(f"-> {self.get_repr(verbose=True)}")
# Les données aggrégés (RCRCF + SxTags # Les données aggrégés (RCRCF + SxTags
self.rcsemxs_aggreges = rcrcf.rcsemxs_aggreges self.semXs_aggreges: dict[(str, int) : pe_rcsemx.RCSemX] = rcsemx.semXs_aggreges
"""Les RCFs aggrégés""" """Les SemX aggrégés"""
self.sxstags = {} self.sxstags = {}
"""Les SxTag associés aux RCF aggrégés""" """Les SxTag associés aux SemX aggrégés"""
try: try:
for rcf_id in self.rcsemxs_aggreges: for rcf_id in self.semXs_aggreges:
self.sxstags[rcf_id] = sxstags[rcf_id] self.sxstags[rcf_id] = sxstags[rcf_id]
except: except:
raise ValueError("Semestres SxTag manquants") raise ValueError("Semestres SxTag manquants")
# Les étudiants (etuds, états civils & etudis) # Les étudiants (etuds, états civils & etudis)
sxtag_final = self.sxstags[self.rcs_id] sems_dans_aggregat = pe_rcs.TYPES_RCS[self.rcs_id[0]]["aggregat"]
sxtag_final = self.sxstags[(sems_dans_aggregat[-1], self.rcs_id[1])]
self.etuds = sxtag_final.etuds self.etuds = sxtag_final.etuds
"""Les étudiants (extraits du semestre final)""" """Les étudiants (extraits du semestre final)"""
self.add_etuds(self.etuds) self.add_etuds(self.etuds)
@ -106,7 +108,10 @@ class RCSTag(TableTag):
pe_affichage.pe_print( pe_affichage.pe_print(
f"* Association UEs -> compétences : {self.acronymes_ues_to_competences}" f"* Association UEs -> compétences : {self.acronymes_ues_to_competences}"
) )
self.competences_sorted = sorted(self.acronymes_ues_to_competences.values()) self.competences_sorted = sorted(
set(self.acronymes_ues_to_competences.values())
)
"""Compétences (triées par nom, extraites des SxTag aggrégés)""" """Compétences (triées par nom, extraites des 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)}")
@ -119,6 +124,7 @@ class RCSTag(TableTag):
self.moyennes_tags: dict[str, MoyennesTag] = {} self.moyennes_tags: dict[str, MoyennesTag] = {}
"""Synthétise les moyennes/classements par tag (qu'ils soient personnalisé ou de compétences)""" """Synthétise les moyennes/classements par tag (qu'ils soient personnalisé ou de compétences)"""
for tag in self.tags_sorted: for tag in self.tags_sorted:
print(tag)
# Cube de notes (etudids_sorted x compétences_sorted x sxstags) # Cube de notes (etudids_sorted x compétences_sorted x sxstags)
notes_df, notes_cube = self.compute_notes_comps_cube( notes_df, notes_cube = self.compute_notes_comps_cube(
tag, self.etudids_sorted, self.competences_sorted, self.sxstags tag, self.etudids_sorted, self.competences_sorted, self.sxstags
@ -153,7 +159,7 @@ class RCSTag(TableTag):
"""Renvoie une représentation textuelle (celle de la trajectoire sur laquelle elle """Renvoie une représentation textuelle (celle de la trajectoire sur laquelle elle
est basée)""" est basée)"""
if verbose: if verbose:
return self.rcrcf.get_repr(verbose=verbose) return self.rcsemx.get_repr(verbose=verbose)
else: else:
return f"{self.__class__.__name__} ({self.rcs_id})" return f"{self.__class__.__name__} ({self.rcs_id})"
@ -182,26 +188,29 @@ class RCSTag(TableTag):
np.nan, index=etudids_sorted, columns=competences_sorted np.nan, index=etudids_sorted, columns=competences_sorted
) )
# Charge les notes du semestre tag (copie car changement de nom de colonnes à venir) # Charge les notes du semestre tag (copie car changement de nom de colonnes à venir)
moys_tag = sxtag.moyennes_tags[tag] if tag in sxtag.moyennes_tags: # si le tag est présent dans le semestre
notes = moys_tag.matrice_notes.copy() # avec une copie moys_tag = sxtag.moyennes_tags[tag]
# Traduction des acronymes d'UE en compétences notes = moys_tag.matrice_notes.copy() # avec une copie
acronymes_ues_columns = notes.columns
acronymes_to_comps = [
self.acronymes_ues_to_competences[acro]
for acro in acronymes_ues_columns
]
notes.columns = acronymes_to_comps
# Les étudiants et les compétences communes # Traduction des acronymes d'UE en compétences
etudids_communs, comp_communes = pe_comp.find_index_and_columns_communs( acronymes_ues_columns = notes.columns
notes_df, notes acronymes_to_comps = [
) self.acronymes_ues_to_competences[acro]
for acro in acronymes_ues_columns
]
notes.columns = acronymes_to_comps
# Recopie des notes et des coeffs # Les étudiants et les compétences communes
notes_df.loc[etudids_communs, comp_communes] = notes.loc[ (
etudids_communs, comp_communes etudids_communs,
] comp_communes,
) = pe_comp.find_index_and_columns_communs(notes_df, notes)
# Recopie des notes et des coeffs
notes_df.loc[etudids_communs, comp_communes] = notes.loc[
etudids_communs, comp_communes
]
# Supprime tout ce qui n'est pas numérique # Supprime tout ce qui n'est pas numérique
# for col in notes_df.columns: # for col in notes_df.columns:
@ -242,29 +251,29 @@ class RCSTag(TableTag):
coeffs_df = pd.DataFrame( coeffs_df = pd.DataFrame(
np.nan, index=etudids_sorted, columns=competences_sorted np.nan, index=etudids_sorted, columns=competences_sorted
) )
if tag in sxtag.moyennes_tags:
moys_tag = sxtag.moyennes_tags[tag]
moys_tag = sxtag.moyennes_tags[tag] # Charge les notes et les coeffs du semestre tag
coeffs = moys_tag.matrice_coeffs_moy_gen.copy() # les coeffs
# Charge les notes et les coeffs du semestre tag # Traduction des acronymes d'UE en compétences
coeffs = moys_tag.matrice_coeffs_moy_gen.copy() # les coeffs acronymes_ues_columns = coeffs.columns
acronymes_to_comps = [
self.acronymes_ues_to_competences[acro]
for acro in acronymes_ues_columns
]
coeffs.columns = acronymes_to_comps
# Traduction des acronymes d'UE en compétences # Les étudiants et les compétences communes
acronymes_ues_columns = coeffs.columns etudids_communs, comp_communes = pe_comp.find_index_and_columns_communs(
acronymes_to_comps = [ coeffs_df, coeffs
self.acronymes_ues_to_competences[acro] )
for acro in acronymes_ues_columns
]
coeffs.columns = acronymes_to_comps
# Les étudiants et les compétences communes # Recopie des notes et des coeffs
etudids_communs, comp_communes = pe_comp.find_index_and_columns_communs( coeffs_df.loc[etudids_communs, comp_communes] = coeffs.loc[
coeffs_df, coeffs etudids_communs, comp_communes
) ]
# Recopie des notes et des coeffs
coeffs_df.loc[etudids_communs, comp_communes] = coeffs.loc[
etudids_communs, comp_communes
]
# Stocke les dfs # Stocke les dfs
coeffs_dfs[sxtag_id] = coeffs_df coeffs_dfs[sxtag_id] = coeffs_df