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

Mise en place des interclassements

Browse Source
This commit is contained in:
Cléo Baras 2024-01-24 19:37:45 +01:00
parent 283daae4d9
commit 82713752c2
5 changed files with 85 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
app/pe/pe_etudiant.py
View File

@ -60,7 +60,9 @@ class EtudiantsJuryPE:
self.trajectoires = {}
"Les etudids des étudiants à considérer au jury (ceux qui seront effectivement diplômés)"
self.etudiants_diplomes = {}
self.diplomes_ids = {}
"Les etudids des étudiants dont il faut calculer les moyennes/classements (même si d'éventuels abandons)"
self.etudiants_ids = {}
@ -112,7 +114,8 @@ class EtudiantsJuryPE:
pe_tools.pe_print()
"""Les étudiants à prendre dans le diplôme, étudiants ayant abandonnés non compris"""
self.diplomes_ids = self.get_etudiants_diplomes()
self.etudiants_diplomes = self.get_etudiants_diplomes()
self.diplomes_ids = set(self.etudiants_diplomes.keys())
"""Les étudiants dont il faut calculer les moyennes"""
self.etudiants_ids = {etudid for etudid in self.identites}
@ -122,16 +125,16 @@ class EtudiantsJuryPE:
# Synthèse
pe_tools.pe_print(
f" => {len(self.diplomes_ids)} étudiants à diplômer en {self.annee_diplome}"
f" => {len(self.etudiants_diplomes)} étudiants à diplômer en {self.annee_diplome}"
)
nbre_abandons = len(self.etudiants_ids) - len(self.diplomes_ids)
nbre_abandons = len(self.etudiants_ids) - len(self.etudiants_diplomes)
pe_tools.pe_print(f" => {nbre_abandons} étudiants éliminer pour abandon")
pe_tools.pe_print(
f" => {len(self.formsemestres_jury_ids)} semestres dont il faut calculer la moyenne"
)
pe_tools.pe_print(
f" => quelques étudiants futurs diplômés : "
+ ", ".join([str(etudid) for etudid in list(self.diplomes_ids)[:10]])
+ ", ".join([str(etudid) for etudid in list(self.etudiants_diplomes)[:10]])
)
pe_tools.pe_print(
f" => semestres dont il faut calculer les moyennes : "

16
app/pe/pe_interclassetag.py → app/pe/pe_interclasstag.py
View File

@ -5,6 +5,7 @@ from app.pe.pe_tools import PE_DEBUG, pe_print
import app.pe.pe_etudiant as pe_etudiant
from app.pe.pe_etudiant import EtudiantsJuryPE
from app.pe.pe_trajectoire import Trajectoire, TrajectoiresJuryPE
from app.pe.pe_trajectoiretag import TrajectoireTag
from app.comp import moy_sem
import pandas as pd
@ -34,7 +35,7 @@ class AggregatInterclasseTag(pe_tagtable.TableTag):
pe_tagtable.TableTag.__init__(self, nom_aggregat)
"""Les étudiants diplômés et leurs trajectoires (cf. trajectoires.suivis)"""
self.diplomes_ids = etudiants.diplomes_ids
self.diplomes_ids = etudiants.etudiants_diplomes
self.etudiants_diplomes = {etudid for etudid in self.diplomes_ids}
"""Les trajectoires (et leur version tagguées), en ne gardant que celles associées à l'aggrégat
@ -53,9 +54,9 @@ class AggregatInterclasseTag(pe_tagtable.TableTag):
"""Les trajectoires suivies par les étudiants du jury, en ne gardant que
celles associées aux diplomés"""
self.suivis: dict[int, Trajectoire] = {}
self.suivi: dict[int, Trajectoire] = {}
for etudid in self.diplomes_ids:
self.suivis[etudid] = trajectoires_jury_pe.suivis[etudid][nom_aggregat]
self.suivi[etudid] = trajectoires_jury_pe.suivi[etudid][nom_aggregat]
"""Les tags"""
self.tags_sorted = self.do_taglist()
@ -77,6 +78,11 @@ class AggregatInterclasseTag(pe_tagtable.TableTag):
"nb_inscrits": len(moy_gen_tag),
}
def get_repr(self) -> str:
"""Une représentation textuelle"""
return f"Aggrégat {self.nom}"
def do_taglist(self):
"""Synthétise les tags à partir des trajectoires_tagguées
@ -89,8 +95,6 @@ class AggregatInterclasseTag(pe_tagtable.TableTag):
tags.extend(trajectoire.tags_sorted)
return sorted(set(tags))
def get_etudids(self):
return list(self.etudiants_diplomes.keys())
def compute_notes_matrice(self):
"""Construit la matrice de notes (etudid x tags)
@ -101,7 +105,7 @@ class AggregatInterclasseTag(pe_tagtable.TableTag):
nb_etudiants = len(self.diplomes_ids)
"""Index de la matrice (etudids -> dim 0, tags -> dim 1)"""
etudids = [etud.etudid for etud in self.diplomes_ids]
etudids = list(self.diplomes_ids)
tags = self.tags_sorted
"""Partant d'un dataframe vierge"""

113
app/pe/pe_jurype.py
View File

@ -47,30 +47,23 @@ import io
import os
from zipfile import ZipFile
import app.pe.pe_etudiant
import app.pe.pe_settag_interclasse
from app.comp import res_sem
from app.comp.res_compat import NotesTableCompat
from app.comp.res_sem import load_formsemestre_results
from app.models import Formation, FormSemestre
from app.models.etudiants import Identite
from app.pe.pe_semestretag import SemestreTag
from app.pe.pe_interclasstag import AggregatInterclasseTag
from app.pe.pe_trajectoiretag import TrajectoireTag
from app.scodoc.gen_tables import GenTable, SeqGenTable
import app.scodoc.sco_utils as scu
from app.scodoc import (
codes_cursus,
sco_formsemestre_inscriptions,
) # codes_cursus.NEXT -> sem suivant
from app.scodoc import sco_etud
from app.scodoc import sco_report
from app.scodoc import sco_formsemestre
from app.pe import pe_tagtable
from app.scodoc import codes_cursus
from app.pe import pe_tools
from app.pe import pe_semestretag
from app.pe import pe_trajectoiretag
from app.pe.pe_etudiant import EtudiantsJuryPE
from app.pe.pe_trajectoire import TrajectoiresJuryPE
from app.pe.pe_trajectoire import TrajectoiresJuryPE, Trajectoire
# ----------------------------------------------------------------------------------------
@ -143,6 +136,7 @@ class JuryPE(object):
self.etudiants.find_etudiants(self.formation_id)
"""Génère les semestres taggués (avec le calcul des moyennes) pour le jury PE"""
pe_tools.pe_print("*** Génère les semestres taggués")
self.semestres_taggues = compute_semestres_tag(self.etudiants)
if pe_tools.PE_DEBUG:
@ -158,41 +152,49 @@ class JuryPE(object):
"""Génère les trajectoires (combinaison de semestres suivis
par un étudiant pour atteindre le semestre final d'un aggrégat)
"""
pe_tools.pe_print(
"*** Génère les trajectoires (différentes combinaisons de semestres) des étudiants"
)
self.trajectoires = TrajectoiresJuryPE(self.diplome)
self.trajectoires.cree_trajectoires(self.etudiants)
"""Génère les aggrégats de semestre (par ex: 1A, 3S, 5S) avec calcul
des moyennes pour le jury"""
"""Génère les moyennes par tags des trajectoires"""
pe_tools.pe_print("*** Calcule les moyennes par tag des trajectoires possibles")
self.trajectoires_tagguees = compute_trajectoires_tag(
self.etudiants, self.semestres_taggues
self.trajectoires, self.etudiants, self.semestres_taggues
)
if pe_tools.PE_DEBUG:
"""Intègre le bilan des aggrégats de semestres au zip final"""
for aggregat in self.trajectoires_tagguees:
for fid in self.trajectoires_tagguees[aggregat]:
set_tag = self.trajectoires_tagguees[aggregat][fid]
filename = set_tag.nom.replace(" ", "_") + ".csv"
"""Intègre le bilan des trajectoires tagguées au zip final"""
for trajectoire_id in self.trajectoires_tagguees:
trajectoire_tagguee = self.trajectoires_tagguees[trajectoire_id]
filename = trajectoire_tagguee.get_repr().replace(" ", "_") + ".csv"
pe_tools.pe_print(f" - Export csv de {filename} ")
self.add_file_to_zip(
filename, set_tag.str_tagtable(), path="details_semestres"
filename,
trajectoire_tagguee.str_tagtable(),
path="details_semestres",
)
"""Génère les interclassements par (nom d') aggrégat"""
self.aggregats_taggues_interclasses = compute_interclassements(
self.etudiants, #
self.trajectoires_tagguees,
"""Génère les interclassements (par promo et) par (nom d') aggrégat"""
pe_tools.pe_print("*** Génère les interclassements par aggrégat")
self.interclassements_taggues = compute_interclassements(
self.etudiants, self.trajectoires, self.trajectoires_tagguees
)
# Les interclassements
# --------------------
if pe_tools.PE_DEBUG:
pe_tools.pe_print(
"*** Création des interclassements au sein de la promo sur différentes combinaisons de semestres"
"""Intègre le bilan des aggrégats (par promo) au zip final"""
for nom_aggregat in self.interclassements_taggues:
interclass_tag = self.interclassements_taggues[nom_aggregat]
filename = interclass_tag.get_repr().replace(" ", "_") + ".csv"
pe_tools.pe_print(f" - Export csv de {filename} ")
self.add_file_to_zip(
filename,
interclass_tag.str_tagtable(),
path="details_semestres",
)
"""Synthèse des éléments du jury PE"""
if False:
self.synthetise_juryPE()
# Export des données => mode 1 seule feuille -> supprimé
@ -243,7 +245,7 @@ class JuryPE(object):
# Méthodes pour la synthèse du juryPE
# *****************************************************************************************************************
def synthetise_juryPE(self):
"""Synthétise tous les résultats du jury PE dans un dictionnaire"""
"""Synthétise tous les résultats du jury PE dans des dataframess"""
self.syntheseJury = {}
for etudid in self.etudiants.get_etudids(self.diplome):
etudinfo = self.ETUDINFO_DICT[etudid]
@ -663,9 +665,11 @@ def compute_semestres_tag(etudiants: EtudiantsJuryPE):
return semestres_tags
def compute_trajectoires_tag(trajectoires: TrajectoiresJuryPE,
def compute_trajectoires_tag(
trajectoires: TrajectoiresJuryPE,
etudiants: EtudiantsJuryPE,
semestres_taggues: dict[int, SemestreTag]):
semestres_taggues: dict[int, SemestreTag],
):
"""Créée les trajectoires tagguées (combinaison aggrégeant plusieurs semestres au sens
d'un aggrégat (par ex: '3S')),
en calculant les moyennes et les classements par tag pour chacune.
@ -694,14 +698,14 @@ def compute_trajectoires_tag(trajectoires: TrajectoiresJuryPE,
trajectoires_tagguees = {}
for trajectoire_id in trajectoires_tagguees:
trajectoire = trajectoires[trajectoire_id]
for trajectoire_id in trajectoires.trajectoires:
trajectoire = trajectoires.trajectoires[trajectoire_id]
nom = trajectoire.get_repr()
pe_tools.pe_print(f" --> Fusion {nom}")
"""Création de la trajectoire_tagguee associée"""
trajectoire_tagguee = pe_trajectoiretag.TrajectoireTag(
trajectoire_tagguee = TrajectoireTag(
nom, trajectoire, semestres_taggues, etudiants
)
@ -711,33 +715,22 @@ def compute_trajectoires_tag(trajectoires: TrajectoiresJuryPE,
return trajectoires_tagguees
def compute_interclassements(
etudiants: EtudiantsJuryPE, aggregats_taggues: dict[str, dict]
etudiants: EtudiantsJuryPE,
trajectoires_jury_pe: TrajectoiresJuryPE,
trajectoires_tagguees: dict[tuple, Trajectoire],
):
"""Interclasse les étudiants, (nom d') aggrégat par aggrégat,
pour fournir un classement sur la promo. Le classement est établit au regard du nombre
pour fournir un classement sur la promo. Le classement est établi au regard du nombre
d'étudiants ayant participé au même aggrégat.
"""
etudiants_diplomes = etudiants.get_etudiants_diplomes()
pe_tools.pe_print(" Interclassement sur la promo")
"""
for i, nom in enumerate(pe_tools.PARCOURS.keys()):
settag = app.pe.pe_settag_interclasse.SetTagInterClasse(nom, diplome=diplome)
nbreEtudInscrits = settag.set_Etudiants(
lesEtudids, self.etudiants.cursus, self.etudiants.identites
aggregats_interclasses_taggues = {}
for nom_aggregat in pe_tools.TOUS_LES_SEMESTRES + pe_tools.TOUS_LES_AGGREGATS:
pe_tools.pe_print(f" --> {nom_aggregat}")
interclass = AggregatInterclasseTag(
nom_aggregat, etudiants, trajectoires_jury_pe, trajectoires_tagguees
)
if nbreEtudInscrits > 0:
pe_tools.pe_print("%d) %s avec interclassement sur la promo" % (i + 1, nom))
if nom in pe_tools.TOUS_LES_SEMESTRES:
settag.set_SetTagDict(self.semestres_taggues)
else: # cas des aggrégats
settag.set_SetTagDict(self.aggregats_taggues[nom])
settag.comp_data_settag()
self.promoTagDict[nom] = settag
else:
pe_tools.pe_print(
"%d) Pas d'interclassement %s sur la promo faute de notes"
% (i + 1, nom)
)
"""
aggregats_interclasses_taggues[nom_aggregat] = interclass
return aggregats_interclasses_taggues

3
app/pe/pe_trajectoire.py
View File

@ -91,7 +91,8 @@ class TrajectoiresJuryPE:
for etudid in etudiants.cursus:
if etudid not in self.suivi:
self.suivi[etudid] = {}
self.suivi[etudid] = {aggregat: None
for aggregat in pe_tools.TOUS_LES_SEMESTRES + pe_tools.TOUS_LES_AGGREGATS}
"""Le formsemestre terminal (dernier en date) associé au
semestre marquant la fin de l'aggrégat

5
app/pe/pe_trajectoiretag.py
View File

@ -122,6 +122,11 @@ class TrajectoireTag(pe_tagtable.TableTag):
"nb_inscrits": len(moy_gen_tag),
}
def get_repr(self):
"""Renvoie une représentation textuelle (celle de la trajectoire sur laquelle elle
est basée)"""
return self.trajectoire.get_repr()
def compute_notes_cube(self):
"""Construit le cube de notes (etudid x tags x semestre_aggregé)
nécessaire au calcul des moyennes de l'aggrégat