Reformattage code avec Black

app/pe/pe_avislatex.py

@@ -67,8 +67,7 @@ def get_code_latex_from_modele(fichier):
 
 
 # ----------------------------------------------------------------------------------------
-def get_code_latex_from_scodoc_preference(formsemestre_id,
+def get_code_latex_from_scodoc_preference(formsemestre_id, champ="pe_avis_latex_tmpl"):
-                                          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,
+def comp_latex_parcourstimeline(etudiant, promo, taille=17):
-                                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,
+def get_code_latex_avis_etudiant(
-                                 un_avis_latex,
+    donnees_etudiant, un_avis_latex, annotationPE, footer_latex, prefs
-                                 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,
+def get_annotation_PE(etudid, tag_annotation_pe):
-                      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,
+def str_from_syntheseJury(donnees_etudiant, aggregat, groupe, tag_scodoc, champ):
-                          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,
+def get_bilanParTag(donnees_etudiant, groupe="groupe"):
-                    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,
+    jury, etudid, template_latex, tag_annotation_pe, footer_latex, prefs
-    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,
+def table_syntheseAnnotationPE(syntheseJury, tag_annotation_pe):
-                               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
 

app/pe/pe_jurype.py

@@ -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,
+    def __init__(self, sem_base: FormSemestre, semBase):  # CB: à supprimer à long terme
-                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,
+    def get_etudiants_in_jury(self, semBase, avec_meme_formation=False):
-                              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,
+    def get_etudiants_dans_semestres(self, semsListe):
-                                     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 = (
+            etudiantsDuSemestre = [
-                [ins.etudid for ins in nt.formsemestre.inscriptions]  # nt.get_etudids()
+                ins.etudid for ins in nt.formsemestre.inscriptions
-            )  # identification des etudiants du semestre
+            ]  # 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,
+    def get_etudids_du_jury(self, ordre="aucun"):
-                            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,
+    def add_etudiants(self, etudid):
-                      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,
+    def est_un_etudiant_reoriente_ou_demissionnaire(self, etudid):
-                                                    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,
+    def est_un_etudiant_disparu(self, etudid):
-                                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,
+    def get_dernier_semestre_id_valide_d_un_etudiant(self, etudid):
-                                                     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,
+    def get_Fid_d_un_Si_valide_d_un_etudiant(self, etudid, nom_semestre):
-                                             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(),
+            self.get_etudids_du_jury(), liste_semestres=JuryPE.TOUS_LES_SEMESTRES
-            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,
+    def add_semtags_in_jury(self, fid):
-                            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,
+    def get_formsemestreids_du_jury(self, etudids, liste_semestres="6S"):
-                                    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,
+    def get_dateEntree(self, etudid):
-                       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,
+    def get_parcoursIUT(self, etudid):
-                        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,
+    def str_etudiants_in_jury(self, delim=";"):
-                              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,
+    def table_syntheseJury(self, mode="singlesheet"):  #  was str_syntheseJury
-                           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],
+                            for x in (resgroupe[6], resgroupe[4], resgroupe[5])
-                                      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,
+    def get_cache_etudInfo_d_un_etudiant(self, etudid):
-                                         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,
+    def get_cache_notes_d_un_semestre(self, formsemestre_id: int) -> NotesTableCompat:
-                                      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,
+    def get_semestresBUT_d_un_etudiant(self, etudid, semestre_id=None):
-                                       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,
+    def calcul_anneePromoBUT_d_un_etudiant(self, etudid) -> int:
-                                           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,
+    def get_resultat_d_un_etudiant(self, etudid):
-                                   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,
+def get_cosemestres_diplomants(semBase, avec_meme_formation=False):
-                               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 :

app/pe/pe_semestretag.py

@@ -78,9 +78,7 @@ class SemestreTag(pe_tagtable.TableTag):
     # -----------------------------------------------------------------------------
     # Fonctions d'initialisation
     # -----------------------------------------------------------------------------
-    def __init__(self,
+    def __init__(self, notetable, sem):  # Initialisation sur la base d'une notetable
-                 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,
+    def comp_MoyennesTag(self, tag, force=False) -> list:
-                         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,
+    def get_noteEtCoeff_modimpl(self, modimpl_id, etudid, profondeur=2):
-                                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,
+    def get_ue_capitalisees(self, etudid) -> list[dict]:
-                            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,
+    def get_listesNotesEtCoeffsTagEtudiant(self, tag, etudid):
-                                           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,
+    def str_detail_resultat_d_un_tag(self, tag, etudid=None, delim=";"):
-                                     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,
+def comp_coeff_pond(coeffs, ponderations):
-                    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,
+def get_moy_ue_from_nt(nt, etudid, modimpl_id) -> float:
-                       etudid,
-                       modimpl_id) -> float:
     """Renvoie la moyenne de l'UE d'un etudid dans laquelle se trouve
     le module de modimpl_id
     """

app/pe/pe_settag.py

@@ -51,19 +51,15 @@ class SetTag(pe_tagtable.TableTag):
     """
 
     # -------------------------------------------------------------------------------------------------------------------
-    def __init__(self,
+    def __init__(self, nom_combinaison, parcours):
-                 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,
+    def set_Etudiants(
-                      etudiants: list[dict],
+        self, etudiants: list[dict], juryPEDict, etudInfoDict, nom_sem_final=None
-                      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,
+    def set_SemTagDict(self, SemTagDict):
-                       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,
+    def get_NotesEtCoeffsSetTagEtudiant(self, tag, etudid):
-                                        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,
+    def comp_MoyennesSetTag(self, tag, force=False):
-                            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,
+    def __init__(self, nom_combinaison, diplome):
-                 nom_combinaison,
-                 diplome):
         pe_tagtable.TableTag.__init__(self, nom=f"{nom_combinaison}_{diplome or ''}")
         self.combinaison = nom_combinaison
         self.parcoursDict = {}
 
     # -------------------------------------------------------------------------------------------
-    def set_Etudiants(self,
+    def set_Etudiants(self, etudiants, juryPEDict, etudInfoDict, nom_sem_final=None):
-                      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,
+    def set_SetTagDict(self, SetTagDict):
-                       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,
+    def get_NotesEtCoeffsSetTagEtudiant(self, tag, etudid):
-                                        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,
+    def get_MoyennesSetTag(self, tag, force=False):
-                           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.

app/pe/pe_tagtable.py

@@ -77,9 +77,7 @@ class TableTag(object):
     # *****************************************************************************************************************
 
     # -----------------------------------------------------------------------------------------------------------
-    def get_moy_from_resultats(self,
+    def get_moy_from_resultats(self, tag, etudid):
-                               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,
+    def get_rang_from_resultats(self, tag, etudid):
-                                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,
+    def get_coeff_from_resultats(self, tag, etudid):
-                                 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,
+    def get_moy_from_stats(self, tag):
-                           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,
+    def get_min_from_stats(self, tag):
-                           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,
+    def get_max_from_stats(self, tag):
-                           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,
+    def get_resultatsEtud(self, tag, etudid):
-                          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,
+    def add_moyennesTag(self, tag, listMoyEtCoeff) -> bool:
-                        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,
+    def comp_stats_d_un_tag(self, tag):
-                            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,
+    def str_resTag_d_un_etudiant(self, tag, etudid, delim=";"):
-                                 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,
+    def str_res_d_un_etudiant(self, etudid, delim=";"):
-                              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,
+    def str_moytag(cls, moyenne, rang, nbinscrit, delim=";"):
-                   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,
+    def str_tagtable(self, delim=";", decimal_sep=","):
-                     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,
+def moyenne_ponderee_terme_a_terme(notes, coefs=None, force=False):
-                                   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)

app/pe/pe_view.py

@@ -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: