forked from ScoDoc/ScoDoc
Reformattage code avec Black
This commit is contained in:
parent
01d0f7d651
commit
df20372abb
@ -67,8 +67,7 @@ def get_code_latex_from_modele(fichier):
|
||||
|
||||
|
||||
# ----------------------------------------------------------------------------------------
|
||||
def get_code_latex_from_scodoc_preference(formsemestre_id,
|
||||
champ="pe_avis_latex_tmpl"):
|
||||
def get_code_latex_from_scodoc_preference(formsemestre_id, champ="pe_avis_latex_tmpl"):
|
||||
"""
|
||||
Extrait le template (ou le tag d'annotation au regard du champ fourni) des préférences LaTeX
|
||||
et s'assure qu'il est renvoyé au format unicode
|
||||
@ -95,9 +94,7 @@ def get_tags_latex(code_latex):
|
||||
return []
|
||||
|
||||
|
||||
def comp_latex_parcourstimeline(etudiant,
|
||||
promo,
|
||||
taille=17):
|
||||
def comp_latex_parcourstimeline(etudiant, promo, taille=17):
|
||||
"""Interprète un tag dans un avis latex **parcourstimeline**
|
||||
et génère le code latex permettant de retracer le parcours d'un étudiant
|
||||
sous la forme d'une frise temporelle.
|
||||
@ -159,11 +156,9 @@ def interprete_tag_latex(tag):
|
||||
|
||||
|
||||
# ----------------------------------------------------------------------------------------
|
||||
def get_code_latex_avis_etudiant(donnees_etudiant,
|
||||
un_avis_latex,
|
||||
annotationPE,
|
||||
footer_latex,
|
||||
prefs):
|
||||
def get_code_latex_avis_etudiant(
|
||||
donnees_etudiant, un_avis_latex, annotationPE, footer_latex, prefs
|
||||
):
|
||||
"""
|
||||
Renvoie le code latex permettant de générer l'avis d'un étudiant en utilisant ses
|
||||
donnees_etudiant contenu dans le dictionnaire de synthèse du jury PE et en suivant un
|
||||
@ -225,8 +220,7 @@ def get_code_latex_avis_etudiant(donnees_etudiant,
|
||||
|
||||
|
||||
# ----------------------------------------------------------------------------------------
|
||||
def get_annotation_PE(etudid,
|
||||
tag_annotation_pe):
|
||||
def get_annotation_PE(etudid, tag_annotation_pe):
|
||||
"""Renvoie l'annotation PE dans la liste de ces annotations ;
|
||||
Cette annotation est reconnue par la présence d'un tag **PE**
|
||||
(cf. .get_preferences -> pe_tag_annotation_avis_latex).
|
||||
@ -267,11 +261,7 @@ def get_annotation_PE(etudid,
|
||||
|
||||
|
||||
# ----------------------------------------------------------------------------------------
|
||||
def str_from_syntheseJury(donnees_etudiant,
|
||||
aggregat,
|
||||
groupe,
|
||||
tag_scodoc,
|
||||
champ):
|
||||
def str_from_syntheseJury(donnees_etudiant, aggregat, groupe, tag_scodoc, champ):
|
||||
"""Extrait du dictionnaire de synthèse du juryPE pour un étudiant donnée,
|
||||
une valeur indiquée par un champ ;
|
||||
si champ est une liste, renvoie la liste des valeurs extraites.
|
||||
@ -322,8 +312,7 @@ def str_from_syntheseJury(donnees_etudiant,
|
||||
|
||||
|
||||
# ----------------------------------------------------------------------------------------
|
||||
def get_bilanParTag(donnees_etudiant,
|
||||
groupe="groupe"):
|
||||
def get_bilanParTag(donnees_etudiant, groupe="groupe"):
|
||||
"""Renvoie le code latex d'un tableau récapitulant, pour tous les tags trouvés dans
|
||||
les données étudiants, ses résultats.
|
||||
result: chaine unicode
|
||||
@ -394,12 +383,7 @@ def get_bilanParTag(donnees_etudiant,
|
||||
|
||||
# ----------------------------------------------------------------------------------------
|
||||
def get_avis_poursuite_par_etudiant(
|
||||
jury,
|
||||
etudid,
|
||||
template_latex,
|
||||
tag_annotation_pe,
|
||||
footer_latex,
|
||||
prefs
|
||||
jury, etudid, template_latex, tag_annotation_pe, footer_latex, prefs
|
||||
):
|
||||
"""Renvoie un nom de fichier et le contenu de l'avis latex d'un étudiant dont l'etudid est fourni.
|
||||
result: [ chaine unicode, chaine unicode ]
|
||||
@ -460,8 +444,7 @@ def get_templates_from_distrib(template="avis"):
|
||||
|
||||
|
||||
# ----------------------------------------------------------------------------------------
|
||||
def table_syntheseAnnotationPE(syntheseJury,
|
||||
tag_annotation_pe):
|
||||
def table_syntheseAnnotationPE(syntheseJury, tag_annotation_pe):
|
||||
"""Génère un fichier excel synthétisant les annotations PE telles qu'inscrites dans les fiches de chaque étudiant"""
|
||||
sT = SeqGenTable() # le fichier excel à générer
|
||||
|
||||
|
||||
@ -175,19 +175,17 @@ class JuryPE(object):
|
||||
"affichage_court": "BUT",
|
||||
"affichage_long": "BUT (tout semestre inclus)",
|
||||
},
|
||||
|
||||
}
|
||||
|
||||
AGGREGAT_DIPLOMANT = "6S" # aggrégat correspondant à la totalité des notes pour le diplôme
|
||||
AGGREGAT_DIPLOMANT = (
|
||||
"6S" # aggrégat correspondant à la totalité des notes pour le diplôme
|
||||
)
|
||||
TOUS_LES_SEMESTRES = PARCOURS["6S"]["aggregat"]
|
||||
TOUS_LES_AGGREGATS = [cle for cle in PARCOURS.keys() if not cle.startswith("S")]
|
||||
TOUS_LES_PARCOURS = list(PARCOURS.keys())
|
||||
|
||||
# ------------------------------------------------------------------------------------------------------------------
|
||||
def __init__(self,
|
||||
sem_base: FormSemestre,
|
||||
semBase # CB: à supprimer à long terme
|
||||
):
|
||||
def __init__(self, sem_base: FormSemestre, semBase): # CB: à supprimer à long terme
|
||||
"""
|
||||
Création d'une table PE sur la base d'un semestre selectionné. De ce semestre est déduit :
|
||||
1. l'année d'obtention du DUT,
|
||||
@ -312,9 +310,7 @@ class JuryPE(object):
|
||||
# **************************************************************************************************************** #
|
||||
|
||||
# ------------------------------------------------------------------------------------------------------------------
|
||||
def get_etudiants_in_jury(self,
|
||||
semBase,
|
||||
avec_meme_formation=False):
|
||||
def get_etudiants_in_jury(self, semBase, avec_meme_formation=False):
|
||||
"""
|
||||
Calcule la liste des étudiants à prendre en compte dans le jury et la renvoie sous la forme
|
||||
"""
|
||||
@ -360,17 +356,16 @@ class JuryPE(object):
|
||||
# ------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
# ------------------------------------------------------------------------------------------------------------------
|
||||
def get_etudiants_dans_semestres(self,
|
||||
semsListe):
|
||||
def get_etudiants_dans_semestres(self, semsListe):
|
||||
"""Renvoie la liste des etudid des etudiants inscrits à l'un des semestres de la liste fournie en paramètre
|
||||
en supprimant les doublons (i.e. un même étudiant qui apparaîtra 2 fois)"""
|
||||
|
||||
etudiants = []
|
||||
for sem in semsListe: # pour chacun des semestres de la liste
|
||||
nt = self.get_cache_notes_d_un_semestre(sem["formsemestre_id"])
|
||||
etudiantsDuSemestre = (
|
||||
[ins.etudid for ins in nt.formsemestre.inscriptions] # nt.get_etudids()
|
||||
) # identification des etudiants du semestre
|
||||
etudiantsDuSemestre = [
|
||||
ins.etudid for ins in nt.formsemestre.inscriptions
|
||||
] # nt.get_etudids() # identification des etudiants du semestre
|
||||
|
||||
if pe_tools.PE_DEBUG:
|
||||
pe_tools.pe_print(
|
||||
@ -382,8 +377,7 @@ class JuryPE(object):
|
||||
return list(set(etudiants)) # suppression des doublons
|
||||
|
||||
# ------------------------------------------------------------------------------------------------------------------
|
||||
def get_etudids_du_jury(self,
|
||||
ordre="aucun"):
|
||||
def get_etudids_du_jury(self, ordre="aucun"):
|
||||
"""Renvoie la liste de tous les étudiants (concrètement leur etudid)
|
||||
participant au jury c'est-à-dire, ceux dont la date du 'jury' est self.diplome
|
||||
et n'ayant pas abandonné.
|
||||
@ -407,8 +401,7 @@ class JuryPE(object):
|
||||
# ------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
# ------------------------------------------------------------------------------------------------------------------
|
||||
def add_etudiants(self,
|
||||
etudid):
|
||||
def add_etudiants(self, etudid):
|
||||
"""Ajoute un étudiant connaissant son etudid au dictionnaire de synthèse jurydict.
|
||||
L'ajout consiste à :
|
||||
* insérer une entrée pour l'étudiant en mémorisant ses infos (get_etudInfo),
|
||||
@ -473,7 +466,9 @@ class JuryPE(object):
|
||||
|
||||
# Quelles sont ses années validantes ('1A', '2A') et ses parcours (3S, 4S) validants ?
|
||||
for parcours in JuryPE.TOUS_LES_AGGREGATS:
|
||||
lesSemsDuParcours = JuryPE.PARCOURS[parcours]["aggregat"] # les semestres du parcours : par ex. ['S1', 'S2', 'S3']
|
||||
lesSemsDuParcours = JuryPE.PARCOURS[parcours][
|
||||
"aggregat"
|
||||
] # les semestres du parcours : par ex. ['S1', 'S2', 'S3']
|
||||
lesFidsValidantDuParcours = [
|
||||
sesFormsemestre_idValidants[
|
||||
JuryPE.TOUS_LES_SEMESTRES.index(nom_sem)
|
||||
@ -500,8 +495,7 @@ class JuryPE(object):
|
||||
# print
|
||||
|
||||
# ------------------------------------------------------------------------------------------------------------------
|
||||
def est_un_etudiant_reoriente_ou_demissionnaire(self,
|
||||
etudid):
|
||||
def est_un_etudiant_reoriente_ou_demissionnaire(self, etudid):
|
||||
"""Renvoie True si l'étudiant est réorienté (NAR) ou démissionnaire (DEM)"""
|
||||
from app.scodoc import sco_report
|
||||
|
||||
@ -521,8 +515,7 @@ class JuryPE(object):
|
||||
return reponse
|
||||
|
||||
# ------------------------------------------------------------------------------------------------------------------
|
||||
def est_un_etudiant_disparu(self,
|
||||
etudid):
|
||||
def est_un_etudiant_disparu(self, etudid):
|
||||
"""Renvoie True si l'étudiant n'a pas achevé la formation à l'IUT et a disparu des listes, sans
|
||||
pour autant avoir été indiqué NAR ou DEM ; recherche son dernier semestre validé et regarde s'il
|
||||
n'existe pas parmi les semestres existants dans scodoc un semestre postérieur (en terme de date de
|
||||
@ -572,8 +565,7 @@ class JuryPE(object):
|
||||
# ------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
# ------------------------------------------------------------------------------------------------------------------
|
||||
def get_dernier_semestre_id_valide_d_un_etudiant(self,
|
||||
etudid):
|
||||
def get_dernier_semestre_id_valide_d_un_etudiant(self, etudid):
|
||||
"""Renvoie le n° (semestre_id) du dernier semestre validé par un étudiant fourni par son etudid
|
||||
et None si aucun semestre n'a été validé
|
||||
"""
|
||||
@ -596,9 +588,7 @@ class JuryPE(object):
|
||||
# ------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
# ------------------------------------------------------------------------------------------------------------------
|
||||
def get_Fid_d_un_Si_valide_d_un_etudiant(self,
|
||||
etudid,
|
||||
nom_semestre):
|
||||
def get_Fid_d_un_Si_valide_d_un_etudiant(self, etudid, nom_semestre):
|
||||
"""Récupère le formsemestre_id valide d'un étudiant fourni son etudid à un semestre DUT de n° semestre_id
|
||||
donné. Si le semestre est en cours (pas encore de jury), renvoie le formsemestre_id actuel.
|
||||
"""
|
||||
@ -636,8 +626,7 @@ class JuryPE(object):
|
||||
Calcule les moyennes et les classements de chaque semestre par tag et les statistiques de ces semestres.
|
||||
"""
|
||||
lesFids = self.get_formsemestreids_du_jury(
|
||||
self.get_etudids_du_jury(),
|
||||
liste_semestres=JuryPE.TOUS_LES_SEMESTRES
|
||||
self.get_etudids_du_jury(), liste_semestres=JuryPE.TOUS_LES_SEMESTRES
|
||||
)
|
||||
for i, fid in enumerate(lesFids):
|
||||
if pe_tools.PE_DEBUG:
|
||||
@ -648,8 +637,7 @@ class JuryPE(object):
|
||||
self.add_semtags_in_jury(fid)
|
||||
|
||||
# ------------------------------------------------------------------------------------------------------------------
|
||||
def add_semtags_in_jury(self,
|
||||
fid):
|
||||
def add_semtags_in_jury(self, fid):
|
||||
"""Crée si nécessaire un semtag et le mémorise dans self.semTag ;
|
||||
charge également les données des nouveaux étudiants qui en font partis.
|
||||
"""
|
||||
@ -696,9 +684,7 @@ class JuryPE(object):
|
||||
self.zipfile.writestr(filename, self.semTagDict[fid].str_tagtable())
|
||||
|
||||
# ----------------------------------------------------------------------------------------------------------------
|
||||
def get_formsemestreids_du_jury(self,
|
||||
etudids,
|
||||
liste_semestres="6S"):
|
||||
def get_formsemestreids_du_jury(self, etudids, liste_semestres="6S"):
|
||||
"""Renvoie la liste des formsemestre_id validants des étudiants en parcourant les semestres valides des étudiants mémorisés dans
|
||||
self.PARCOURSINFO_DICT.
|
||||
Les étudiants sont identifiés par leur etudic donnés dans la liste etudids (généralement self.get_etudids_in_jury() ).
|
||||
@ -926,8 +912,7 @@ class JuryPE(object):
|
||||
tag
|
||||
] = tagtable.get_resultatsEtud(tag, etudid)
|
||||
|
||||
def get_dateEntree(self,
|
||||
etudid):
|
||||
def get_dateEntree(self, etudid):
|
||||
"""Renvoie l'année d'entrée de l'étudiant à l'IUT"""
|
||||
# etudinfo = self.ETUDINFO_DICT[etudid]
|
||||
semestres = self.get_semestresBUT_d_un_etudiant(etudid)
|
||||
@ -937,8 +922,7 @@ class JuryPE(object):
|
||||
else:
|
||||
return ""
|
||||
|
||||
def get_parcoursIUT(self,
|
||||
etudid):
|
||||
def get_parcoursIUT(self, etudid):
|
||||
"""Renvoie une liste d'infos sur les semestres du parcours d'un étudiant"""
|
||||
# etudinfo = self.ETUDINFO_DICT[etudid]
|
||||
sems = self.get_semestresBUT_d_un_etudiant(etudid)
|
||||
@ -958,8 +942,7 @@ class JuryPE(object):
|
||||
# **************************************************************************************************************** #
|
||||
# Méthodes d'affichage pour debug
|
||||
# **************************************************************************************************************** #
|
||||
def str_etudiants_in_jury(self,
|
||||
delim=";"):
|
||||
def str_etudiants_in_jury(self, delim=";"):
|
||||
# En tete:
|
||||
entete = ["Id", "Nom", "Abandon", "Diplome"]
|
||||
for nom_sem in JuryPE.TOUS_LES_PARCOURS:
|
||||
@ -1022,8 +1005,7 @@ class JuryPE(object):
|
||||
allTags = allTags.union(set(self.get_allTagForAggregat(nom)))
|
||||
return sorted(list(allTags)) if len(allTags) > 0 else []
|
||||
|
||||
def table_syntheseJury(self,
|
||||
mode="singlesheet"): # was str_syntheseJury
|
||||
def table_syntheseJury(self, mode="singlesheet"): # was str_syntheseJury
|
||||
"""Table(s) du jury
|
||||
mode: singlesheet ou multiplesheet pour export excel
|
||||
"""
|
||||
@ -1086,7 +1068,11 @@ class JuryPE(object):
|
||||
entete.extend(["%s %s" % (sem, champ) for champ in champs])
|
||||
else: # "singlesheet"
|
||||
allSheets = ["singlesheet"]
|
||||
for sem in JuryPE.TOUS_LES_PARCOURS: # JuryPE.PARCOURS.keys() -> ['S1', 'S2', ..., '1A', '4S']
|
||||
for (
|
||||
sem
|
||||
) in (
|
||||
JuryPE.TOUS_LES_PARCOURS
|
||||
): # JuryPE.PARCOURS.keys() -> ['S1', 'S2', ..., '1A', '4S']
|
||||
tags = self.get_allTagForAggregat(sem)
|
||||
entete.extend(
|
||||
["%s %s %s" % (sem, tag, champ) for tag in tags for champ in champs]
|
||||
@ -1146,17 +1132,15 @@ class JuryPE(object):
|
||||
row[champ + "note"] = scu.fmt_note(resgroupe[0])
|
||||
row[champ + "class groupe"] = "%s / %s" % (
|
||||
resgroupe[2] if resgroupe[2] else "-",
|
||||
resgroupe[3] if resgroupe[3] else "-"
|
||||
resgroupe[3] if resgroupe[3] else "-",
|
||||
)
|
||||
row[champ + "class promo"] = "%s / %s" % (
|
||||
respromo[2] if respromo[2] else "-",
|
||||
respromo[3] if respromo[3] else "-"
|
||||
respromo[3] if respromo[3] else "-",
|
||||
)
|
||||
row[champ + "min/moy/max groupe"] = "%s / %s / %s" % tuple(
|
||||
(scu.fmt_note(x) if x is not None else "-")
|
||||
for x in (resgroupe[6],
|
||||
resgroupe[4],
|
||||
resgroupe[5])
|
||||
for x in (resgroupe[6], resgroupe[4], resgroupe[5])
|
||||
)
|
||||
row[champ + "min/moy/max promo"] = "%s / %s / %s" % tuple(
|
||||
(scu.fmt_note(x) if x is not None else "-")
|
||||
@ -1183,8 +1167,7 @@ class JuryPE(object):
|
||||
# **************************************************************************************************************** #
|
||||
|
||||
# ------------------------------------------------------------------------------------------------------------------
|
||||
def get_cache_etudInfo_d_un_etudiant(self,
|
||||
etudid):
|
||||
def get_cache_etudInfo_d_un_etudiant(self, etudid):
|
||||
"""Renvoie les informations sur le parcours d'un étudiant soit en les relisant depuis
|
||||
ETUDINFO_DICT si mémorisée soit en les chargeant et en les mémorisant
|
||||
"""
|
||||
@ -1197,8 +1180,7 @@ class JuryPE(object):
|
||||
# ------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
# ------------------------------------------------------------------------------------------------------------------
|
||||
def get_cache_notes_d_un_semestre(self,
|
||||
formsemestre_id: int) -> NotesTableCompat:
|
||||
def get_cache_notes_d_un_semestre(self, formsemestre_id: int) -> NotesTableCompat:
|
||||
"""Charge la table des notes d'un formsemestre"""
|
||||
formsemestre = FormSemestre.get_formsemestre(formsemestre_id)
|
||||
return res_sem.load_formsemestre_results(formsemestre)
|
||||
@ -1206,25 +1188,24 @@ class JuryPE(object):
|
||||
# ------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
# ------------------------------------------------------------------------------------------------------------------
|
||||
def get_semestresBUT_d_un_etudiant(self,
|
||||
etudid,
|
||||
semestre_id=None):
|
||||
def get_semestresBUT_d_un_etudiant(self, etudid, semestre_id=None):
|
||||
"""Renvoie la liste des semestres DUT d'un étudiant
|
||||
pour un semestre_id (parmi 1,2,3,4) donné
|
||||
en fonction de ses infos d'etud (cf. sco_etud.get_etud_info( etudid=etudid, filled=True)[0]),
|
||||
les semestres étant triés par ordre décroissant.
|
||||
Si semestre_id == None renvoie tous les semestres"""
|
||||
etud = self.get_cache_etudInfo_d_un_etudiant(etudid)
|
||||
nbre_semestres = int(JuryPE.AGGREGAT_DIPLOMANT[0]) # 6
|
||||
nbre_semestres = int(JuryPE.AGGREGAT_DIPLOMANT[0]) # 6
|
||||
if semestre_id == None:
|
||||
sesSems = [sem for sem in etud["sems"] if 1 <= sem["semestre_id"] <= nbre_semestres]
|
||||
sesSems = [
|
||||
sem for sem in etud["sems"] if 1 <= sem["semestre_id"] <= nbre_semestres
|
||||
]
|
||||
else:
|
||||
sesSems = [sem for sem in etud["sems"] if sem["semestre_id"] == semestre_id]
|
||||
return sesSems
|
||||
|
||||
# **********************************************
|
||||
def calcul_anneePromoBUT_d_un_etudiant(self,
|
||||
etudid) -> int:
|
||||
def calcul_anneePromoBUT_d_un_etudiant(self, etudid) -> int:
|
||||
"""Calcule et renvoie la date de diplome prévue pour un étudiant fourni avec son etudid
|
||||
en fonction de ses semestres de scolarisation"""
|
||||
semestres = self.get_semestresBUT_d_un_etudiant(etudid)
|
||||
@ -1235,8 +1216,7 @@ class JuryPE(object):
|
||||
|
||||
# *********************************************
|
||||
# Fonctions d'affichage pour debug
|
||||
def get_resultat_d_un_etudiant(self,
|
||||
etudid):
|
||||
def get_resultat_d_un_etudiant(self, etudid):
|
||||
chaine = ""
|
||||
for nom_sem in JuryPE.TOUS_LES_SEMESTRES:
|
||||
semtagid = self.PARCOURSINFO_DICT[etudid][
|
||||
@ -1303,7 +1283,7 @@ def get_annee_diplome_semestre(sem) -> int:
|
||||
Args:
|
||||
sem: Le semestre
|
||||
"""
|
||||
nbre_semestres = int(JuryPE.AGGREGAT_DIPLOMANT[0]) # 6
|
||||
nbre_semestres = int(JuryPE.AGGREGAT_DIPLOMANT[0]) # 6
|
||||
if (
|
||||
1 <= sem["semestre_id"] <= nbre_semestres
|
||||
): # Si le semestre est un semestre BUT => problème si formation BUT en 1 an ??
|
||||
@ -1319,8 +1299,7 @@ def get_annee_diplome_semestre(sem) -> int:
|
||||
|
||||
|
||||
# ----------------------------------------------------------------------------------
|
||||
def get_cosemestres_diplomants(semBase,
|
||||
avec_meme_formation=False):
|
||||
def get_cosemestres_diplomants(semBase, avec_meme_formation=False):
|
||||
"""Partant d'un semestre de Base = {'formsemestre_id': ..., 'semestre_id': ..., 'annee_debut': ...},
|
||||
renvoie la liste de tous ses co-semestres (lui-meme inclus)
|
||||
Par co-semestre, s'entend les semestres :
|
||||
|
||||
@ -78,9 +78,7 @@ class SemestreTag(pe_tagtable.TableTag):
|
||||
# -----------------------------------------------------------------------------
|
||||
# Fonctions d'initialisation
|
||||
# -----------------------------------------------------------------------------
|
||||
def __init__(self,
|
||||
notetable,
|
||||
sem): # Initialisation sur la base d'une notetable
|
||||
def __init__(self, notetable, sem): # Initialisation sur la base d'une notetable
|
||||
"""Instantiation d'un objet SemestreTag à partir d'un tableau de note
|
||||
et des informations sur le semestre pour le dater
|
||||
"""
|
||||
@ -168,7 +166,7 @@ class SemestreTag(pe_tagtable.TableTag):
|
||||
"""
|
||||
tagdict = {}
|
||||
|
||||
for modimpl in []: # CB: désactive la recherche des tags -> self.modimpls:
|
||||
for modimpl in []: # CB: désactive la recherche des tags -> self.modimpls:
|
||||
modimpl_id = modimpl.id
|
||||
# liste des tags pour le modimpl concerné:
|
||||
tags = sco_tag_module.module_tag_list(modimpl.module.id)
|
||||
@ -196,9 +194,7 @@ class SemestreTag(pe_tagtable.TableTag):
|
||||
return tagdict
|
||||
|
||||
# -----------------------------------------------------------------------------
|
||||
def comp_MoyennesTag(self,
|
||||
tag,
|
||||
force=False) -> list:
|
||||
def comp_MoyennesTag(self, tag, force=False) -> list:
|
||||
"""Calcule et renvoie les "moyennes" de tous les étudiants du SemTag
|
||||
(non défaillants) à un tag donné, en prenant en compte
|
||||
tous les modimpl_id concerné par le tag, leur coeff et leur pondération.
|
||||
@ -236,10 +232,7 @@ class SemestreTag(pe_tagtable.TableTag):
|
||||
]
|
||||
|
||||
# -----------------------------------------------------------------------------
|
||||
def get_noteEtCoeff_modimpl(self,
|
||||
modimpl_id,
|
||||
etudid,
|
||||
profondeur=2):
|
||||
def get_noteEtCoeff_modimpl(self, modimpl_id, etudid, profondeur=2):
|
||||
"""Renvoie un couple donnant la note et le coeff normalisé d'un étudiant à un module d'id modimpl_id.
|
||||
La note et le coeff sont extraits :
|
||||
1) soit des données du semestre en normalisant le coefficient par rapport à la somme des coefficients des modules du semestre,
|
||||
@ -320,17 +313,14 @@ class SemestreTag(pe_tagtable.TableTag):
|
||||
return (note, coeff_norm)
|
||||
|
||||
# -----------------------------------------------------------------------------
|
||||
def get_ue_capitalisees(self,
|
||||
etudid) -> list[dict]:
|
||||
def get_ue_capitalisees(self, etudid) -> list[dict]:
|
||||
"""Renvoie la liste des capitalisation effectivement capitalisées par un étudiant"""
|
||||
if etudid in self.nt.validations.ue_capitalisees.index:
|
||||
return self.nt.validations.ue_capitalisees.loc[[etudid]].to_dict("records")
|
||||
return []
|
||||
|
||||
# -----------------------------------------------------------------------------
|
||||
def get_listesNotesEtCoeffsTagEtudiant(self,
|
||||
tag,
|
||||
etudid):
|
||||
def get_listesNotesEtCoeffsTagEtudiant(self, tag, etudid):
|
||||
"""Renvoie un triplet (notes, coeffs_norm, ponderations) où notes, coeff_norm et ponderation désignent trois listes
|
||||
donnant -pour un tag donné- les note, coeff et ponderation de chaque modimpl à prendre en compte dans
|
||||
le calcul de la moyenne du tag.
|
||||
@ -353,10 +343,7 @@ class SemestreTag(pe_tagtable.TableTag):
|
||||
# -----------------------------------------------------------------------------
|
||||
# Fonctions d'affichage (et d'export csv) des données du semestre en mode debug
|
||||
# -----------------------------------------------------------------------------
|
||||
def str_detail_resultat_d_un_tag(self,
|
||||
tag,
|
||||
etudid=None,
|
||||
delim=";"):
|
||||
def str_detail_resultat_d_un_tag(self, tag, etudid=None, delim=";"):
|
||||
"""Renvoie une chaine de caractère décrivant les résultats d'étudiants à un tag :
|
||||
rappelle les notes obtenues dans les modules à prendre en compte, les moyennes et les rangs calculés.
|
||||
Si etudid=None, tous les étudiants inscrits dans le semestre sont pris en compte. Sinon seuls les étudiants indiqués sont affichés.
|
||||
@ -476,8 +463,7 @@ class SemestreTag(pe_tagtable.TableTag):
|
||||
|
||||
|
||||
# *********************************************
|
||||
def comp_coeff_pond(coeffs,
|
||||
ponderations):
|
||||
def comp_coeff_pond(coeffs, ponderations):
|
||||
"""
|
||||
Applique une ponderation (indiquée dans la liste ponderations) à une liste de coefficients :
|
||||
ex: coeff = [2, 3, 1, None], ponderation = [1, 2, 0, 1] => [2*1, 3*2, 1*0, None]
|
||||
@ -513,9 +499,7 @@ def get_moduleimpl(modimpl_id) -> dict:
|
||||
|
||||
|
||||
# **********************************************
|
||||
def get_moy_ue_from_nt(nt,
|
||||
etudid,
|
||||
modimpl_id) -> float:
|
||||
def get_moy_ue_from_nt(nt, etudid, modimpl_id) -> float:
|
||||
"""Renvoie la moyenne de l'UE d'un etudid dans laquelle se trouve
|
||||
le module de modimpl_id
|
||||
"""
|
||||
|
||||
@ -51,19 +51,15 @@ class SetTag(pe_tagtable.TableTag):
|
||||
"""
|
||||
|
||||
# -------------------------------------------------------------------------------------------------------------------
|
||||
def __init__(self,
|
||||
nom_combinaison,
|
||||
parcours):
|
||||
def __init__(self, nom_combinaison, parcours):
|
||||
pe_tagtable.TableTag.__init__(self, nom=nom_combinaison)
|
||||
self.combinaison = nom_combinaison
|
||||
self.parcours = parcours # Le groupe de semestres/parcours à aggréger
|
||||
|
||||
# -------------------------------------------------------------------------------------------
|
||||
def set_Etudiants(self,
|
||||
etudiants: list[dict],
|
||||
juryPEDict,
|
||||
etudInfoDict,
|
||||
nom_sem_final=None):
|
||||
def set_Etudiants(
|
||||
self, etudiants: list[dict], juryPEDict, etudInfoDict, nom_sem_final=None
|
||||
):
|
||||
"""Détermine la liste des étudiants à prendre en compte, en partant de
|
||||
la liste en paramètre et en vérifiant qu'ils ont tous un parcours valide."""
|
||||
if nom_sem_final:
|
||||
@ -98,8 +94,7 @@ class SetTag(pe_tagtable.TableTag):
|
||||
)
|
||||
|
||||
# ---------------------------------------------------------------------------------------------
|
||||
def set_SemTagDict(self,
|
||||
SemTagDict):
|
||||
def set_SemTagDict(self, SemTagDict):
|
||||
"""Mémorise les semtag nécessaires au jury."""
|
||||
self.SemTagDict = {fid: SemTagDict[fid] for fid in self.get_Fids_in_settag()}
|
||||
if PE_DEBUG >= 1:
|
||||
@ -157,9 +152,7 @@ class SetTag(pe_tagtable.TableTag):
|
||||
self.tagdict[tag][mod] = semtag.tagdict[tag][mod]
|
||||
|
||||
# -------------------------------------------------------------------------------------------------------------------
|
||||
def get_NotesEtCoeffsSetTagEtudiant(self,
|
||||
tag,
|
||||
etudid):
|
||||
def get_NotesEtCoeffsSetTagEtudiant(self, tag, etudid):
|
||||
"""Récupère tous les notes et les coeffs d'un étudiant relatives à un tag dans ses semestres valides et les renvoie dans un tuple (notes, coeffs)
|
||||
avec notes et coeffs deux listes"""
|
||||
lesSemsDeLEtudiant = [
|
||||
@ -179,9 +172,7 @@ class SetTag(pe_tagtable.TableTag):
|
||||
return (notes, coeffs)
|
||||
|
||||
# -------------------------------------------------------------------------------------------------------------------
|
||||
def comp_MoyennesSetTag(self,
|
||||
tag,
|
||||
force=False):
|
||||
def comp_MoyennesSetTag(self, tag, force=False):
|
||||
"""Calcule et renvoie les "moyennes" des étudiants à un tag donné, en prenant en compte tous les semestres taggués
|
||||
de l'aggrégat, et leur coeff Par moyenne, s'entend une note moyenne, la somme des coefficients de pondération
|
||||
appliqué dans cette moyenne.
|
||||
@ -218,19 +209,13 @@ class SetTagInterClasse(pe_tagtable.TableTag):
|
||||
"""
|
||||
|
||||
# -------------------------------------------------------------------------------------------------------------------
|
||||
def __init__(self,
|
||||
nom_combinaison,
|
||||
diplome):
|
||||
def __init__(self, nom_combinaison, diplome):
|
||||
pe_tagtable.TableTag.__init__(self, nom=f"{nom_combinaison}_{diplome or ''}")
|
||||
self.combinaison = nom_combinaison
|
||||
self.parcoursDict = {}
|
||||
|
||||
# -------------------------------------------------------------------------------------------
|
||||
def set_Etudiants(self,
|
||||
etudiants,
|
||||
juryPEDict,
|
||||
etudInfoDict,
|
||||
nom_sem_final=None):
|
||||
def set_Etudiants(self, etudiants, juryPEDict, etudInfoDict, nom_sem_final=None):
|
||||
"""Détermine la liste des étudiants à prendre en compte, en partant de
|
||||
la liste fournie en paramètre et en vérifiant que l'étudiant dispose bien d'un parcours valide pour la combinaison demandée.
|
||||
Renvoie le nombre d'étudiants effectivement inscrits."""
|
||||
@ -252,8 +237,7 @@ class SetTagInterClasse(pe_tagtable.TableTag):
|
||||
)
|
||||
|
||||
# ---------------------------------------------------------------------------------------------
|
||||
def set_SetTagDict(self,
|
||||
SetTagDict):
|
||||
def set_SetTagDict(self, SetTagDict):
|
||||
"""Mémorise les settag nécessaires au jury."""
|
||||
self.SetTagDict = {
|
||||
fid: SetTagDict[fid] for fid in self.get_Fids_in_settag() if fid != None
|
||||
@ -301,9 +285,7 @@ class SetTagInterClasse(pe_tagtable.TableTag):
|
||||
return sorted(list(set(ensemble)))
|
||||
|
||||
# -------------------------------------------------------------------------------------------------------------------
|
||||
def get_NotesEtCoeffsSetTagEtudiant(self,
|
||||
tag,
|
||||
etudid):
|
||||
def get_NotesEtCoeffsSetTagEtudiant(self, tag, etudid):
|
||||
"""Récupère tous les notes et les coeffs d'un étudiant relatives à un tag dans ses semestres valides et les renvoie dans un tuple (notes, coeffs)
|
||||
avec notes et coeffs deux listes"""
|
||||
leSetTagDeLetudiant = self.parcoursDict[etudid][self.combinaison]
|
||||
@ -315,9 +297,7 @@ class SetTagInterClasse(pe_tagtable.TableTag):
|
||||
return (note, coeff)
|
||||
|
||||
# -------------------------------------------------------------------------------------------------------------------
|
||||
def get_MoyennesSetTag(self,
|
||||
tag,
|
||||
force=False):
|
||||
def get_MoyennesSetTag(self, tag, force=False):
|
||||
"""Renvoie les "moyennes" des étudiants à un tag donné, en prenant en compte tous les settag de l'aggrégat,
|
||||
et leur coeff Par moyenne, s'entend une note moyenne, la somme des coefficients de pondération
|
||||
appliqué dans cette moyenne.
|
||||
|
||||
@ -77,9 +77,7 @@ class TableTag(object):
|
||||
# *****************************************************************************************************************
|
||||
|
||||
# -----------------------------------------------------------------------------------------------------------
|
||||
def get_moy_from_resultats(self,
|
||||
tag,
|
||||
etudid):
|
||||
def get_moy_from_resultats(self, tag, etudid):
|
||||
"""Renvoie la moyenne obtenue par un étudiant à un tag donné au regard du format de self.resultats"""
|
||||
return (
|
||||
self.resultats[tag][etudid][0]
|
||||
@ -88,9 +86,7 @@ class TableTag(object):
|
||||
)
|
||||
|
||||
# -----------------------------------------------------------------------------------------------------------
|
||||
def get_rang_from_resultats(self,
|
||||
tag,
|
||||
etudid):
|
||||
def get_rang_from_resultats(self, tag, etudid):
|
||||
"""Renvoie le rang à un tag d'un étudiant au regard du format de self.resultats"""
|
||||
return (
|
||||
self.rangs[tag][etudid]
|
||||
@ -99,9 +95,7 @@ class TableTag(object):
|
||||
)
|
||||
|
||||
# -----------------------------------------------------------------------------------------------------------
|
||||
def get_coeff_from_resultats(self,
|
||||
tag,
|
||||
etudid):
|
||||
def get_coeff_from_resultats(self, tag, etudid):
|
||||
"""Renvoie la somme des coeffs de pondération normalisée utilisés dans le calcul de la moyenne à un tag d'un étudiant
|
||||
au regard du format de self.resultats.
|
||||
"""
|
||||
@ -123,18 +117,15 @@ class TableTag(object):
|
||||
return len(self.inscrlist)
|
||||
|
||||
# -----------------------------------------------------------------------------------------------------------
|
||||
def get_moy_from_stats(self,
|
||||
tag):
|
||||
def get_moy_from_stats(self, tag):
|
||||
"""Renvoie la moyenne des notes calculées pour d'un tag donné"""
|
||||
return self.statistiques[tag][0] if tag in self.statistiques else None
|
||||
|
||||
def get_min_from_stats(self,
|
||||
tag):
|
||||
def get_min_from_stats(self, tag):
|
||||
"""Renvoie la plus basse des notes calculées pour d'un tag donné"""
|
||||
return self.statistiques[tag][1] if tag in self.statistiques else None
|
||||
|
||||
def get_max_from_stats(self,
|
||||
tag):
|
||||
def get_max_from_stats(self, tag):
|
||||
"""Renvoie la plus haute des notes calculées pour d'un tag donné"""
|
||||
return self.statistiques[tag][2] if tag in self.statistiques else None
|
||||
|
||||
@ -151,9 +142,7 @@ class TableTag(object):
|
||||
"min",
|
||||
)
|
||||
|
||||
def get_resultatsEtud(self,
|
||||
tag,
|
||||
etudid):
|
||||
def get_resultatsEtud(self, tag, etudid):
|
||||
"""Renvoie un tuple (note, coeff, rang, nb_inscrit, moy, min, max) synthétisant les résultats d'un étudiant
|
||||
à un tag donné. None sinon"""
|
||||
return (
|
||||
@ -175,9 +164,7 @@ class TableTag(object):
|
||||
# *****************************************************************************************************************
|
||||
|
||||
# -----------------------------------------------------------------------------------------------------------
|
||||
def add_moyennesTag(self,
|
||||
tag,
|
||||
listMoyEtCoeff) -> bool:
|
||||
def add_moyennesTag(self, tag, listMoyEtCoeff) -> bool:
|
||||
"""
|
||||
Mémorise les moyennes, les coeffs de pondération et les etudid dans resultats
|
||||
avec calcul du rang
|
||||
@ -210,8 +197,7 @@ class TableTag(object):
|
||||
# Méthodes dévolues aux calculs de statistiques (min, max, moy) sur chaque moyenne taguée
|
||||
# *****************************************************************************************************************
|
||||
|
||||
def comp_stats_d_un_tag(self,
|
||||
tag):
|
||||
def comp_stats_d_un_tag(self, tag):
|
||||
"""
|
||||
Calcule la moyenne generale, le min, le max pour un tag donné,
|
||||
en ne prenant en compte que les moyennes significatives. Mémorise le resultat dans
|
||||
@ -235,10 +221,7 @@ class TableTag(object):
|
||||
# ************************************************************************
|
||||
# Méthodes dévolues aux affichages -> a revoir
|
||||
# ************************************************************************
|
||||
def str_resTag_d_un_etudiant(self,
|
||||
tag,
|
||||
etudid,
|
||||
delim=";"):
|
||||
def str_resTag_d_un_etudiant(self, tag, etudid, delim=";"):
|
||||
"""Renvoie une chaine de caractères (valable pour un csv)
|
||||
décrivant la moyenne et le rang d'un étudiant, pour un tag donné ;
|
||||
"""
|
||||
@ -253,20 +236,14 @@ class TableTag(object):
|
||||
)
|
||||
return moystr
|
||||
|
||||
def str_res_d_un_etudiant(self,
|
||||
etudid,
|
||||
delim=";"):
|
||||
def str_res_d_un_etudiant(self, etudid, delim=";"):
|
||||
"""Renvoie sur une ligne les résultats d'un étudiant à tous les tags (par ordre alphabétique)."""
|
||||
return delim.join(
|
||||
[self.str_resTag_d_un_etudiant(tag, etudid) for tag in self.get_all_tags()]
|
||||
)
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
def str_moytag(cls,
|
||||
moyenne,
|
||||
rang,
|
||||
nbinscrit,
|
||||
delim=";"):
|
||||
def str_moytag(cls, moyenne, rang, nbinscrit, delim=";"):
|
||||
"""Renvoie une chaine de caractères représentant une moyenne (float ou string) et un rang
|
||||
pour différents formats d'affichage : HTML, debug ligne de commande, csv"""
|
||||
moystr = (
|
||||
@ -279,9 +256,7 @@ class TableTag(object):
|
||||
str_moytag = classmethod(str_moytag)
|
||||
# -----------------------------------------------------------------------
|
||||
|
||||
def str_tagtable(self,
|
||||
delim=";",
|
||||
decimal_sep=","):
|
||||
def str_tagtable(self, delim=";", decimal_sep=","):
|
||||
"""Renvoie une chaine de caractère listant toutes les moyennes, les rangs des étudiants pour tous les tags."""
|
||||
entete = ["etudid", "nom", "prenom"]
|
||||
for tag in self.get_all_tags():
|
||||
@ -313,9 +288,7 @@ class TableTag(object):
|
||||
|
||||
|
||||
# *********************************************
|
||||
def moyenne_ponderee_terme_a_terme(notes,
|
||||
coefs=None,
|
||||
force=False):
|
||||
def moyenne_ponderee_terme_a_terme(notes, coefs=None, force=False):
|
||||
"""
|
||||
Calcule la moyenne pondérée d'une liste de notes avec d'éventuels coeffs de pondération.
|
||||
Renvoie le résultat sous forme d'un tuple (moy, somme_coeff)
|
||||
|
||||
@ -100,10 +100,14 @@ def pe_view_sem_recap(
|
||||
|
||||
sem_base = FormSemestre.get_formsemestre(formsemestre_id)
|
||||
if not sem_base.formation.is_apc():
|
||||
raise ScoValueError("Le module de Poursuites d'Etudes avec Scodoc 9 n'est disponible que pour des formations BUT")
|
||||
raise ScoValueError(
|
||||
"Le module de Poursuites d'Etudes avec Scodoc 9 n'est disponible que pour des formations BUT"
|
||||
)
|
||||
|
||||
# TODO: CB: A supprimer à long terme
|
||||
semBase = sco_formsemestre.get_formsemestre(formsemestre_id) # FormSemestre.get_formsemestre()
|
||||
semBase = sco_formsemestre.get_formsemestre(
|
||||
formsemestre_id
|
||||
) # FormSemestre.get_formsemestre()
|
||||
|
||||
jury = pe_jurype.JuryPE(sem_base, semBase)
|
||||
# Ajout avis LaTeX au même zip:
|
||||
|
||||
Loading…
Reference in New Issue
Block a user