Merge pe-BUT-v2 de Cléo

app/pe/pe_affichage.py

@@ -0,0 +1,68 @@
+from app.models import Formation, FormSemestre
+from app.scodoc import codes_cursus
+
+
+def nom_semestre_etape(semestre: FormSemestre, avec_fid=False) -> str:
+    """Nom d'un semestre à afficher dans le descriptif des étapes de la scolarité
+    d'un étudiant.
+
+    Par ex: Pour un S2, affiche ``"Semestre 2 FI S014-2015 (129)"`` avec :
+
+    * 2 le numéro du semestre,
+    * FI la modalité,
+    * 2014-2015 les dates
+
+    Args:
+        semestre: Un ``FormSemestre``
+        avec_fid: Ajoute le n° du semestre à la description
+
+    Returns:
+        La chaine de caractères décrivant succintement le semestre
+    """
+    formation: Formation = semestre.formation
+    parcours = codes_cursus.get_cursus_from_code(formation.type_parcours)
+
+    description = [
+        parcours.SESSION_NAME.capitalize(),
+        str(semestre.semestre_id),
+        semestre.modalite,  # eg FI ou FC
+        f"{semestre.date_debut.year}-{semestre.date_fin.year}",
+    ]
+    if avec_fid:
+        description.append(f"({semestre.forsemestre_id})")
+
+    return " ".join(description)
+
+
+def etapes_du_cursus(semestres: dict[int, FormSemestre], nbre_etapes_max: int) -> list[str]:
+    """Partant d'un dictionnaire de semestres (qui retrace
+    la scolarité d'un étudiant), liste les noms des
+    semestres (en version abbrégée)
+    qu'un étudiant a suivi au cours de sa scolarité à l'IUT.
+    Les noms des semestres sont renvoyés dans un dictionnaire
+    ``{"etape i": nom_semestre_a_etape_i}``
+    avec i variant jusqu'à nbre_semestres_max. (S'il n'y a pas de semestre à l'étape i,
+    le nom affiché est vide.
+
+    La fonction suppose la liste des semestres triées par ordre
+    décroissant de date.
+
+    Args:
+        semestres: une liste de ``FormSemestre``
+        nbre_etapes_max: le nombre d'étapes max prise en compte
+
+    Returns:
+        Une liste de nom de semestre (dans le même ordre que les ``semestres``)
+
+    See also:
+         app.pe.pe_affichage.nom_semestre_etape
+    """
+    assert len(semestres) <= nbre_etapes_max
+
+    noms = [nom_semestre_etape(sem, avec_fid=False) for (fid, sem) in semestres.items()]
+    noms = noms[::-1] # trie par ordre croissant
+
+    dico = {f"Etape {i+1}": "" for i in range(nbre_etapes_max)}
+    for (i, nom) in enumerate(noms): # Charge les noms de semestres
+        dico[f"Etape {i+1}"] = nom
+    return dico

app/pe/pe_avislatex.py

@@ -1,517 +0,0 @@
-# -*- mode: python -*-
-# -*- coding: utf-8 -*-
-
-##############################################################################
-#
-# Gestion scolarite IUT
-#
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-#
-#   Emmanuel Viennet      emmanuel.viennet@viennet.net
-#
-##############################################################################
-
-##############################################################################
-#  Module "Avis de poursuite d'étude"
-#  conçu et développé par Cléo Baras (IUT de Grenoble)
-##############################################################################
-
-import os
-import codecs
-import re
-from app.pe import pe_tagtable
-from app.pe import pe_jurype
-from app.pe import pe_tools
-
-import app.scodoc.sco_utils as scu
-import app.scodoc.notesdb as ndb
-from app import log
-from app.scodoc.gen_tables import GenTable, SeqGenTable
-from app.scodoc import sco_preferences
-from app.scodoc import sco_etud
-
-
-DEBUG = False  # Pour debug et repérage des prints à changer en Log
-
-DONNEE_MANQUANTE = (
-    ""  # Caractère de remplacement des données manquantes dans un avis PE
-)
-
-
-# ----------------------------------------------------------------------------------------
-def get_code_latex_from_modele(fichier):
-    """Lit le code latex à partir d'un modèle. Renvoie une chaine unicode.
-
-    Le fichier doit contenir le chemin relatif
-    vers le modele : attention pas de vérification du format d'encodage
-    Le fichier doit donc etre enregistré avec le même codage que ScoDoc (utf-8)
-    """
-    fid_latex = codecs.open(fichier, "r", encoding=scu.SCO_ENCODING)
-    un_avis_latex = fid_latex.read()
-    fid_latex.close()
-    return un_avis_latex
-
-
-# ----------------------------------------------------------------------------------------
-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
-    """
-    template_latex = sco_preferences.get_preference(champ, formsemestre_id)
-
-    return template_latex or ""
-
-
-# ----------------------------------------------------------------------------------------
-def get_tags_latex(code_latex):
-    """Recherche tous les tags présents dans un code latex (ce code étant obtenu
-    à la lecture d'un modèle d'avis pe).
-    Ces tags sont répérés par les balises **, débutant et finissant le tag
-    et sont renvoyés sous la forme d'une liste.
-
-    result: liste de chaines unicode
-    """
-    if code_latex:
-        # changé par EV: était r"([\*]{2}[a-zA-Z0-9:éèàâêëïôöù]+[\*]{2})"
-        res = re.findall(r"([\*]{2}[^\t\n\r\f\v\*]+[\*]{2})", code_latex)
-        return [tag[2:-2] for tag in res]
-    else:
-        return []
-
-
-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.
-    Nota: modeles/parcourstimeline.tex doit avoir été inclu dans le préambule
-
-    result: chaine unicode (EV:)
-    """
-    codelatexDebut = (
-        """"
-    \\begin{parcourstimeline}{**debut**}{**fin**}{**nbreSemestres**}{%d}
-    """
-        % taille
-    )
-
-    modeleEvent = """
-    \\parcoursevent{**nosem**}{**nomsem**}{**descr**}
-    """
-
-    codelatexFin = """
-    \\end{parcourstimeline}
-    """
-    reslatex = codelatexDebut
-    reslatex = reslatex.replace("**debut**", etudiant["entree"])
-    reslatex = reslatex.replace("**fin**", str(etudiant["promo"]))
-    reslatex = reslatex.replace("**nbreSemestres**", str(etudiant["nbSemestres"]))
-    # Tri du parcours par ordre croissant : de la forme descr, nom sem date-date
-    parcours = etudiant["parcours"][::-1]  # EV: XXX je ne comprend pas ce commentaire ?
-
-    for no_sem in range(etudiant["nbSemestres"]):
-        descr = modeleEvent
-        nom_semestre_dans_parcours = parcours[no_sem]["nom_semestre_dans_parcours"]
-        descr = descr.replace("**nosem**", str(no_sem + 1))
-        if no_sem % 2 == 0:
-            descr = descr.replace("**nomsem**", nom_semestre_dans_parcours)
-            descr = descr.replace("**descr**", "")
-        else:
-            descr = descr.replace("**nomsem**", "")
-            descr = descr.replace("**descr**", nom_semestre_dans_parcours)
-        reslatex += descr
-    reslatex += codelatexFin
-    return reslatex
-
-
-# ----------------------------------------------------------------------------------------
-def interprete_tag_latex(tag):
-    """Découpe les tags latex de la forme S1:groupe:dut:min et renvoie si possible
-    le résultat sous la forme d'un quadruplet.
-    """
-    infotag = tag.split(":")
-    if len(infotag) == 4:
-        return (
-            infotag[0].upper(),
-            infotag[1].lower(),
-            infotag[2].lower(),
-            infotag[3].lower(),
-        )
-    else:
-        return (None, None, None, None)
-
-
-# ----------------------------------------------------------------------------------------
-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
-    fichier modele donné
-
-    result: chaine unicode
-    """
-    if not donnees_etudiant or not un_avis_latex:  # Cas d'un template vide
-        return annotationPE if annotationPE else ""
-
-    # Le template latex (corps + footer)
-    code = un_avis_latex + "\n\n" + footer_latex
-
-    # Recherche des tags dans le fichier
-    tags_latex = get_tags_latex(code)
-    if DEBUG:
-        log("Les tags" + str(tags_latex))
-
-    # Interprète et remplace chaque tags latex par les données numériques de l'étudiant (y compris les
-    # tags "macros" tels que parcourstimeline
-    for tag_latex in tags_latex:
-        # les tags numériques
-        valeur = DONNEE_MANQUANTE
-
-        if ":" in tag_latex:
-            (aggregat, groupe, tag_scodoc, champ) = interprete_tag_latex(tag_latex)
-            valeur = str_from_syntheseJury(
-                donnees_etudiant, aggregat, groupe, tag_scodoc, champ
-            )
-
-        # La macro parcourstimeline
-        elif tag_latex == "parcourstimeline":
-            valeur = comp_latex_parcourstimeline(
-                donnees_etudiant, donnees_etudiant["promo"]
-            )
-
-        # Le tag annotationPE
-        elif tag_latex == "annotation":
-            valeur = annotationPE
-
-        # Le tag bilanParTag
-        elif tag_latex == "bilanParTag":
-            valeur = get_bilanParTag(donnees_etudiant)
-
-        # Les tags "simples": par ex. nom, prenom, civilite, ...
-        else:
-            if tag_latex in donnees_etudiant:
-                valeur = donnees_etudiant[tag_latex]
-            elif tag_latex in prefs:  # les champs **NomResponsablePE**, ...
-                valeur = pe_tools.escape_for_latex(prefs[tag_latex])
-
-        # Vérification des pb d'encodage (debug)
-        # assert isinstance(tag_latex, unicode)
-        # assert isinstance(valeur, unicode)
-
-        # Substitution
-        code = code.replace("**" + tag_latex + "**", valeur)
-    return code
-
-
-# ----------------------------------------------------------------------------------------
-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).
-
-    Result: chaine unicode
-    """
-    if tag_annotation_pe:
-        cnx = ndb.GetDBConnexion()
-        annotations = sco_etud.etud_annotations_list(
-            cnx, args={"etudid": etudid}
-        )  # Les annotations de l'étudiant
-        annotationsPE = []
-
-        exp = re.compile(r"^" + tag_annotation_pe)
-
-        for a in annotations:
-            commentaire = scu.unescape_html(a["comment"])
-            if exp.match(commentaire):  # tag en début de commentaire ?
-                a["comment_u"] = commentaire  # unicode, HTML non quoté
-                annotationsPE.append(
-                    a
-                )  # sauvegarde l'annotation si elle contient le tag
-
-        if annotationsPE:  # Si des annotations existent, prend la plus récente
-            annotationPE = sorted(annotationsPE, key=lambda a: a["date"], reverse=True)[
-                0
-            ]["comment_u"]
-
-            annotationPE = exp.sub(
-                "", annotationPE
-            )  # Suppression du tag d'annotation PE
-            annotationPE = annotationPE.replace("\r", "")  # Suppression des \r
-            annotationPE = annotationPE.replace(
-                "<br>", "\n\n"
-            )  # Interprète les retours chariots html
-            return annotationPE
-    return ""  # pas d'annotations
-
-
-# ----------------------------------------------------------------------------------------
-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.
-
-    Result: chaine unicode ou liste de chaines unicode
-    """
-
-    if isinstance(champ, list):
-        return [
-            str_from_syntheseJury(donnees_etudiant, aggregat, groupe, tag_scodoc, chp)
-            for chp in champ
-        ]
-    else:  # champ = str à priori
-        valeur = DONNEE_MANQUANTE
-        if (
-            (aggregat in donnees_etudiant)
-            and (groupe in donnees_etudiant[aggregat])
-            and (tag_scodoc in donnees_etudiant[aggregat][groupe])
-        ):
-            donnees_numeriques = donnees_etudiant[aggregat][groupe][tag_scodoc]
-            if champ == "rang":
-                valeur = "%s/%d" % (
-                    donnees_numeriques[
-                        pe_tagtable.TableTag.FORMAT_DONNEES_ETUDIANTS.index("rang")
-                    ],
-                    donnees_numeriques[
-                        pe_tagtable.TableTag.FORMAT_DONNEES_ETUDIANTS.index(
-                            "nbinscrits"
-                        )
-                    ],
-                )
-            elif champ in pe_tagtable.TableTag.FORMAT_DONNEES_ETUDIANTS:
-                indice_champ = pe_tagtable.TableTag.FORMAT_DONNEES_ETUDIANTS.index(
-                    champ
-                )
-                if (
-                    len(donnees_numeriques) > indice_champ
-                    and donnees_numeriques[indice_champ] != None
-                ):
-                    if isinstance(
-                        donnees_numeriques[indice_champ], float
-                    ):  # valeur numérique avec formattage unicode
-                        valeur = "%2.2f" % donnees_numeriques[indice_champ]
-                    else:
-                        valeur = "%s" % donnees_numeriques[indice_champ]
-
-        return valeur
-
-
-# ----------------------------------------------------------------------------------------
-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
-    """
-
-    entete = [
-        (
-            agg,
-            pe_jurype.JuryPE.PARCOURS[agg]["affichage_court"],
-            pe_jurype.JuryPE.PARCOURS[agg]["ordre"],
-        )
-        for agg in pe_jurype.JuryPE.PARCOURS
-    ]
-    entete = sorted(entete, key=lambda t: t[2])
-
-    lignes = []
-    valeurs = {"note": [], "rang": []}
-    for indice_aggregat, (aggregat, intitule, _) in enumerate(entete):
-        # print("> " + aggregat)
-        # listeTags = jury.get_allTagForAggregat(aggregat)  # les tags de l'aggrégat
-        listeTags = [
-            tag for tag in donnees_etudiant[aggregat][groupe].keys() if tag != "dut"
-        ]  #
-        for tag in listeTags:
-            if tag not in lignes:
-                lignes.append(tag)
-                valeurs["note"].append(
-                    [""] * len(entete)
-                )  # Ajout d'une ligne de données
-                valeurs["rang"].append(
-                    [""] * len(entete)
-                )  # Ajout d'une ligne de données
-            indice_tag = lignes.index(tag)  # l'indice de ligne du tag
-
-            # print(" --- " + tag + "(" + str(indice_tag) + "," + str(indice_aggregat) + ")")
-            [note, rang] = str_from_syntheseJury(
-                donnees_etudiant, aggregat, groupe, tag, ["note", "rang"]
-            )
-            valeurs["note"][indice_tag][indice_aggregat] = "" + note + ""
-            valeurs["rang"][indice_tag][indice_aggregat] = (
-                ("\\textit{" + rang + "}") if note else ""
-            )  # rang masqué si pas de notes
-
-    code_latex = "\\begin{tabular}{|c|" + "|c" * (len(entete)) + "|}\n"
-    code_latex += "\\hline \n"
-    code_latex += (
-        " & "
-        + " & ".join(["\\textbf{" + intitule + "}" for (agg, intitule, _) in entete])
-        + " \\\\ \n"
-    )
-    code_latex += "\\hline"
-    code_latex += "\\hline \n"
-    for i, ligne_val in enumerate(valeurs["note"]):
-        titre = lignes[i]  # règle le pb d'encodage
-        code_latex += "\\textbf{" + titre + "} & " + " & ".join(ligne_val) + "\\\\ \n"
-        code_latex += (
-            " & "
-            + " & ".join(
-                ["{\\scriptsize " + clsmt + "}" for clsmt in valeurs["rang"][i]]
-            )
-            + "\\\\ \n"
-        )
-        code_latex += "\\hline \n"
-    code_latex += "\\end{tabular}"
-
-    return code_latex
-
-
-# ----------------------------------------------------------------------------------------
-def get_avis_poursuite_par_etudiant(
-    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 ]
-    """
-    if pe_tools.PE_DEBUG:
-        pe_tools.pe_print(jury.syntheseJury[etudid]["nom"] + " " + str(etudid))
-
-    civilite_str = jury.syntheseJury[etudid]["civilite_str"]
-    nom = jury.syntheseJury[etudid]["nom"].replace(" ", "-")
-    prenom = jury.syntheseJury[etudid]["prenom"].replace(" ", "-")
-
-    nom_fichier = scu.sanitize_filename(
-        "avis_poursuite_%s_%s_%s" % (nom, prenom, etudid)
-    )
-    if pe_tools.PE_DEBUG:
-        pe_tools.pe_print("fichier latex =" + nom_fichier, type(nom_fichier))
-
-    # Entete (commentaire)
-    contenu_latex = (
-        "%% ---- Etudiant: " + civilite_str + " " + nom + " " + prenom + "\n"
-    )
-
-    # les annnotations
-    annotationPE = get_annotation_PE(etudid, tag_annotation_pe=tag_annotation_pe)
-    if pe_tools.PE_DEBUG:
-        pe_tools.pe_print(annotationPE, type(annotationPE))
-
-    # le LaTeX
-    avis = get_code_latex_avis_etudiant(
-        jury.syntheseJury[etudid], template_latex, annotationPE, footer_latex, prefs
-    )
-    # if pe_tools.PE_DEBUG: pe_tools.pe_print(avis, type(avis))
-    contenu_latex += avis + "\n"
-
-    return [nom_fichier, contenu_latex]
-
-
-def get_templates_from_distrib(template="avis"):
-    """Récupère le template (soit un_avis.tex soit le footer.tex) à partir des fichiers mémorisés dans la distrib des avis pe (distrib local
-    ou par défaut et le renvoie"""
-    if template == "avis":
-        pe_local_tmpl = pe_tools.PE_LOCAL_AVIS_LATEX_TMPL
-        pe_default_tmpl = pe_tools.PE_DEFAULT_AVIS_LATEX_TMPL
-    elif template == "footer":
-        pe_local_tmpl = pe_tools.PE_LOCAL_FOOTER_TMPL
-        pe_default_tmpl = pe_tools.PE_DEFAULT_FOOTER_TMPL
-
-    if template in ["avis", "footer"]:
-        # pas de preference pour le template: utilise fichier du serveur
-        if os.path.exists(pe_local_tmpl):
-            template_latex = get_code_latex_from_modele(pe_local_tmpl)
-        else:
-            if os.path.exists(pe_default_tmpl):
-                template_latex = get_code_latex_from_modele(pe_default_tmpl)
-            else:
-                template_latex = ""  # fallback: avis vides
-        return template_latex
-
-
-# ----------------------------------------------------------------------------------------
-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
-
-    # Les etudids des étudiants à afficher, triés par ordre alphabétiques de nom+prénom
-    donnees_tries = sorted(
-        [
-            (etudid, syntheseJury[etudid]["nom"] + " " + syntheseJury[etudid]["prenom"])
-            for etudid in syntheseJury.keys()
-        ],
-        key=lambda c: c[1],
-    )
-    etudids = [e[0] for e in donnees_tries]
-    if not etudids:  # Si pas d'étudiants
-        T = GenTable(
-            columns_ids=["pas d'étudiants"],
-            rows=[],
-            titles={"pas d'étudiants": "pas d'étudiants"},
-            html_sortable=True,
-            xls_sheet_name="dut",
-        )
-        sT.add_genTable("Annotation PE", T)
-        return sT
-
-    # Si des étudiants
-    maxParcours = max(
-        [syntheseJury[etudid]["nbSemestres"] for etudid in etudids]
-    )  # le nombre de semestre le + grand
-
-    infos = ["civilite", "nom", "prenom", "age", "nbSemestres"]
-    entete = ["etudid"]
-    entete.extend(infos)
-    entete.extend(["P%d" % i for i in range(1, maxParcours + 1)])  # ajout du parcours
-    entete.append("Annotation PE")
-    columns_ids = entete  # les id et les titres de colonnes sont ici identiques
-    titles = {i: i for i in columns_ids}
-
-    rows = []
-    for (
-        etudid
-    ) in etudids:  # parcours des étudiants par ordre alphabétique des nom+prénom
-        e = syntheseJury[etudid]
-        # Les info générales:
-        row = {
-            "etudid": etudid,
-            "civilite": e["civilite"],
-            "nom": e["nom"],
-            "prenom": e["prenom"],
-            "age": e["age"],
-            "nbSemestres": e["nbSemestres"],
-        }
-        # Les parcours: P1, P2, ...
-        n = 1
-        for p in e["parcours"]:
-            row["P%d" % n] = p["titreannee"]
-            n += 1
-
-        # L'annotation PE
-        annotationPE = get_annotation_PE(etudid, tag_annotation_pe=tag_annotation_pe)
-        row["Annotation PE"] = annotationPE if annotationPE else ""
-        rows.append(row)
-
-    T = GenTable(
-        columns_ids=columns_ids,
-        rows=rows,
-        titles=titles,
-        html_sortable=True,
-        xls_sheet_name="Annotation PE",
-    )
-    sT.add_genTable("Annotation PE", T)
-    return sT

app/pe/pe_comp.py

@@ -0,0 +1,384 @@
+# -*- mode: python -*-
+# -*- coding: utf-8 -*-
+
+##############################################################################
+#
+# Gestion scolarite IUT
+#
+# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+#   Emmanuel Viennet      emmanuel.viennet@viennet.net
+#
+##############################################################################
+
+##############################################################################
+#  Module "Avis de poursuite d'étude"
+#  conçu et développé par Cléo Baras (IUT de Grenoble)
+##############################################################################
+
+"""
+Created on Thu Sep  8 09:36:33 2016
+
+@author: barasc
+"""
+
+import os
+import datetime
+import re
+import unicodedata
+
+
+from flask import g
+
+import app.scodoc.sco_utils as scu
+from app import log
+from app.models import FormSemestre
+from app.scodoc import sco_formsemestre
+from app.scodoc.sco_logos import find_logo
+
+PE_DEBUG = 0
+
+if not PE_DEBUG:
+    # log to notes.log
+    def pe_print(*a, **kw):
+        # kw is ignored. log always add a newline
+        log(" ".join(a))
+
+else:
+    pe_print = print  # print function
+
+
+# Generated LaTeX files are encoded as:
+PE_LATEX_ENCODING = "utf-8"
+
+# /opt/scodoc/tools/doc_poursuites_etudes
+REP_DEFAULT_AVIS = os.path.join(scu.SCO_TOOLS_DIR, "doc_poursuites_etudes/")
+REP_LOCAL_AVIS = os.path.join(scu.SCODOC_CFG_DIR, "doc_poursuites_etudes/")
+
+PE_DEFAULT_AVIS_LATEX_TMPL = REP_DEFAULT_AVIS + "distrib/modeles/un_avis.tex"
+PE_LOCAL_AVIS_LATEX_TMPL = REP_LOCAL_AVIS + "local/modeles/un_avis.tex"
+PE_DEFAULT_FOOTER_TMPL = REP_DEFAULT_AVIS + "distrib/modeles/un_footer.tex"
+PE_LOCAL_FOOTER_TMPL = REP_LOCAL_AVIS + "local/modeles/un_footer.tex"
+
+# ----------------------------------------------------------------------------------------
+
+"""
+Descriptif d'un parcours classique BUT
+
+TODO:: A améliorer si BUT en moins de 6 semestres
+"""
+
+PARCOURS = {
+    "S1": {
+        "aggregat": ["S1"],
+        "ordre": 1,
+        "affichage_court": "S1",
+        "affichage_long": "Semestre 1",
+    },
+    "S2": {
+        "aggregat": ["S2"],
+        "ordre": 2,
+        "affichage_court": "S2",
+        "affichage_long": "Semestre 2",
+    },
+    "1A": {
+        "aggregat": ["S1", "S2"],
+        "ordre": 3,
+        "affichage_court": "1A",
+        "affichage_long": "1ère année",
+    },
+    "S3": {
+        "aggregat": ["S3"],
+        "ordre": 4,
+        "affichage_court": "S3",
+        "affichage_long": "Semestre 3",
+    },
+    "S4": {
+        "aggregat": ["S4"],
+        "ordre": 5,
+        "affichage_court": "S4",
+        "affichage_long": "Semestre 4",
+    },
+    "2A": {
+        "aggregat": ["S3", "S4"],
+        "ordre": 6,
+        "affichage_court": "2A",
+        "affichage_long": "2ème année",
+    },
+    "3S": {
+        "aggregat": ["S1", "S2", "S3"],
+        "ordre": 7,
+        "affichage_court": "S1+S2+S3",
+        "affichage_long": "BUT du semestre 1 au semestre 3",
+    },
+    "4S": {
+        "aggregat": ["S1", "S2", "S3", "S4"],
+        "ordre": 8,
+        "affichage_court": "BUT",
+        "affichage_long": "BUT du semestre 1 au semestre 4",
+    },
+    "S5": {
+        "aggregat": ["S5"],
+        "ordre": 9,
+        "affichage_court": "S5",
+        "affichage_long": "Semestre 5",
+    },
+    "S6": {
+        "aggregat": ["S6"],
+        "ordre": 10,
+        "affichage_court": "S6",
+        "affichage_long": "Semestre 6",
+    },
+    "3A": {
+        "aggregat": ["S5", "S6"],
+        "ordre": 11,
+        "affichage_court": "3A",
+        "affichage_long": "3ème année",
+    },
+    "5S": {
+        "aggregat": ["S1", "S2", "S3", "S4", "S5"],
+        "ordre": 12,
+        "affichage_court": "S1+S2+S3+S4+S5",
+        "affichage_long": "BUT du semestre 1 au semestre 5",
+    },
+    "6S": {
+        "aggregat": ["S1", "S2", "S3", "S4", "S5", "S6"],
+        "ordre": 13,
+        "affichage_court": "BUT",
+        "affichage_long": "BUT (tout semestre inclus)",
+    },
+}
+NBRE_SEMESTRES_DIPLOMANT = 6
+AGGREGAT_DIPLOMANT = (
+    "6S"  # aggrégat correspondant à la totalité des notes pour le diplôme
+)
+TOUS_LES_SEMESTRES = PARCOURS[AGGREGAT_DIPLOMANT]["aggregat"]
+TOUS_LES_AGGREGATS = [cle for cle in PARCOURS.keys() if not cle.startswith("S")]
+TOUS_LES_PARCOURS = list(PARCOURS.keys())
+
+# ----------------------------------------------------------------------------------------
+def calcul_age(born: datetime.date) -> int:
+    """Calcule l'age connaissant la date de naissance ``born``. (L'age est calculé
+    à partir de l'horloge système).
+
+    Args:
+        born: La date de naissance
+
+    Return:
+        L'age (au regard de la date actuelle)
+    """
+    if not born or not isinstance(born, datetime.date):
+        return None
+
+    today = datetime.date.today()
+    return (
+        today.year
+        - born.year
+        - ((today.month, today.day) < (born.month, born.day))
+    )
+
+
+def remove_accents(input_unicode_str):
+    """Supprime les accents d'une chaine unicode"""
+    nfkd_form = unicodedata.normalize("NFKD", input_unicode_str)
+    only_ascii = nfkd_form.encode("ASCII", "ignore")
+    return only_ascii
+
+
+def escape_for_latex(s):
+    """Protège les caractères pour inclusion dans du source LaTeX"""
+    if not s:
+        return ""
+    conv = {
+        "&": r"\&",
+        "%": r"\%",
+        "$": r"\$",
+        "#": r"\#",
+        "_": r"\_",
+        "{": r"\{",
+        "}": r"\}",
+        "~": r"\textasciitilde{}",
+        "^": r"\^{}",
+        "\\": r"\textbackslash{}",
+        "<": r"\textless ",
+        ">": r"\textgreater ",
+    }
+    exp = re.compile(
+        "|".join(
+            re.escape(key)
+            for key in sorted(list(conv.keys()), key=lambda item: -len(item))
+        )
+    )
+    return exp.sub(lambda match: conv[match.group()], s)
+
+
+# ----------------------------------------------------------------------------------------
+def list_directory_filenames(path):
+    """List of regular filenames in a directory (recursive)
+    Excludes files and directories begining with .
+    """
+    R = []
+    for root, dirs, files in os.walk(path, topdown=True):
+        dirs[:] = [d for d in dirs if d[0] != "."]
+        R += [os.path.join(root, fn) for fn in files if fn[0] != "."]
+    return R
+
+
+def add_local_file_to_zip(zipfile, ziproot, pathname, path_in_zip):
+    """Read pathname server file and add content to zip under path_in_zip"""
+    rooted_path_in_zip = os.path.join(ziproot, path_in_zip)
+    zipfile.write(filename=pathname, arcname=rooted_path_in_zip)
+    # data = open(pathname).read()
+    # zipfile.writestr(rooted_path_in_zip, data)
+
+
+def add_refs_to_register(register, directory):
+    """Ajoute les fichiers trouvés dans directory au registre (dictionaire) sous la forme
+    filename => pathname
+    """
+    length = len(directory)
+    for pathname in list_directory_filenames(directory):
+        filename = pathname[length + 1 :]
+        register[filename] = pathname
+
+
+def add_pe_stuff_to_zip(zipfile, ziproot):
+    """Add auxiliary files to (already opened) zip
+    Put all local files found under config/doc_poursuites_etudes/local
+    and config/doc_poursuites_etudes/distrib
+    If a file is present in both subtrees, take the one in local.
+
+    Also copy logos
+    """
+    register = {}
+    # first add standard (distrib references)
+    distrib_dir = os.path.join(REP_DEFAULT_AVIS, "distrib")
+    add_refs_to_register(register=register, directory=distrib_dir)
+    # then add local references (some oh them may overwrite distrib refs)
+    local_dir = os.path.join(REP_LOCAL_AVIS, "local")
+    add_refs_to_register(register=register, directory=local_dir)
+    # at this point register contains all refs (filename, pathname) to be saved
+    for filename, pathname in register.items():
+        add_local_file_to_zip(zipfile, ziproot, pathname, "avis/" + filename)
+
+    # Logos: (add to logos/ directory in zip)
+    logos_names = ["header", "footer"]
+    for name in logos_names:
+        logo = find_logo(logoname=name, dept_id=g.scodoc_dept_id)
+        if logo is not None:
+            add_local_file_to_zip(
+                zipfile, ziproot, logo.filepath, "avis/logos/" + logo.filename
+            )
+
+
+# ----------------------------------------------------------------------------------------
+def get_annee_diplome_semestre(sem_base, nbre_sem_formation=6) -> int:
+    """Pour un semestre ``sem_base`` donné (supposé être un semestre d'une formation BUT à 6 semestres)
+    et connaissant le numéro du semestre, ses dates de début et de fin du semestre, prédit l'année à laquelle
+    sera remis le diplôme BUT des étudiants qui y sont scolarisés
+    (en supposant qu'il n'y ait pas de redoublement à venir).
+
+    **Remarque sur le calcul** : Les semestres de 1ère partie d'année (S1, S3, S5 ou S4, S6 pour des semestres décalés)
+    s'étalent sur deux années civiles ; contrairement au semestre de seconde partie d'année universitaire.
+
+    Par exemple :
+
+    * S5 débutant en 2025 finissant en 2026 : diplome en 2026
+    * S3 debutant en 2025 et finissant en 2026 : diplome en 2027
+
+    La fonction est adaptée au cas des semestres décalés.
+
+    Par exemple :
+
+    * S5 décalé débutant en 2025 et finissant en 2025 : diplome en 2026
+    * S3 décalé débutant en 2025 et finissant en 2025 : diplome en 2027
+
+    Args:
+        sem_base: Le semestre à partir duquel est prédit l'année de diplomation, soit :
+
+                 * un ``FormSemestre`` (Scodoc9)
+                 * un dict (format compatible avec Scodoc7)
+
+        nbre_sem_formation: Le nombre de semestre prévu dans la formation (par défaut 6 pour un BUT)
+    """
+
+    if isinstance(sem_base, FormSemestre):
+        sem_id = sem_base.semestre_id
+        annee_fin = sem_base.date_fin.year
+        annee_debut = sem_base.date_debut.year
+    else:  # sem_base est un dictionnaire (Scodoc 7)
+        sem_id = sem_base["semestre_id"]
+        annee_fin = int(sem_base["annee_fin"])
+        annee_debut = int(sem_base["annee_debut"])
+    if (
+        1 <= sem_id <= nbre_sem_formation
+    ):  # Si le semestre est un semestre BUT => problème si formation BUT en 1 an ??
+        nbreSemRestant = (
+            nbre_sem_formation - sem_id
+        )  # nombre de semestres restant avant diplome
+        nbreAnRestant = nbreSemRestant // 2  # nombre d'annees restant avant diplome
+        # Flag permettant d'activer ou désactiver un increment à prendre en compte en cas de semestre décalé
+        # avec 1 - delta = 0 si semestre de 1ere partie d'année / 1 sinon
+        delta = annee_fin - annee_debut
+        decalage = nbreSemRestant % 2  # 0 si S4, 1 si S3, 0 si S2, 1 si S1
+        increment = decalage * (1 - delta)
+        return annee_fin + nbreAnRestant + increment
+
+
+def get_cosemestres_diplomants(annee_diplome: int, formation_id: int) -> list:
+    """Ensemble des cosemestres donnant lieu à diplomation à l'``annee_diplome``
+    et s'intégrant à la formation donnée par son ``formation_id``.
+
+    **Définition** : Un co-semestre est un semestre :
+
+    * dont l'année de diplômation prédite (sans redoublement) est la même
+    * dont la formation est la même (optionnel)
+    * qui a des étudiants inscrits
+
+    Si formation_id == None, ne prend pas en compte l'identifiant de formation
+    TODO:: A raccrocher à un programme
+
+    Args:
+        annee_diplome: L'année de diplomation
+        formation_id: L'identifiant de la formation
+    """
+    tousLesSems = (
+        sco_formsemestre.do_formsemestre_list()
+    )  # tous les semestres memorisés dans scodoc
+
+    if formation_id:
+        cosemestres_fids = {
+            sem["id"]
+            for sem in tousLesSems
+            if get_annee_diplome_semestre(sem) == annee_diplome
+            and sem["formation_id"] == formation_id
+        }
+    else:
+        cosemestres_fids = {
+            sem["id"]
+            for sem in tousLesSems
+            if get_annee_diplome_semestre(sem) == annee_diplome
+        }
+
+    cosemestres = {}
+    for fid in cosemestres_fids:
+        cosem = FormSemestre.get_formsemestre(fid)
+        if len(cosem.etuds_inscriptions) > 0:
+            cosemestres[fid] = cosem
+
+    return cosemestres
+

app/pe/pe_etudiant.py

@@ -0,0 +1,527 @@
+# -*- mode: python -*-
+# -*- coding: utf-8 -*-
+
+##############################################################################
+#
+# Gestion scolarite IUT
+#
+# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+#   Emmanuel Viennet      emmanuel.viennet@viennet.net
+#
+##############################################################################
+
+##############################################################################
+#  Module "Avis de poursuite d'étude"
+#  conçu et développé par Cléo Baras (IUT de Grenoble)
+##############################################################################
+
+"""
+Created on 17/01/2024
+
+@author: barasc
+"""
+
+import app.pe.pe_comp as pe_comp
+from app.models import FormSemestre, Identite
+from app.pe.pe_comp import pe_print
+
+
+class EtudiantsJuryPE:
+    """Classe centralisant la gestion des étudiants à prendre en compte dans un jury de PE"""
+
+    def __init__(self, annee_diplome: int):
+        """
+
+        Args:
+            annee_diplome: L'année de diplomation
+        """
+
+        self.annee_diplome = annee_diplome
+
+        "Les identités des étudiants traités pour le jury"
+        self.identites = {}  # ex. ETUDINFO_DICT
+        "Les cursus (semestres suivis, abandons) des étudiants"
+        self.cursus = {}
+        """Les aggrégats des semestres suivis (par ex: 3S=S1+S2+S3 à prendre en compte avec d'éventuels redoublements) des étudiants"""
+        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 = {}
+
+    def find_etudiants(self, formation_id: int):
+        """Liste des étudiants à prendre en compte dans le jury PE, en les recherchant
+        de manière automatique par rapport à leur année de diplomation ``annee_diplome``
+        dans la formation ``formation_id``.
+
+        Les données obtenues sont stockées dans les attributs de EtudiantsJuryPE.
+
+
+            formation_id: L'identifiant de la formation (inutilisé)
+
+        *Remarque* : ex: JuryPE.get_etudiants_in_jury()
+        """
+        "Les cosemestres donnant lieu à même année de diplome"
+        cosemestres = pe_comp.get_cosemestres_diplomants(self.annee_diplome, None)
+        self.cosemestres = cosemestres
+        pe_comp.pe_print(
+            "1) Recherche des coSemestres -> %d trouvés" % len(cosemestres)
+        )
+
+        """Les étudiants inscrits dans les co-semestres (ceux du jury mais aussi d'autres ayant été réorientés ou ayant abandonnés)"""
+        pe_comp.pe_print("2) Liste des étudiants dans les différents co-semestres")
+        self.etudiants_ids = get_etudiants_dans_semestres(cosemestres)
+        pe_comp.pe_print(
+            " => %d étudiants trouvés dans les cosemestres" % len(self.etudiants_ids)
+        )
+
+        """Analyse des parcours étudiants pour déterminer leur année effective de diplome 
+        avec prise en compte des redoublements, des abandons, ...."""
+        pe_comp.pe_print("3) Analyse des parcours individuels des étudiants")
+
+        no_etud = 0
+        for no_etud, etudid in enumerate(self.etudiants_ids):
+            """L'identité de l'étudiant"""
+            identite = Identite.get_etud(etudid)
+            self.identites[etudid] = identite
+
+            """L'analyse de son cursus"""
+            self.analyse_etat_etudiant(etudid, cosemestres)
+
+            """L'analyse de son parcours pour atteindre chaque semestre de la formation"""
+            self.structure_cursus_etudiant(etudid)
+
+            if (no_etud + 1) % 10 == 0:
+                pe_comp.pe_print(f"{no_etud + 1}")
+                no_etud += 1
+        pe_comp.pe_print()
+
+        """Les étudiants à prendre dans le diplôme, étudiants ayant abandonnés non compris"""
+        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}
+
+        """Les formsemestres (des étudiants) dont il faut calculer les moyennes"""
+        self.formsemestres_jury_ids = self.get_formsemestres()
+
+        # Synthèse
+        pe_comp.pe_print(
+            f"  => {len(self.etudiants_diplomes)} étudiants à diplômer en {self.annee_diplome}"
+        )
+        nbre_abandons = len(self.etudiants_ids) - len(self.etudiants_diplomes)
+        pe_comp.pe_print(f"  => {nbre_abandons} étudiants éliminer pour abandon")
+        pe_comp.pe_print(
+            f"  => {len(self.formsemestres_jury_ids)} semestres dont il faut calculer la moyenne"
+        )
+        pe_comp.pe_print(
+            f"  => quelques étudiants futurs diplômés : "
+            + ", ".join([str(etudid) for etudid in list(self.etudiants_diplomes)[:10]])
+        )
+        pe_comp.pe_print(
+            f"  => semestres dont il faut calculer les moyennes : "
+            + ", ".join([str(fid) for fid in list(self.formsemestres_jury_ids)])
+        )
+        # Les abandons :
+        self.abandons = sorted([self.cursus[etudid]['nom']
+                                for etudid in self.cursus if etudid not in self.diplomes_ids])
+
+
+    def get_etudiants_diplomes(self) -> dict[int, Identite]:
+        """Identités des étudiants (sous forme d'un dictionnaire `{etudid: Identite(etudid)}`
+        qui vont être à traiter au jury PE pour
+        l'année de diplômation donnée et n'ayant ni été réorienté, ni abandonné.
+
+
+        Returns:
+            Un dictionnaire `{etudid: Identite(etudid)}`
+        """
+        etudids = [
+            etudid
+            for etudid in self.cursus
+            if self.cursus[etudid]["diplome"] == self.annee_diplome
+            and self.cursus[etudid]["abandon"] == False
+        ]
+        etudiants = {etudid: self.identites[etudid] for etudid in etudids}
+        return etudiants
+
+    def analyse_etat_etudiant(self, etudid: int, cosemestres: dict[int, FormSemestre]):
+        """Analyse le cursus d'un étudiant pouvant être :
+
+        * l'un de ceux sur lesquels le jury va statuer (année de diplômation du jury considéré)
+        * un étudiant qui ne sera pas considéré dans le jury mais qui a participé dans sa scolarité
+          à un (ou plusieurs) semestres communs aux étudiants du jury (et impactera les classements)
+
+        L'analyse consiste :
+
+        * à insérer une entrée dans ``self.cursus`` pour mémoriser son identité,
+          avec son nom, prénom, etc...
+        * à analyser son parcours, pour déterminer s'il n'a (ou non) abandonné l'IUT en cours de
+          route (cf. clé abandon)
+
+        Args:
+            etudid: L'etudid d'un étudiant, à ajouter à ceux traiter par le jury
+            cosemestres: Dictionnaire {fid: Formsemestre(fid)} donnant accès aux cosemestres
+                         de même année de diplomation
+        """
+        identite = Identite.get_etud(etudid)
+
+        """Le cursus global de l'étudiant (restreint aux semestres APC)"""
+        formsemestres = identite.get_formsemestres()
+
+        semestres_etudiant = {
+            frmsem.formsemestre_id: frmsem
+            for frmsem in formsemestres
+            if frmsem.formation.is_apc()
+        }
+
+        self.cursus[etudid] = {
+            "etudid": etudid,  # les infos sur l'étudiant
+            "etat_civil": identite.etat_civil,  # Ajout à la table jury
+            "nom": identite.nom,
+            "entree": formsemestres[-1].date_debut.year, # La date d'entrée à l'IUT
+            "diplome": annee_diplome(identite),  # Le date prévisionnelle de son diplôme
+            "formsemestres": semestres_etudiant,  # les semestres de l'étudiant
+            "nb_semestres": len(semestres_etudiant), # le nombre de semestres de l'étudiant
+            "abandon": False,  # va être traité en dessous
+        }
+
+        """ Est-il réorienté / démissionnaire ou a-t-il arrêté volontairement sa formation ?"""
+        self.cursus[etudid]["abandon"] = arret_de_formation(identite, cosemestres)
+
+    def get_semestres_significatifs(self, etudid: int):
+        """Ensemble des semestres d'un étudiant, qui l'auraient amené à être diplomé
+        l'année visée (supprime les semestres qui conduisent à une diplomation
+        postérieure à celle du jury visé)
+
+        Args:
+            etudid: L'identifiant d'un étudiant
+
+        Returns:
+            Un dictionnaire ``{fid: FormSemestre(fid)`` dans lequel les semestres
+            amènent à une diplomation avant l'annee de diplomation du jury
+        """
+
+        semestres_etudiant = self.cursus[etudid]["formsemestres"]
+        semestres_significatifs = {}
+        for fid in semestres_etudiant:
+            semestre = semestres_etudiant[fid]
+            if pe_comp.get_annee_diplome_semestre(semestre) <= self.annee_diplome:
+                semestres_significatifs[fid] = semestre
+        return semestres_significatifs
+
+    def structure_cursus_etudiant(self, etudid: int):
+        """Structure les informations sur les semestres suivis par un
+        étudiant, pour identifier les semestres qui seront pris en compte lors de ses calculs
+        de moyennes PE.
+
+        Cette structuration s'appuie sur les numéros de semestre: pour chaque Si, stocke :
+        le dernier semestre (en date) de numéro i qu'il a suivi (1 ou 0 si pas encore suivi). Ce semestre influera les
+        interclassement par semestre dans la promo.
+        """
+        semestres_significatifs = self.get_semestres_significatifs(etudid)
+
+        """Tri des semestres par numéro de semestre"""
+        for nom_sem in pe_comp.TOUS_LES_SEMESTRES:
+            i = int(nom_sem[1])  # le n° du semestre
+            semestres_i = {
+                fid: semestres_significatifs[fid]
+                for fid in semestres_significatifs
+                if semestres_significatifs[fid].semestre_id == i
+            }  # les semestres de n°i de l'étudiant
+            self.cursus[etudid][nom_sem] = semestres_i
+
+
+    def get_trajectoire(self, etudid: int, formsemestre_final: FormSemestre):
+        """Ensemble des semestres parcourus par
+        un étudiant pour l'amener à un semestre terminal.
+
+        Par ex: si formsemestre_terminal est un S3, ensemble des S1,
+        S2, S3 suivi pour l'amener au S3 (il peut y avoir plusieurs S1,
+        ou S2, ou S3 s'il a redoublé).
+
+        Les semestres parcourus sont antérieurs (en terme de date de fin)
+        au formsemestre_terminal.
+
+        Args:
+            etudid: L'identifiant de l'étudiant
+            formsemestre_final: le semestre final visé
+        """
+        numero_semestre_terminal = formsemestre_final.semestre_id
+        semestres_significatifs = self.get_semestres_significatifs(etudid)
+
+        """Semestres de n° inférieur (pax ex: des S1, S2, S3 pour un S3 terminal) et qui lui sont antérieurs"""
+        semestres_aggreges = {}
+        for fid in semestres_significatifs:
+            semestre = semestres_significatifs[fid]
+            if (
+                semestre.semestre_id <= numero_semestre_terminal
+                and semestre.date_fin <= formsemestre_final.date_fin
+            ):
+                semestres_aggreges[fid] = semestre
+        return semestres_aggreges
+
+    def get_formsemestres_terminaux_aggregat(self, aggregat: str):
+        """Pour un aggrégat donné, ensemble des formsemestres terminaux possibles pour l'aggrégat
+        (pour l'aggrégat '3S' incluant S1+S2+S3, a pour semestre terminal S3).
+        Ces formsemestres traduisent :
+
+        * les différents parcours des étudiants liés par exemple au choix de modalité (par ex: S1 FI + S2 FI + S3 FI
+          ou S1 FI + S2 FI + S3 UFA), en renvoyant les formsemestre_id du S3 FI et du S3 UFA.
+        * les éventuelles situations de redoublement (par ex pour 1 étudiant ayant redoublé sa 2ème année :
+          S1 + S2 + S3 (1ère session) et S1 + S2 + S3 + S4 + S3 (2ème session), en renvoyant les formsemestre_id du
+          S3 (1ère session) et du S3 (2ème session)
+
+        Args:
+            aggregat: L'aggrégat
+
+        Returns:
+            Un dictionnaire ``{fid: FormSemestre(fid)}``
+        """
+        formsemestres_terminaux = {}
+        for etudid in self.trajectoires:
+            if self.trajectoires[etudid][aggregat]:
+                trajectoire = self.trajectoires[etudid][aggregat]
+                """Le semestre terminal de l'étudiant de l'aggrégat"""
+                fid = trajectoire.semestre_final.formsemestre_id
+                formsemestres_terminaux[fid] = trajectoire.semestre_final
+        return formsemestres_terminaux
+
+    def get_formsemestres(self, semestres_recherches=None):
+        """Ayant connaissance des étudiants dont il faut calculer les moyennes pour
+        le jury PE (attribut `self.etudiant_ids) et de leur cursus (semestres
+        parcourus),
+        renvoie un dictionnaire ``{fid: FormSemestre(fid)}``
+        contenant l'ensemble des formsemestres de leurs cursus, dont il faudra calculer
+        la moyenne.
+        Les formsemestres sont limités à ceux indiqués dans ``semestres_recherches``.
+
+        Args:
+            semestres_recherches: Une liste ou une chaine de caractères parmi :
+
+            * None : pour obtenir tous les formsemestres du jury
+            * 'Si' : pour obtenir les semestres de n° i (par ex. 'S1')
+            * 'iA' : pour obtenir les semestres de l'année i (par ex. '1A' donne ['S1, 'S2'])
+            * '3S', '4S' : pour obtenir les combinaisons de semestres définies par les aggrégats
+
+        Returns:
+            Un dictionnaire de la forme ``{fid: FormSemestre(fid)}``
+
+        Remarque:
+            Une liste de la forme ``[ 'Si', 'iA' , ... ]`` (combinant les formats précédents) est possible.
+        """
+        if semestres_recherches is None:
+            """Appel récursif pour obtenir tous les semestres (validants)"""
+            semestres = self.get_formsemestres(pe_comp.AGGREGAT_DIPLOMANT)
+            return semestres
+        elif isinstance(semestres_recherches, list):
+            """Appel récursif sur tous les éléments de la liste"""
+            semestres = {}
+            for elmt in semestres_recherches:
+                semestres_elmt = self.get_formsemestres(elmt)
+                semestres = semestres | semestres_elmt
+            return semestres
+        elif (
+            isinstance(semestres_recherches, str)
+            and semestres_recherches in pe_comp.TOUS_LES_AGGREGATS
+        ):
+            """Cas d'un aggrégat avec appel récursif sur toutes les entrées de l'aggrégat"""
+            semestres = self.get_formsemestres(
+                pe_comp.PARCOURS[semestres_recherches]["aggregat"]
+            )
+            return semestres
+        elif (
+            isinstance(semestres_recherches, str)
+            and semestres_recherches in pe_comp.TOUS_LES_SEMESTRES
+        ):
+            """semestres_recherches est un nom de semestre de type S1,
+            pour une recherche parmi les étudiants à prendre en compte
+            dans le jury (diplômé et redoublants non diplômé)
+            """
+            nom_sem = semestres_recherches
+            semestres = {}
+            for etudid in self.etudiants_ids:
+                if self.cursus[etudid][nom_sem]:
+                    semestres = semestres | self.cursus[etudid][nom_sem]
+            return semestres
+        else:
+            raise ValueError("Probleme de paramètres d'appel dans get_formsemestreids")
+
+    def nbre_etapes_max_diplomes(self):
+        """Connaissant les étudiants diplomes du jury PE,
+        nombre de semestres (étapes) maximum suivis par les étudiants du jury.
+        """
+        nbres_semestres = []
+        for etudid in self.diplomes_ids:
+            nbres_semestres.append( self.cursus[etudid]["nb_semestres"] )
+        return max(nbres_semestres)
+
+
+def get_etudiants_dans_semestres(semestres: dict[int, FormSemestre]) -> set:
+    """Ensemble d'identifiants des étudiants (identifiés via leur ``etudid``)
+    inscrits à l'un des semestres de la liste de ``semestres``.
+
+    Remarque : Les ``cosemestres`` sont généralement obtenus avec ``sco_formsemestre.do_formsemestre_list()``
+
+    Args:
+        semestres: Un dictionnaire ``{fid: Formsemestre(fid)}`` donnant un
+                   ensemble d'identifiant de semestres
+
+    Returns:
+        Un ensemble d``etudid``
+    """
+
+    etudiants_ids = set()
+    for fid, sem in semestres.items():  # pour chacun des semestres de la liste
+        etudiants_du_sem = {ins.etudid for ins in sem.inscriptions}
+
+        pe_print(f"  --> {sem} : {len(etudiants_du_sem)} etudiants")
+        etudiants_ids = (
+            etudiants_ids | etudiants_du_sem
+        )  # incluant la suppression des doublons
+
+    return etudiants_ids
+
+
+def annee_diplome(identite: Identite) -> int:
+    """L'année de diplôme prévue d'un étudiant en fonction de ses semestres
+    d'inscription (pour un BUT).
+
+    Args:
+        identite: L'identité d'un étudiant
+
+    Returns:
+        L'année prévue de sa diplômation
+
+    NOTE: Pourrait être déplacé dans app.models.etudiants.Identite
+    """
+    formsemestres = identite.get_formsemestres()
+    if formsemestres:
+        return max(
+            [
+                pe_comp.get_annee_diplome_semestre(sem_base)
+                for sem_base in formsemestres
+            ]
+        )
+    else:
+        return None
+
+
+def arret_de_formation(identite: Identite, cosemestres: list[FormSemestre]) -> bool:
+    """Détermine si un étudiant a arrêté sa formation.  Il peut s'agir :
+
+    * d'une réorientation à l'initiative du jury de semestre ou d'une démission (on pourrait
+      utiliser les code NAR pour réorienté & DEM pour démissionnaire des résultats du jury renseigné dans la BDD,
+      mais pas nécessaire ici)
+
+    * d'un arrêt volontaire : l'étudiant disparait des listes d'inscrits (sans pour autant avoir été indiqué NAR ou DEM).
+
+    Dans les cas, on considérera que l'étudiant a arrêté sa formation s'il n'est pas dans l'un des "derniers" cosemestres
+    (semestres conduisant à la même année de diplômation) connu dans Scodoc.
+
+    Par ex: au moment du jury PE en fin de S5 (pas de S6 renseigné dans Scodoc), l'étudiant doit appartenir à une
+    instance des S5 qui conduisent à la diplomation dans l'année visée. S'il n'est que dans un S4, il a sans doute
+    arrêté. A moins qu'il ne soit parti à l'étranger et là, pas de notes.
+    TODO:: Cas de l'étranger, à coder/tester
+
+    **Attention** : Cela suppose que toutes les instances d'un semestre donné (par ex: toutes les instances de S6
+    accueillant un étudiant soient créées ; sinon les étudiants non inscrits dans un S6 seront considérés comme
+    ayant abandonnés)
+    TODO:: Peut-être à mettre en regard avec les propositions d'inscriptions d'étudiants dans un nouveau semestre
+
+    Pour chaque étudiant, recherche son dernier semestre en date (validé ou non) et
+    regarde s'il n'existe pas parmi les semestres existants dans Scodoc un semestre :
+    * dont les dates sont postérieures (en terme de date de début)
+    * de n° au moins égal à celui de son dernier semestre valide (S5 -> S5 ou S5 -> S6)
+    dans lequel il aurait pu s'inscrire mais ne l'a pas fait.
+
+    Args:
+        identite: L'identité d'un étudiant
+        cosemestres: Les semestres donnant lieu à diplômation (sans redoublement) en date du jury
+
+    Returns:
+        Est-il réorienté, démissionnaire ou a-t-il arrêté de son propre chef sa formation ?
+
+    TODO:: A reprendre pour le cas des étudiants à l'étranger
+    TODO:: A reprendre si BUT avec semestres décalés
+    """
+    etudid = identite.etudid
+
+    """Son dernier semestre en date"""
+    semestres = {sem.semestre_id: sem for sem in identite.get_formsemestres()}
+    dernier_formsemestre = get_dernier_semestre_en_date(semestres)
+    numero_dernier_formsemestre = dernier_formsemestre.semestre_id
+
+    """Les numéro de semestres possible dans lesquels il pourrait s'incrire"""
+    # semestre impair => passage de droit en semestre pair suivant (effet de l'annualisation)
+    if numero_dernier_formsemestre % 2 == 1:
+        numeros_possibles = list(
+            range(numero_dernier_formsemestre + 1, pe_comp.NBRE_SEMESTRES_DIPLOMANT)
+        )
+    # semestre pair => passage en année supérieure ou redoublement
+    else:  #
+        numeros_possibles = list(
+            range(
+                max(numero_dernier_formsemestre - 1, 1),
+                pe_comp.NBRE_SEMESTRES_DIPLOMANT,
+            )
+        )
+
+    """Y-a-t-il des cosemestres dans lesquels il aurait pu s'incrire ?"""
+    formsestres_superieurs_possibles = []
+    for fid, sem in cosemestres.items():  # Les semestres ayant des inscrits
+        if (
+            fid != dernier_formsemestre.formsemestre_id
+            and sem.semestre_id in numeros_possibles
+            and sem.date_debut.year >= dernier_formsemestre.date_debut.year
+        ):  # date de debut des semestres possibles postérieur au dernier semestre de l'étudiant et de niveau plus élevé que le dernier semestre valide de l'étudiant
+            formsestres_superieurs_possibles.append(fid)
+
+    if len(formsestres_superieurs_possibles) > 0:
+        return True
+
+    return False
+
+
+
+
+def get_dernier_semestre_en_date(semestres: dict[int, FormSemestre]) -> FormSemestre:
+    """Renvoie le dernier semestre en **date de fin** d'un dictionnaire
+    de semestres (potentiellement non trié) de la forme ``{fid: FormSemestre(fid)}``.
+
+    Args:
+        semestres: Un dictionnaire de semestres
+
+    Return:
+        Le FormSemestre du semestre le plus récent
+    """
+    if semestres:
+        fid_dernier_semestre = list(semestres.keys())[0]
+        dernier_semestre: FormSemestre = semestres[fid_dernier_semestre]
+        for fid in semestres:
+            if semestres[fid].date_fin > dernier_semestre.date_fin:
+                dernier_semestre = semestres[fid]
+        return dernier_semestre
+    else:
+        return None
+
+

app/pe/pe_interclasstag.py

@@ -0,0 +1,125 @@
+
+from app.pe.pe_tabletags import TableTag
+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
+import numpy as np
+
+
+class AggregatInterclasseTag(TableTag):
+    """Interclasse l'ensemble des étudiants diplômés à une année
+    donnée (celle du jury), pour un aggrégat donné (par ex: 'S2', '3S')
+    en reportant :
+
+    * les moyennes obtenues sur la trajectoire qu'il ont suivi pour atteindre le numéro de semestre de fin de l'aggrégat (indépendamment de son
+    formsemestres)
+    * calculant le classement sur les étudiants diplômes
+    """
+
+    # -------------------------------------------------------------------------------------------------------------------
+    def __init__(
+        self,
+        nom_aggregat: str,
+        etudiants: EtudiantsJuryPE,
+        trajectoires_jury_pe: TrajectoiresJuryPE,
+        trajectoires_taggues: dict[tuple, TrajectoireTag],
+    ):
+        """"""
+        """Table nommée au nom de l'aggrégat (par ex: 3S"""
+        TableTag.__init__(self, nom_aggregat)
+
+        """Les étudiants diplômés et leurs trajectoires (cf. trajectoires.suivis)"""
+        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
+        """
+        self.trajectoires: dict[int, Trajectoire] = {}
+        for trajectoire_id in trajectoires_jury_pe.trajectoires:
+            trajectoire = trajectoires_jury_pe.trajectoires[trajectoire_id]
+            if trajectoire_id[0] == nom_aggregat:
+                self.trajectoires[trajectoire_id] = trajectoire
+
+        self.trajectoires_taggues: dict[int, Trajectoire] = {}
+        for trajectoire_id in self.trajectoires:
+            self.trajectoires_taggues[trajectoire_id] = trajectoires_taggues[
+                trajectoire_id
+            ]
+
+        """Les trajectoires suivies par les étudiants du jury, en ne gardant que 
+        celles associées aux diplomés"""
+        self.suivi: dict[int, Trajectoire] = {}
+        for etudid in self.diplomes_ids:
+            self.suivi[etudid] = trajectoires_jury_pe.suivi[etudid][nom_aggregat]
+
+        """Les tags"""
+        self.tags_sorted = self.do_taglist()
+
+        """Construit la matrice de notes"""
+        self.notes = self.compute_notes_matrice()
+
+        """Synthétise les moyennes/classements par tag"""
+        self.moyennes_tags = {}
+        for tag in self.tags_sorted:
+            moy_gen_tag = self.notes[tag]
+            class_gen_tag = moy_sem.comp_ranks_series(moy_gen_tag)[1]  # en int
+            self.moyennes_tags[tag] = {
+                "notes": moy_gen_tag,
+                "classements": class_gen_tag,
+                "min": moy_gen_tag.min(),
+                "max": moy_gen_tag.max(),
+                "moy": moy_gen_tag.mean(),
+                "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
+
+        Returns:
+            Une liste de tags triés par ordre alphabétique
+        """
+        tags = []
+        for trajectoire_id in self.trajectoires_taggues:
+            trajectoire = self.trajectoires_taggues[trajectoire_id]
+            tags.extend(trajectoire.tags_sorted)
+        return sorted(set(tags))
+
+
+    def compute_notes_matrice(self):
+        """Construit la matrice de notes (etudid x tags)
+        retraçant les moyennes obtenues par les étudiants dans les semestres associés à
+        l'aggrégat (une trajectoire ayant pour numéro de semestre final, celui de l'aggrégat).
+        """
+        nb_tags = len(self.tags_sorted)
+        nb_etudiants = len(self.diplomes_ids)
+
+        """Index de la matrice (etudids -> dim 0, tags -> dim 1)"""
+        etudids = list(self.diplomes_ids)
+        tags = self.tags_sorted
+
+        """Partant d'un dataframe vierge"""
+        df = pd.DataFrame(np.nan, index=etudids, columns=tags)
+
+        for trajectoire_id in self.trajectoires_taggues:
+            """Charge les moyennes par tag de la trajectoire tagguée"""
+            notes = self.trajectoires_taggues[trajectoire_id].notes
+
+            """Etudiants/Tags communs entre la trajectoire_tagguée et les données interclassées"""
+            etudids_communs = df.index.intersection(notes.index)
+            tags_communs = df.columns.intersection(notes.columns)
+
+            """Injecte les notes par tag"""
+            df.loc[etudids_communs, tags_communs] = notes.loc[
+                etudids_communs, tags_communs
+            ]
+
+        return df
+

app/pe/pe_jury.py

@@ -0,0 +1,480 @@
+# -*- mode: python -*-
+# -*- coding: utf-8 -*-
+
+##############################################################################
+#
+# Gestion scolarite IUT
+#
+# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+#   Emmanuel Viennet      emmanuel.viennet@viennet.net
+#
+##############################################################################
+
+##############################################################################
+#  Module "Avis de poursuite d'étude"
+#  conçu et développé par Cléo Baras (IUT de Grenoble)
+##############################################################################
+
+"""
+Created on Fri Sep  9 09:15:05 2016
+
+@author: barasc
+"""
+
+# ----------------------------------------------------------
+# Ensemble des fonctions et des classes
+# permettant les calculs preliminaires (hors affichage)
+# a l'edition d'un jury de poursuites d'etudes
+# ----------------------------------------------------------
+
+import io
+import os
+from zipfile import ZipFile
+
+
+from app.comp import res_sem
+from app.comp.res_compat import NotesTableCompat
+from app.models import FormSemestre
+from app.models.etudiants import Identite
+
+from app.scodoc.gen_tables import GenTable, SeqGenTable
+import app.scodoc.sco_utils as scu
+from app.pe.pe_etudiant import EtudiantsJuryPE
+from app.pe.pe_trajectoire import TrajectoiresJuryPE, Trajectoire
+import app.pe.pe_comp as pe_comp
+from app.pe.pe_semtag import SemestreTag
+from app.pe.pe_interclasstag import AggregatInterclasseTag
+from app.pe.pe_trajectoiretag import TrajectoireTag
+import app.pe.pe_affichage as pe_affichage
+
+import pandas as pd
+import numpy as np
+
+# ----------------------------------------------------------------------------------------
+
+
+# ----------------------------------------------------------------------------------------
+class JuryPE(object):
+    """Classe mémorisant toutes les informations nécessaires pour établir un jury de PE.
+        Modèle basé sur NotesTable.
+
+        Attributs :
+
+        * diplome : l'année d'obtention du diplome BUT et du jury de PE (généralement février XXXX)
+        * juryEtudDict : dictionnaire récapitulant les étudiants participant au jury PE (données administratives +
+          celles des semestres valides à prendre en compte permettant le calcul des moyennes  ...
+          ``{'etudid : { 'nom', 'prenom', 'civilite', 'diplome', '',  }}``
+    a
+          Rq: il contient à la fois les étudiants qui vont être diplomés à la date prévue
+          et ceux qui sont éliminés (abandon, redoublement, ...) pour affichage alternatif
+    """
+
+    # Variables de classe décrivant les aggrégats, leur ordre d'apparition temporelle et
+    # leur affichage dans les avis latex
+
+    # ------------------------------------------------------------------------------------------------------------------
+    def __init__(self, diplome, formation_id):
+        """
+        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,
+        2. tous les étudiants susceptibles à ce stade (au regard de leur parcours) d'être diplomés.
+
+        Args:
+            sem_base: le FormSemestre donnant le semestre à la base du jury PE
+            semBase: le dictionnaire sem donnant la base du jury (CB: TODO: A supprimer à long term)
+            meme_programme: si True, impose un même programme pour tous les étudiants participant au jury,
+                            si False, permet des programmes differents
+        """
+        "L'année du diplome"
+        self.diplome = diplome
+
+        "La formation associée au diplome"
+        self.formation_id = formation_id
+
+        "Un zip où ranger les fichiers générés"
+        self.nom_export_zip = "Jury_PE_%s" % self.diplome
+        self.zipdata = io.BytesIO()
+        self.zipfile = ZipFile(self.zipdata, "w")
+
+        """Chargement des étudiants à prendre en compte dans le jury"""
+        pe_comp.pe_print(
+            f"*** Recherche et chargement des étudiants diplômés en {self.diplome} pour la formation {self.formation_id}"
+        )
+        self.etudiants = EtudiantsJuryPE(self.diplome)  # Les infos sur les étudiants
+        self.etudiants.find_etudiants(self.formation_id)
+        self.diplomes_ids = self.etudiants.diplomes_ids
+
+        """Génère les semestres taggués (avec le calcul des moyennes) pour le jury PE"""
+        pe_comp.pe_print("*** Génère les semestres taggués")
+        self.semestres_taggues = compute_semestres_tag(self.etudiants)
+
+        if pe_comp.PE_DEBUG:
+            """Intègre le bilan des semestres taggués au zip final"""
+            for fid in self.semestres_taggues:
+                formsemestretag = self.semestres_taggues[fid]
+                filename = formsemestretag.nom.replace(" ", "_") + ".csv"
+                pe_comp.pe_print(f"    - Export csv de {filename} ")
+                self.add_file_to_zip(
+                    filename, formsemestretag.str_tagtable(), path="details_semestres"
+                )
+
+        """Génère les trajectoires (combinaison de semestres suivis 
+        par un étudiant pour atteindre le semestre final d'un aggrégat)
+        """
+        pe_comp.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 moyennes par tags des trajectoires"""
+        pe_comp.pe_print("*** Calcule les moyennes par tag des trajectoires possibles")
+        self.trajectoires_tagguees = compute_trajectoires_tag(
+            self.trajectoires, self.etudiants, self.semestres_taggues
+        )
+
+        if pe_comp.PE_DEBUG:
+            """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_comp.pe_print(f"    - Export csv de {filename} ")
+                self.add_file_to_zip(
+                    filename,
+                    trajectoire_tagguee.str_tagtable(),
+                    path="details_semestres",
+                )
+
+        """Génère les interclassements (par promo et) par (nom d') aggrégat"""
+        pe_comp.pe_print("*** Génère les interclassements par aggrégat")
+        self.interclassements_taggues = compute_interclassements(
+            self.etudiants, self.trajectoires, self.trajectoires_tagguees
+        )
+
+        if pe_comp.PE_DEBUG:
+            """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_comp.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"""
+        self.synthese = self.synthetise_juryPE()
+
+        # Export des données => mode 1 seule feuille -> supprimé
+        pe_comp.pe_print("*** Export du jury de synthese")
+        filename = "synthese_jury_" + str(self.diplome) + ".xlsx"
+        with pd.ExcelWriter(filename, engine="openpyxl") as writer:
+            for onglet in self.synthese:
+                df = self.synthese[onglet]
+                df.to_excel(
+                    writer, onglet, index=True, header=True
+                )  # écriture dans l'onglet
+                # worksheet = writer.sheets[onglet]  # l'on
+
+        self.add_file_to_zip(
+            filename,
+            open(filename, "rb").read(),
+        )
+
+        """Fin !!!! Tada :)"""
+
+    def add_file_to_zip(self, filename: str, data, path=""):
+        """Add a file to our zip
+        All files under NOM_EXPORT_ZIP/
+        path may specify a subdirectory
+
+        Args:
+             filename: Le nom du fichier à intégrer au zip
+             data: Les données du fichier
+             path: Un dossier dans l'arborescence du zip
+        """
+        path_in_zip = os.path.join(path, filename)  # self.nom_export_zip,
+        self.zipfile.writestr(path_in_zip, data)
+
+    def get_zipped_data(self):
+        """returns file-like data with a zip of all generated (CSV) files.
+        Reset file cursor at the beginning !
+        """
+        if self.zipfile:
+            self.zipfile.close()
+            self.zipfile = None
+        self.zipdata.seek(0)
+        return self.zipdata
+
+    def do_tags_list(self, interclassements: dict[str, AggregatInterclasseTag]):
+        """La liste des tags extraites des interclassements"""
+        tags = []
+        for aggregat in interclassements:
+            interclass = interclassements[aggregat]
+            if interclass.tags_sorted:
+                tags.extend(interclass.tags_sorted)
+        tags = sorted(set(tags))
+        return tags
+
+    # **************************************************************************************************************** #
+    # Méthodes pour la synthèse du juryPE
+    # *****************************************************************************************************************
+
+    def synthetise_juryPE(self):
+        """Synthétise tous les résultats du jury PE dans des dataframes"""
+
+        pe_comp.pe_print("*** Synthèse finale des moyennes ***")
+
+        synthese = {}
+        pe_comp.pe_print("  -> Synthèse des données administratives")
+        synthese["administratif"] = self.df_administratif()
+
+        tags = self.do_tags_list(self.interclassements_taggues)
+        for tag in tags:
+            pe_comp.pe_print(f"  -> Synthèse du tag {tag}")
+            synthese[tag] = self.df_tag(tag)
+        return synthese
+
+    def df_administratif(self):
+        """Synthétise toutes les données administratives des étudiants"""
+
+        etudids = list(self.diplomes_ids)
+
+        """Récupération des  données des étudiants"""
+        administratif = {}
+        nbre_semestres_max = self.etudiants.nbre_etapes_max_diplomes()
+
+        for etudid in etudids:
+            etudiant = self.etudiants.identites[etudid]
+            cursus = self.etudiants.cursus[etudid]
+            formsemestres = cursus["formsemestres"]
+
+            administratif[etudid] = {
+                "Nom": etudiant.nom,
+                "Prenom": etudiant.prenom,
+                "Civilite": etudiant.civilite_str,
+                "Age": pe_comp.calcul_age(etudiant.date_naissance),
+                "Date d'entree": cursus["entree"],
+                "Date de diplome": cursus["diplome"],
+                "Nbre de semestres": len(formsemestres),
+            }
+
+            # Ajout des noms de semestres parcourus
+            etapes = pe_affichage.etapes_du_cursus(formsemestres, nbre_semestres_max)
+            administratif[etudid] |= etapes
+
+        """Construction du dataframe"""
+        df = pd.DataFrame.from_dict(administratif, orient="index")
+
+        """Tri par nom/prénom"""
+        df.sort_values(by=["Nom", "Prenom"], inplace = True)
+        return df
+
+    def df_tag(self, tag):
+        """Génère le DataFrame synthétisant les moyennes/classements (groupe,
+        interclassement promo) pour tous les aggrégats prévus,
+        tels que fourni dans l'excel final.
+
+        Args:
+            tag: Un des tags (a minima `but`)
+
+        Returns:
+        """
+
+        etudids = list(self.diplomes_ids)
+        aggregats = pe_comp.TOUS_LES_PARCOURS
+
+        donnees = {}
+
+        for etudid in etudids:
+            etudiant = self.etudiants.identites[etudid]
+            donnees[etudid] = {
+                "Nom": etudiant.nom,
+                "Prenom": etudiant.prenom,
+                "Civilite": etudiant.civilite_str,
+            }
+
+            for aggregat in aggregats:
+                """La trajectoire de l'étudiant sur l'aggrégat"""
+                trajectoire = self.trajectoires.suivi[etudid][aggregat]
+                """Les moyennes par tag de cette trajectoire"""
+                if trajectoire:
+                    trajectoire_tagguee = self.trajectoires_tagguees[
+                        trajectoire.trajectoire_id
+                    ]
+                    bilan = trajectoire_tagguee.moyennes_tags[tag]
+
+                    donnees[etudid] |= {
+                        f"{aggregat} notes ": f"{bilan['notes'].loc[etudid]:.1f}",
+                        f"{aggregat} class. (groupe)": f"{bilan['classements'].loc[etudid]}/{bilan['nb_inscrits']}",
+                        f"{aggregat} min/moy/max (groupe)": f"{bilan['min']:.1f}/{bilan['moy']:.1f}/{bilan['max']:.1f}",
+                    }
+                else:
+                    donnees[etudid] |= {
+                        f"{aggregat} notes ": "-",
+                        f"{aggregat} class. (groupe)": "-",
+                        f"{aggregat} min/moy/max (groupe)": "-",
+                    }
+
+                """L'interclassement"""
+                interclass = self.interclassements_taggues[aggregat]
+                if tag in interclass.moyennes_tags:
+                    bilan = interclass.moyennes_tags[tag]
+
+                    donnees[etudid] |= {
+                        f"{aggregat} class. (promo)": f"{bilan['classements'].loc[etudid]}/{bilan['nb_inscrits']}",
+                        f"{aggregat} min/moy/max (promo)": f"{bilan['min']:.1f}/{bilan['moy']:.1f}/{bilan['max']:.1f}",
+                    }
+                else:
+                    donnees[etudid] |= {
+                        f"{aggregat} class. (promo)": "-",
+                        f"{aggregat} min/moy/max (promo)": "-",
+                    }
+
+            # Fin de l'aggrégat
+        """Construction du dataFrame"""
+        df = pd.DataFrame.from_dict(donnees, orient="index")
+
+        """Tri par nom/prénom"""
+        df.sort_values(by=["Nom", "Prenom"], inplace = True)
+        return df
+
+    def table_syntheseJury(self, mode="singlesheet"):  #  was str_syntheseJury
+        """Table(s) du jury
+        mode: singlesheet ou multiplesheet pour export excel
+        """
+        sT = SeqGenTable()  # le fichier excel à générer
+
+        if mode == "singlesheet":
+            return sT.get_genTable("singlesheet")
+        else:
+            return sT
+
+
+def compute_semestres_tag(etudiants: EtudiantsJuryPE) -> dict:
+    """Créé les semestres taggués, de type 'S1', 'S2', ..., pour un groupe d'étudiants donnés.
+    Chaque semestre taggué est rattaché à l'un des FormSemestre faisant partie du cursus scolaire
+    des étudiants (cf. attribut etudiants.cursus).
+    En crééant le semestre taggué, sont calculées les moyennes/classements par tag associé.
+        .
+
+    Args:
+        etudiants: Un groupe d'étudiants participant au jury
+
+    Returns:
+        Un dictionnaire {fid: SemestreTag(fid)}
+    """
+
+    """Création des semestres taggués, de type 'S1', 'S2', ..."""
+    pe_comp.pe_print("*** Création des semestres taggués")
+
+    formsemestres = etudiants.get_formsemestres(
+        semestres_recherches=pe_comp.TOUS_LES_SEMESTRES
+    )
+
+    semestres_tags = {}
+    for frmsem_id, formsemestre in formsemestres.items():
+        """Choix d'un nom pour le semestretag"""
+        nom = "S%d %d %d-%d" % (
+            formsemestre.semestre_id,
+            frmsem_id,
+            formsemestre.date_debut.year,
+            formsemestre.date_fin.year,
+        )
+
+        pe_comp.pe_print(f"  --> Semestre taggué {nom} sur la base de {formsemestre}")
+
+        """Créé le semestre_tag et exécute les calculs de moyennes"""
+        formsemestretag = SemestreTag(nom, frmsem_id)
+
+        """Stocke le semestre taggué"""
+        semestres_tags[frmsem_id] = formsemestretag
+
+    return semestres_tags
+
+
+def compute_trajectoires_tag(
+    trajectoires: TrajectoiresJuryPE,
+    etudiants: EtudiantsJuryPE,
+    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.
+
+    Pour rappel : Chaque trajectoire est identifiée un nom d'aggrégat et par un formsemestre terminal.
+
+    Par exemple :
+
+    * combinaisons '3S' : S1+S2+S3 en prenant en compte tous les S3 qu'ont fréquenté les
+      étudiants du jury PE. Ces S3 marquent les formsemestre terminal de chaque combinaison.
+
+    * combinaisons 'S2' : 1 seul S2 pour des étudiants n'ayant pas redoublé, 2 pour des redoublants (dont les
+      notes seront moyennées sur leur 2 semestres S2). Ces combinaisons ont pour formsemestre le dernier S2 en
+      date (le S2 redoublé par les redoublants est forcément antérieur)
+
+
+    Args:
+        etudiants: Les données des étudiants
+        semestres_tag: Les semestres tag (pour lesquels des moyennes par tag ont été calculés)
+
+    Return:
+        Un dictionnaire de la forme {nom_aggregat: {fid_terminal: SetTag(fid_terminal)} }
+    """
+
+    pe_comp.pe_print(" *** Création des aggrégats ")
+
+    trajectoires_tagguees = {}
+
+    for trajectoire_id in trajectoires.trajectoires:
+        trajectoire = trajectoires.trajectoires[trajectoire_id]
+        nom = trajectoire.get_repr()
+
+        pe_comp.pe_print(f"   --> Fusion {nom}")
+
+        """Création de la trajectoire_tagguee associée"""
+        trajectoire_tagguee = TrajectoireTag(
+            nom, trajectoire, semestres_taggues, etudiants
+        )
+
+        """Mémorise le résultat"""
+        trajectoires_tagguees[trajectoire_id] = trajectoire_tagguee
+
+    return trajectoires_tagguees
+
+
+def compute_interclassements(
+    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 établi au regard du nombre
+    d'étudiants ayant participé au même aggrégat.
+    """
+    pe_comp.pe_print(" Interclassement sur la promo")
+
+    aggregats_interclasses_taggues = {}
+    for nom_aggregat in pe_comp.TOUS_LES_SEMESTRES + pe_comp.TOUS_LES_AGGREGATS:
+        pe_comp.pe_print(f"   --> {nom_aggregat}")
+        interclass = AggregatInterclasseTag(
+            nom_aggregat, etudiants, trajectoires_jury_pe, trajectoires_tagguees
+        )
+        aggregats_interclasses_taggues[nom_aggregat] = interclass
+    return aggregats_interclasses_taggues

app/pe/pe_semtag.py

@@ -37,110 +37,96 @@ Created on Fri Sep  9 09:15:05 2016
 """
 
 from app import db, log
-from app.comp import res_sem
+from app.comp import res_sem, moy_ue, moy_sem
 from app.comp.res_compat import NotesTableCompat
+from app.comp.res_sem import load_formsemestre_results
 from app.models import FormSemestre
 from app.models.moduleimpls import ModuleImpl
-from app.pe import pe_tagtable
 
-from app.scodoc import codes_cursus
 from app.scodoc import sco_tag_module
-from app.scodoc import sco_utils as scu
+from app.scodoc.codes_cursus import UE_SPORT
+import app.pe.pe_comp as pe_comp
+from app.pe.pe_tabletags import (TableTag, TAGS_RESERVES)
 
-
+class SemestreTag(TableTag):
-class SemestreTag(pe_tagtable.TableTag):
+    """Un SemestreTag représente les résultats des étudiants à un semestre, en donnant
-    """Un SemestreTag représente un tableau de notes (basé sur notesTable)
+    accès aux moyennes par tag.
-    modélisant les résultats des étudiants sous forme de moyennes par tag.
+    Il s'appuie principalement sur FormSemestre et sur ResultatsSemestreBUT.
-
-    Attributs récupérés via des NotesTables :
-    - nt: le tableau de notes du semestre considéré
-    - nt.inscrlist: étudiants inscrits à ce semestre, par ordre alphabétique (avec demissions)
-    - nt.identdict: { etudid : ident }
-    - liste des moduleimpl { ... 'module_id', ...}
-
-    Attributs supplémentaires :
-    - inscrlist/identdict: étudiants inscrits hors démissionnaires ou défaillants
-    - _tagdict : Dictionnaire résumant les tags et les modules du semestre auxquels ils sont liés
-
-
-    Attributs hérités de TableTag :
-    - nom :
-    - resultats: {tag: { etudid: (note_moy, somme_coff), ...} , ...}
-    - rang
-    - statistiques
-
-    Redéfinition :
-    - get_etudids() : les etudids des étudiants non défaillants ni démissionnaires
     """
 
-    DEBUG = True
-
     # -----------------------------------------------------------------------------
     # Fonctions d'initialisation
     # -----------------------------------------------------------------------------
-    def __init__(self, notetable, sem):  # Initialisation sur la base d'une notetable
+    def __init__(self, nom: str, formsemestre_id: int):
-        """Instantiation d'un objet SemestreTag à partir d'un tableau de note
-        et des informations sur le semestre pour le dater
         """
-        pe_tagtable.TableTag.__init__(
+        Args:
-            self,
+            nom: Nom à donner au SemestreTag
-            nom="S%d %s %s-%s"
+            formsemestre_id: Identifiant du FormSemestre sur lequel il se base
-            % (
+        """
-                sem["semestre_id"],
+        TableTag.__init__(self, nom=nom)
-                "ENEPS"
-                if "ENEPS" in sem["titre"]
-                else "UFA"
-                if "UFA" in sem["titre"]
-                else "FI",
-                sem["annee_debut"],
-                sem["annee_fin"],
-            ),
-        )
 
-        # Les attributs spécifiques
+        """Le semestre"""
-        self.nt = notetable
+        self.formsemestre_id = formsemestre_id
+        self.formsemestre = FormSemestre.get_formsemestre(formsemestre_id)
 
-        # Les attributs hérités : la liste des étudiants
+        """Les résultats du semestre"""
-        self.inscrlist = [
+        self.nt = load_formsemestre_results(self.formsemestre)
-            etud
-            for etud in self.nt.inscrlist
-            if self.nt.get_etud_etat(etud["etudid"]) == scu.INSCRIT
-        ]
-        self.identdict = {
-            etudid: ident
-            for (etudid, ident) in self.nt.identdict.items()
-            if etudid in self.get_etudids()
-        }  # Liste des étudiants non démissionnaires et non défaillants
 
-        # Les modules pris en compte dans le calcul des moyennes par tag => ceux des UE standards
+        """Les étudiants"""
-        self.modimpls = [
+        self.etuds = self.nt.etuds
-            modimpl
+        self.etudiants = {etud.etudid: etud.etat_civil for etud in self.etuds}
-            for modimpl in self.nt.formsemestre.modimpls_sorted
-            if modimpl.module.ue.type == codes_cursus.UE_STANDARD
-        ]  # la liste des modules (objet modimpl)
-        self.somme_coeffs = sum(
-            [
-                modimpl.module.coefficient
-                for modimpl in self.modimpls
-                if modimpl.module.coefficient is not None
-            ]
-        )
 
-    # -----------------------------------------------------------------------------
+        """Les notes, les modules implémentés triés, les étudiants, les coeffs,
-    def comp_data_semtag(self):
+        récupérés notamment de py:mod:`res_but`
-        """Calcule tous les données numériques associées au semtag"""
+        """
-        # Attributs relatifs aux tag pour les modules pris en compte
+        self.sem_cube = self.nt.sem_cube
-        self.tagdict = (
+        self.modimpls_sorted = self.nt.formsemestre.modimpls_sorted
-            self.do_tagdict()
+        self.modimpl_coefs_df = self.nt.modimpl_coefs_df
-        )  # Dictionnaire résumant les tags et les données (normalisées) des modules du semestre auxquels ils sont liés
 
-        # Calcul des moyennes de chaque étudiant puis ajoute la moyenne au sens "DUT"
+        """Les inscriptions au module et les dispenses d'UE"""
-        for tag in self.tagdict:
+        self.modimpl_inscr_df = self.nt.modimpl_inscr_df
-            self.add_moyennesTag(tag, self.comp_MoyennesTag(tag, force=True))
+        self.ues = self.nt.ues
-        self.add_moyennesTag("dut", self.get_moyennes_DUT())
+        self.ues_inscr_parcours_df = self.nt.load_ues_inscr_parcours()
-        self.taglist = sorted(
+        self.dispense_ues = self.nt.dispense_ues
-            list(self.tagdict.keys()) + ["dut"]
+
-        )  # actualise la liste des tags
+        """Les tags (en supprimant les tags réservés)"""
+        self.tags = get_synthese_tags_semestre(self.nt.formsemestre)
+        for tag in TAGS_RESERVES:
+            if tag in self.tags:
+                del self.tags[tag]
+
+        """Calcul des moyennes & les classements de chaque étudiant à chaque tag"""
+        self.moyennes_tags = {}
+
+        for tag in self.tags:
+            pe_comp.pe_print(f"  -> Traitement du tag {tag}")
+            moy_gen_tag = self.compute_moyenne_tag(tag)
+            class_gen_tag = moy_sem.comp_ranks_series(moy_gen_tag)[1] # en int
+            self.moyennes_tags[tag] = {
+                "notes": moy_gen_tag,
+                "classements": class_gen_tag,
+                "min": moy_gen_tag.min(),
+                "max": moy_gen_tag.max(),
+                "moy": moy_gen_tag.mean(),
+                "nb_inscrits": len(moy_gen_tag),
+            }
+
+        """Ajoute les moyennes générales de BUT pour le semestre considéré"""
+        pe_comp.pe_print(f"  -> Traitement du tag but")
+        moy_gen_but = self.nt.etud_moy_gen
+        class_gen_but = self.nt.etud_moy_gen_ranks_int
+        self.moyennes_tags["but"] = {
+            "notes": moy_gen_but,
+            "classements": class_gen_but,
+            "min": moy_gen_but.min(),
+            "max": moy_gen_but.max(),
+            "moy": moy_gen_but.mean(),
+            "nb_inscrits": len(moy_gen_but),
+        }
+
+        """Synthétise l'ensemble des moyennes dans un dataframe"""
+        self.tags_sorted = sorted(self.moyennes_tags) # les tags par ordre alphabétique
+        self.notes = self.df_tagtable() # Le dataframe synthétique des notes (=moyennes par tag)
 
     # -----------------------------------------------------------------------------
     def get_etudids(self):
@@ -148,89 +134,64 @@ class SemestreTag(pe_tagtable.TableTag):
         return [etud["etudid"] for etud in self.inscrlist]
 
     # -----------------------------------------------------------------------------
-    def do_tagdict(self):
+    def compute_moyenne_tag(self, tag: str) -> list:
-        """Parcourt les modimpl du semestre (instance des modules d'un programme) et synthétise leurs données sous la
+        """Calcule la moyenne des étudiants pour le tag indiqué,
-        forme d'un dictionnaire reliant les tags saisis dans le programme aux
+        pour ce SemestreTag.
-        données des modules qui les concernent, à savoir les modimpl_id, les module_id, le code du module, le coeff,
-        la pondération fournie avec le tag (par défaut 1 si non indiquée).
-        { tagname1 : { modimpl_id1 : { 'module_id' : ..., 'coeff' : ..., 'coeff_norm' : ..., 'ponderation' : ..., 'module_code' : ..., 'ue_xxx' : ...},
-                       modimpl_id2 : ....
-                     },
-          tagname2 : ...
-        }
-        Renvoie le dictionnaire ainsi construit.
 
-        Rq: choix fait de repérer les modules par rapport à leur modimpl_id (valable uniquement pour un semestre), car
+        Sont pris en compte les modules implémentés associés au tag,
-        correspond à la majorité des calculs de moyennes pour les étudiants
+        avec leur éventuel coefficient de **repondération**, en utilisant les notes
-        (seuls ceux qui ont capitalisé des ue auront un régime de calcul différent).
+        chargées pour ce SemestreTag.
-        """
-        tagdict = {}
 
-        for modimpl in self.modimpls:
-            modimpl_id = modimpl.id
-            # liste des tags pour le modimpl concerné:
-            tags = sco_tag_module.module_tag_list(modimpl.module.id)
-
-            for (
-                tag
-            ) in tags:  # tag de la forme "mathématiques", "théorie", "pe:0", "maths:2"
-                [tagname, ponderation] = sco_tag_module.split_tagname_coeff(
-                    tag
-                )  # extrait un tagname et un éventuel coefficient de pondération (par defaut: 1)
-                # tagname = tagname
-                if tagname not in tagdict:  # Ajout d'une clé pour le tag
-                    tagdict[tagname] = {}
-
-                # Ajout du modimpl au tagname considéré
-                tagdict[tagname][modimpl_id] = {
-                    "module_id": modimpl.module.id,  # les données sur le module
-                    "coeff": modimpl.module.coefficient,  # le coeff du module dans le semestre
-                    "ponderation": ponderation,  # la pondération demandée pour le tag sur le module
-                    "module_code": modimpl.module.code,  # le code qui doit se retrouver à l'identique dans des ue capitalisee
-                    "ue_id": modimpl.module.ue.id,  # les données sur l'ue
-                    "ue_code": modimpl.module.ue.ue_code,
-                    "ue_acronyme": modimpl.module.ue.acronyme,
-                }
-        return tagdict
-
-    # -----------------------------------------------------------------------------
-    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.
         Force ou non le calcul de la moyenne lorsque des notes sont manquantes.
 
         Renvoie les informations sous la forme d'une liste
             [ (moy, somme_coeff_normalise, etudid), ...]
         """
-        lesMoyennes = []
-        for etudid in self.get_etudids():
-            (
-                notes,
-                coeffs_norm,
-                ponderations,
-            ) = self.get_listesNotesEtCoeffsTagEtudiant(
-                tag, etudid
-            )  # les notes associées au tag
-            coeffs = comp_coeff_pond(
-                coeffs_norm, ponderations
-            )  # les coeff pondérés par les tags
-            (moyenne, somme_coeffs) = pe_tagtable.moyenne_ponderee_terme_a_terme(
-                notes, coeffs, force=force
-            )
-            lesMoyennes += [
-                (moyenne, somme_coeffs, etudid)
-            ]  # Un tuple (pour classement résumant les données)
-        return lesMoyennes
 
-    # -----------------------------------------------------------------------------
+        """Adaptation du mask de calcul des moyennes au tag visé"""
-    def get_moyennes_DUT(self):
+        modimpls_mask = [
-        """Lit les moyennes DUT du semestre pour tous les étudiants
+            modimpl.module.ue.type != UE_SPORT
-        et les renvoie au même format que comp_MoyennesTag"""
+            for modimpl in self.formsemestre.modimpls_sorted
-        return [
-            (self.nt.etud_moy_gen[etudid], 1.0, etudid) for etudid in self.get_etudids()
         ]
 
+        """Désactive tous les modules qui ne sont pas pris en compte pour ce tag"""
+        for i, modimpl in enumerate(self.formsemestre.modimpls_sorted):
+            if modimpl.moduleimpl_id not in self.tags[tag]:
+                modimpls_mask[i] = False
+
+        """Applique la pondération des coefficients"""
+        modimpl_coefs_ponderes_df = self.modimpl_coefs_df.copy()
+        for modimpl_id in self.tags[tag]:
+            ponderation = self.tags[tag][modimpl_id]["ponderation"]
+            modimpl_coefs_ponderes_df[modimpl_id] *= ponderation
+
+        """Calcule les moyennes pour le tag visé dans chaque UE (dataframe etudid x ues)"""
+        moyennes_ues_tag = moy_ue.compute_ue_moys_apc(
+            self.sem_cube,
+            self.etuds,
+            self.formsemestre.modimpls_sorted,
+            self.modimpl_inscr_df,
+            modimpl_coefs_ponderes_df,
+            modimpls_mask,
+            self.dispense_ues,
+            block=self.formsemestre.block_moyennes,
+        )
+
+        """Les ects"""
+        ects = self.ues_inscr_parcours_df.fillna(0.0) * [
+            ue.ects for ue in self.ues if ue.type != UE_SPORT
+        ]
+
+        """Calcule la moyenne générale dans le semestre (pondérée par le ECTS)"""
+        moy_gen_tag = moy_sem.compute_sem_moys_apc_using_ects(
+            moyennes_ues_tag,
+            ects,
+            formation_id=self.formsemestre.formation_id,
+            skip_empty_ues=True,
+        )
+
+        return moy_gen_tag
+
     # -----------------------------------------------------------------------------
     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.
@@ -319,27 +280,6 @@ class SemestreTag(pe_tagtable.TableTag):
             return self.nt.validations.ue_capitalisees.loc[[etudid]].to_dict("records")
         return []
 
-    # -----------------------------------------------------------------------------
-    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.
-        Les notes et coeff_norm sont extraits grâce à SemestreTag.get_noteEtCoeff_modimpl (donc dans semestre courant ou UE capitalisée).
-        Les pondérations sont celles déclarées avec le tag (cf. _tagdict)."""
-
-        notes = []
-        coeffs_norm = []
-        ponderations = []
-        for moduleimpl_id, modimpl in self.tagdict[
-            tag
-        ].items():  # pour chaque module du semestre relatif au tag
-            (note, coeff_norm) = self.get_noteEtCoeff_modimpl(moduleimpl_id, etudid)
-            if note != None:
-                notes.append(note)
-                coeffs_norm.append(coeff_norm)
-                ponderations.append(modimpl["ponderation"])
-        return (notes, coeffs_norm, ponderations)
-
     # -----------------------------------------------------------------------------
     # Fonctions d'affichage (et d'export csv) des données du semestre en mode debug
     # -----------------------------------------------------------------------------
@@ -435,8 +375,9 @@ class SemestreTag(pe_tagtable.TableTag):
         return chaine
 
     def str_tagsModulesEtCoeffs(self):
-        """Renvoie une chaine affichant la liste des tags associés au semestre, les modules qui les concernent et les coeffs de pondération.
+        """Renvoie une chaine affichant la liste des tags associés au semestre,
-        Plus concrêtement permet d'afficher le contenu de self._tagdict"""
+        les modules qui les concernent et les coeffs de pondération.
+        Plus concrètement permet d'afficher le contenu de self._tagdict"""
         chaine = "Semestre %s d'id %d" % (self.nom, id(self)) + "\n"
         chaine += " -> somme de coeffs: " + str(self.somme_coeffs) + "\n"
         taglist = self.get_all_tags()
@@ -463,25 +404,6 @@ class SemestreTag(pe_tagtable.TableTag):
 
 
 # *********************************************
-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]
-    Les coeff peuvent éventuellement être None auquel cas None est conservé ;
-    Les pondérations sont des floattants
-    """
-    if (
-        coeffs == None
-        or ponderations == None
-        or not isinstance(coeffs, list)
-        or not isinstance(ponderations, list)
-        or len(coeffs) != len(ponderations)
-    ):
-        raise ValueError("Erreur de paramètres dans comp_coeff_pond")
-    return [
-        (None if coeffs[i] == None else coeffs[i] * ponderations[i])
-        for i in range(len(coeffs))
-    ]
 
 
 # -----------------------------------------------------------------------------
@@ -509,3 +431,58 @@ def get_moy_ue_from_nt(nt, etudid, modimpl_id) -> float:
     if ue_status is None:
         return None
     return ue_status["moy"]
+
+
+# -----------------------------------------------------------------------------
+def get_synthese_tags_semestre(formsemestre: FormSemestre):
+    """Etant données les implémentations des modules du semestre (modimpls),
+    synthétise les tags les concernant (tags saisis dans le programme pédagogique)
+    en les associant aux modimpls qui les concernent (modimpl_id, module_id,
+    le code du module, coeff et pondération fournie avec le tag (par défaut 1 si non indiquée)).
+
+    { tagname1: { modimpl_id1: { 'module_id': ...,
+                                 'coeff': ...,
+                                 'coeff_norm': ...,
+                                 'ponderation': ...,
+                                 'module_code': ...,
+                                 'ue_xxx': ...},
+                }
+    }
+
+    Args:
+        formsemestre: Le formsemestre à la base de la recherche des tags
+    """
+    synthese_tags = {}
+
+    """Instance des modules du semestre"""
+    modimpls = formsemestre.modimpls_sorted
+
+    for modimpl in modimpls:
+        modimpl_id = modimpl.id
+
+        """Liste des tags pour le module concerné"""
+        tags = sco_tag_module.module_tag_list(modimpl.module.id)
+
+        """Traitement des tags recensés, chacun pouvant étant de la forme 
+        "mathématiques", "théorie", "pe:0", "maths:2"
+        """
+        for tag in tags:
+            """Extraction du nom du tag et du coeff de pondération"""
+            (tagname, ponderation) = sco_tag_module.split_tagname_coeff(tag)
+
+            """Ajout d'une clé pour le tag"""
+            if tagname not in synthese_tags:
+                synthese_tags[tagname] = {}
+
+            """Ajout du module (modimpl) au tagname considéré"""
+            synthese_tags[tagname][modimpl_id] = {
+                "modimpl": modimpl,  # les données sur le module
+                # "coeff": modimpl.module.coefficient,  # le coeff du module dans le semestre
+                "ponderation": ponderation,  # la pondération demandée pour le tag sur le module
+                # "module_code": modimpl.module.code,  # le code qui doit se retrouver à l'identique dans des ue capitalisee
+                # "ue_id": modimpl.module.ue.id,  # les données sur l'ue
+                # "ue_code": modimpl.module.ue.ue_code,
+                # "ue_acronyme": modimpl.module.ue.acronyme,
+            }
+
+    return synthese_tags

app/pe/pe_settag.py

@@ -1,324 +0,0 @@
-# -*- mode: python -*-
-# -*- coding: utf-8 -*-
-
-##############################################################################
-#
-# Gestion scolarite IUT
-#
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-#
-#   Emmanuel Viennet      emmanuel.viennet@viennet.net
-#
-##############################################################################
-
-##############################################################################
-#  Module "Avis de poursuite d'étude"
-#  conçu et développé par Cléo Baras (IUT de Grenoble)
-##############################################################################
-
-"""
-Created on Fri Sep  9 09:15:05 2016
-
-@author: barasc
-"""
-
-from app.pe.pe_tools import pe_print, PE_DEBUG
-from app.pe import pe_tagtable
-
-
-class SetTag(pe_tagtable.TableTag):
-    """Agrège plusieurs semestres (ou settag) taggués (SemestreTag/Settag de 1 à 4) pour extraire des moyennes
-    et des classements par tag pour un groupe d'étudiants donnés.
-    par. exemple fusion d'un parcours ['S1', 'S2', 'S3'] donnant un nom_combinaison = '3S'
-    Le settag est identifié sur la base du dernier semestre (ici le 'S3') ;
-    les étudiants considérés sont donc ceux inscrits dans ce S3
-    à condition qu'ils disposent d'un parcours sur tous les semestres fusionnés valides (par. ex
-    un etudiant non inscrit dans un S1 mais dans un S2 et un S3 n'est pas pris en compte).
-    """
-
-    # -------------------------------------------------------------------------------------------------------------------
-    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
-    ):
-        """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:
-            self.nom += "_" + nom_sem_final
-        for etudid in etudiants:
-            parcours_incomplet = (
-                sum([juryPEDict[etudid][nom_sem] is None for nom_sem in self.parcours])
-                > 0
-            )  # manque-t-il des formsemestre_id validant aka l'étudiant n'a pas été inscrit dans tous les semestres de l'aggrégat
-            if not parcours_incomplet:
-                self.inscrlist.append(etudInfoDict[etudid])
-                self.identdict[etudid] = etudInfoDict[etudid]
-
-        delta = len(etudiants) - len(self.inscrlist)
-        if delta > 0:
-            pe_print(self.nom + " -> " + str(delta) + " étudiants supprimés")
-
-        # Le sous-ensemble des parcours
-        self.parcoursDict = {etudid: juryPEDict[etudid] for etudid in self.identdict}
-
-    # -------------------------------------------------------------------------------------------
-    def get_Fids_in_settag(self):
-        """Renvoie la liste des semestres (leur formsemestre_id) à prendre en compte
-        pour le calcul des moyennes, en considérant tous les étudiants inscrits et
-        tous les semestres de leur parcours"""
-        return list(
-            {
-                self.parcoursDict[etudid][nom_sem]
-                for etudid in self.identdict
-                for nom_sem in self.parcours
-            }
-        )
-
-    # ---------------------------------------------------------------------------------------------
-    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:
-            pe_print("    => %d semestres fusionnés" % len(self.SemTagDict))
-
-    # -------------------------------------------------------------------------------------------------------------------
-    def comp_data_settag(self):
-        """Calcule tous les données numériques relatives au settag"""
-        # Attributs relatifs aux tag pour les modules pris en compte
-        self.taglist = self.do_taglist()  # la liste des tags
-        self.do_tagdict()  # le dico descriptif des tags
-        # if PE_DEBUG >= 1: pe_print("   => Tags = " + ", ".join( self.taglist ))
-
-        # Calcul des moyennes de chaque étudiant par tag
-        reussiteAjoutTag = {"OK": [], "KO": []}
-        for tag in self.taglist:
-            moyennes = self.comp_MoyennesSetTag(tag, force=False)
-            res = self.add_moyennesTag(tag, moyennes)  # pas de notes => pas de moyenne
-            reussiteAjoutTag["OK" if res else "KO"].append(tag)
-        if len(reussiteAjoutTag["OK"]) > 0 and PE_DEBUG:
-            pe_print(
-                "     => Fusion de %d tags : " % (len(reussiteAjoutTag["OK"]))
-                + ", ".join(reussiteAjoutTag["OK"])
-            )
-        if len(reussiteAjoutTag["KO"]) > 0 and PE_DEBUG:
-            pe_print(
-                "     => %d tags manquants : " % (len(reussiteAjoutTag["KO"]))
-                + ", ".join(reussiteAjoutTag["KO"])
-            )
-
-    # -------------------------------------------------------------------------------------------------------------------
-    def get_etudids(self):
-        return list(self.identdict.keys())
-
-    # -------------------------------------------------------------------------------------------------------------------
-    def do_taglist(self):
-        """Parcourt les tags des semestres taggués et les synthétise sous la forme
-        d'une liste en supprimant les doublons
-        """
-        ensemble = []
-        for semtag in self.SemTagDict.values():
-            ensemble.extend(semtag.get_all_tags())
-        return sorted(list(set(ensemble)))
-
-    # -------------------------------------------------------------------------------------------------------------------
-    def do_tagdict(self):
-        """Synthétise la liste des modules pris en compte dans le calcul d'un tag (pour analyse des résultats)"""
-        self.tagdict = {}
-        for semtag in self.SemTagDict.values():
-            for tag in semtag.get_all_tags():
-                if tag != "dut":
-                    if tag not in self.tagdict:
-                        self.tagdict[tag] = {}
-                    for mod in semtag.tagdict[tag]:
-                        self.tagdict[tag][mod] = semtag.tagdict[tag][mod]
-
-    # -------------------------------------------------------------------------------------------------------------------
-    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 = [
-            self.parcoursDict[etudid][nom_sem] for nom_sem in self.parcours
-        ]  # peuvent être None
-
-        notes = [
-            self.SemTagDict[fid].get_moy_from_resultats(tag, etudid)
-            for fid in lesSemsDeLEtudiant
-            if tag in self.SemTagDict[fid].taglist
-        ]  # eventuellement None
-        coeffs = [
-            self.SemTagDict[fid].get_coeff_from_resultats(tag, etudid)
-            for fid in lesSemsDeLEtudiant
-            if tag in self.SemTagDict[fid].taglist
-        ]
-        return (notes, coeffs)
-
-    # -------------------------------------------------------------------------------------------------------------------
-    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.
-
-        Force ou non le calcul de la moyenne lorsque des notes sont manquantes.
-
-        Renvoie les informations sous la forme d'une liste  [etudid: (moy, somme_coeff_normalisée, rang), ...}
-        """
-        # if tag not in self.get_all_tags() : return None
-
-        # Calcule les moyennes
-        lesMoyennes = []
-        for (
-            etudid
-        ) in (
-            self.get_etudids()
-        ):  # Pour tous les étudiants non défaillants du semestre inscrits dans des modules relatifs au tag
-            (notes, coeffs_norm) = self.get_NotesEtCoeffsSetTagEtudiant(
-                tag, etudid
-            )  # lecture des notes associées au tag
-            (moyenne, somme_coeffs) = pe_tagtable.moyenne_ponderee_terme_a_terme(
-                notes, coeffs_norm, force=force
-            )
-            lesMoyennes += [
-                (moyenne, somme_coeffs, etudid)
-            ]  # Un tuple (pour classement résumant les données)
-        return lesMoyennes
-
-
-class SetTagInterClasse(pe_tagtable.TableTag):
-    """Récupère les moyennes de SetTag aggrégant un même parcours (par ex un ['S1', 'S2'] n'ayant pas fini au même S2
-    pour fournir un interclassement sur un groupe d'étudiant => seul compte alors la promo
-    nom_combinaison = 'S1' ou '1A'
-    """
-
-    # -------------------------------------------------------------------------------------------------------------------
-    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):
-        """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."""
-        if nom_sem_final:
-            self.nom += "_" + nom_sem_final
-        for etudid in etudiants:
-            if juryPEDict[etudid][self.combinaison] != None:
-                self.inscrlist.append(etudInfoDict[etudid])
-                self.identdict[etudid] = etudInfoDict[etudid]
-                self.parcoursDict[etudid] = juryPEDict[etudid]
-        return len(self.inscrlist)
-
-    # -------------------------------------------------------------------------------------------
-    def get_Fids_in_settag(self):
-        """Renvoie la liste des semestres (les formsemestre_id finissant la combinaison par ex. '3S' dont les fid des S3) à prendre en compte
-        pour les moyennes, en considérant tous les étudiants inscrits"""
-        return list(
-            {self.parcoursDict[etudid][self.combinaison] for etudid in self.identdict}
-        )
-
-    # ---------------------------------------------------------------------------------------------
-    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
-        }
-        if PE_DEBUG >= 1:
-            pe_print("    => %d semestres utilisés" % len(self.SetTagDict))
-
-    # -------------------------------------------------------------------------------------------------------------------
-    def comp_data_settag(self):
-        """Calcule tous les données numériques relatives au settag"""
-        # Attributs relatifs aux tag pour les modules pris en compte
-        self.taglist = self.do_taglist()
-
-        # if PE_DEBUG >= 1: pe_print("   => Tags = " + ", ".join( self.taglist ))
-
-        # Calcul des moyennes de chaque étudiant par tag
-        reussiteAjoutTag = {"OK": [], "KO": []}
-        for tag in self.taglist:
-            moyennes = self.get_MoyennesSetTag(tag, force=False)
-            res = self.add_moyennesTag(tag, moyennes)  # pas de notes => pas de moyenne
-            reussiteAjoutTag["OK" if res else "KO"].append(tag)
-        if len(reussiteAjoutTag["OK"]) > 0 and PE_DEBUG:
-            pe_print(
-                "     => Interclassement de %d tags : " % (len(reussiteAjoutTag["OK"]))
-                + ", ".join(reussiteAjoutTag["OK"])
-            )
-        if len(reussiteAjoutTag["KO"]) > 0 and PE_DEBUG:
-            pe_print(
-                "     => %d tags manquants : " % (len(reussiteAjoutTag["KO"]))
-                + ", ".join(reussiteAjoutTag["KO"])
-            )
-
-    # -------------------------------------------------------------------------------------------------------------------
-    def get_etudids(self):
-        return list(self.identdict.keys())
-
-    # -------------------------------------------------------------------------------------------------------------------
-    def do_taglist(self):
-        """Parcourt les tags des semestres taggués et les synthétise sous la forme
-        d'une liste en supprimant les doublons
-        """
-        ensemble = []
-        for settag in self.SetTagDict.values():
-            ensemble.extend(settag.get_all_tags())
-        return sorted(list(set(ensemble)))
-
-    # -------------------------------------------------------------------------------------------------------------------
-    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]
-
-        note = self.SetTagDict[leSetTagDeLetudiant].get_moy_from_resultats(tag, etudid)
-        coeff = self.SetTagDict[leSetTagDeLetudiant].get_coeff_from_resultats(
-            tag, etudid
-        )
-        return (note, coeff)
-
-    # -------------------------------------------------------------------------------------------------------------------
-    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.
-
-        Force ou non le calcul de la moyenne lorsque des notes sont manquantes.
-
-        Renvoie les informations sous la forme d'une liste  [etudid: (moy, somme_coeff_normalisée, rang), ...}
-        """
-        # if tag not in self.get_all_tags() : return None
-
-        # Calcule les moyennes
-        lesMoyennes = []
-        for (
-            etudid
-        ) in (
-            self.get_etudids()
-        ):  # Pour tous les étudiants non défaillants du semestre inscrits dans des modules relatifs au tag
-            (moyenne, somme_coeffs) = self.get_NotesEtCoeffsSetTagEtudiant(
-                tag, etudid
-            )  # lecture des notes associées au tag
-            lesMoyennes += [
-                (moyenne, somme_coeffs, etudid)
-            ]  # Un tuple (pour classement résumant les données)
-        return lesMoyennes

app/pe/pe_tabletags.py

@@ -41,36 +41,55 @@ import datetime
 import numpy as np
 
 from app.scodoc import sco_utils as scu
+import pandas as pd
+
+
+TAGS_RESERVES = ["but"]
 
 
 class TableTag(object):
     """
-    Classe mémorisant les moyennes des étudiants à différents tag et permettant de calculer les rangs et les statistiques :
+    Classe mémorisant les moyennes des étudiants à différents tags et permettant de
-    - nom : Nom représentatif des données de la Table
+    calculer des rangs et des statistiques.
-    - inscrlist : Les étudiants inscrits dans le TagTag avec leur information de la forme :
+
+    Ses attributs sont:
+
+    * nom : Nom représentatif des données de la Table
+    * inscrlist : Les étudiants inscrits dans le TagTag avec leur information de la forme :
         { etudid : dictionnaire d'info extrait de Scodoc, ...}
-    - taglist : Liste triée des noms des tags
+    * taglist : Liste triée des noms des tags
-    - resultats : Dictionnaire donnant les notes-moyennes de chaque étudiant par tag et la somme commulée
+    * resultats : Dictionnaire donnant les notes-moyennes de chaque étudiant par tag et la somme commulée
     des coeff utilisées dans le calcul de la moyenne pondérée, sous la forme :
         { tag : { etudid: (note_moy, somme_coeff_norm),
                                         ...}
-    - rangs : Dictionnaire donnant les rang par tag de chaque étudiant de la forme :
+    * rangs : Dictionnaire donnant les rang par tag de chaque étudiant de la forme :
         { tag : {etudid: rang, ...} }
-    - nbinscrits : Nombre d'inscrits dans le semestre (pas de distinction entre les tags)
+    * nbinscrits : Nombre d'inscrits dans le semestre (pas de distinction entre les tags)
-    - statistiques : Dictionnaire donnant les stastitiques (moyenne, min, max) des résultats par tag de la forme :
+    * statistiques : Dictionnaire donnant les statistiques (moyenne, min, max) des résultats par tag de la forme :
         { tag : (moy, min, max), ...}
 
     """
 
-    def __init__(self, nom=""):
+    def __init__(self, nom: str):
+        """Les attributs basiques des TagTable, qui seront initialisés
+        dans les classes dérivées
+        """
         self.nom = nom
-        self.inscrlist = []
+        """Les étudiants"""
-        self.identdict = {}
+        self.etudiants = {}
-        self.taglist = []
+        """Les moyennes par tag"""
+        self.moyennes_tags = {}
+
+
+    # -----------------------------------------------------------------------------------------------------------
+    def get_all_tags(self):
+        """Liste des tags de la table, triée par ordre alphabétique
+
+        Returns:
+            Liste de tags triés par ordre alphabétique
+        """
+        return sorted(self.moyennes_tags.keys())
 
-        self.resultats = {}
-        self.rangs = {}
-        self.statistiques = {}
 
     # *****************************************************************************************************************
     # Accesseurs
@@ -80,8 +99,8 @@ class TableTag(object):
     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]
+            self.moyennes_tags[tag][etudid][0]
-            if tag in self.resultats and etudid in self.resultats[tag]
+            if tag in self.moyennes_tags and etudid in self.moyennes_tags[tag]
             else None
         )
 
@@ -90,7 +109,7 @@ class TableTag(object):
         """Renvoie le rang à un tag d'un étudiant au regard du format de self.resultats"""
         return (
             self.rangs[tag][etudid]
-            if tag in self.resultats and etudid in self.resultats[tag]
+            if tag in self.moyennes_tags and etudid in self.moyennes_tags[tag]
             else None
         )
 
@@ -100,16 +119,11 @@ class TableTag(object):
         au regard du format de self.resultats.
         """
         return (
-            self.resultats[tag][etudid][1]
+            self.moyennes_tags[tag][etudid][1]
-            if tag in self.resultats and etudid in self.resultats[tag]
+            if tag in self.moyennes_tags and etudid in self.moyennes_tags[tag]
             else None
         )
 
-    # -----------------------------------------------------------------------------------------------------------
-    def get_all_tags(self):
-        """Renvoie la liste des tags du semestre triée par ordre alphabétique"""
-        # return self.taglist
-        return sorted(self.resultats.keys())
 
     # -----------------------------------------------------------------------------------------------------------
     def get_nbinscrits(self):
@@ -170,10 +184,12 @@ class TableTag(object):
         avec calcul du rang
         :param tag: Un tag
         :param listMoyEtCoeff: Une liste donnant [ (moy, coeff, etudid) ]
+
+        TODO:: Inutile maintenant ?
         """
         # ajout des moyennes au dictionnaire résultat
         if listMoyEtCoeff:
-            self.resultats[tag] = {
+            self.moyennes_tags[tag] = {
                 etudid: (moyenne, somme_coeffs)
                 for (moyenne, somme_coeffs, etudid) in listMoyEtCoeff
             }
@@ -204,11 +220,12 @@ class TableTag(object):
         self.statistiques
         """
         stats = ("-NA-", "-", "-")
-        if tag not in self.resultats:
+        if tag not in self.moyennes_tags:
             return stats
 
         notes = [
-            self.get_moy_from_resultats(tag, etudid) for etudid in self.resultats[tag]
+            self.get_moy_from_resultats(tag, etudid)
+            for etudid in self.moyennes_tags[tag]
         ]  # les notes du tag
         notes_valides = [
             note for note in notes if isinstance(note, float) and note != None
@@ -225,7 +242,7 @@ class TableTag(object):
         """Renvoie une chaine de caractères (valable pour un csv)
         décrivant la moyenne et le rang d'un étudiant, pour un tag donné ;
         """
-        if tag not in self.get_all_tags() or etudid not in self.resultats[tag]:
+        if tag not in self.get_all_tags() or etudid not in self.moyennes_tags[tag]:
             return ""
 
         moystr = TableTag.str_moytag(
@@ -256,30 +273,32 @@ class TableTag(object):
     str_moytag = classmethod(str_moytag)
     # -----------------------------------------------------------------------
 
-    def str_tagtable(self, delim=";", decimal_sep=","):
+    def df_tagtable(self):
-        """Renvoie une chaine de caractère listant toutes les moyennes, les rangs des étudiants pour tous les tags."""
+        """Renvoie un dataframe (etudid x tag) listant toutes les moyennes par tags
-        entete = ["etudid", "nom", "prenom"]
-        for tag in self.get_all_tags():
-            entete += [titre + "_" + tag for titre in ["note", "rang", "nb_inscrit"]]
-        chaine = delim.join(entete) + "\n"
 
-        for etudid in self.identdict:
+        Returns:
-            descr = delim.join(
+            Un dataframe etudids x tag (avec tag par ordre alphabétique)
-                [
+        """
-                    etudid,
+        tags = self.get_all_tags()
-                    self.identdict[etudid]["nom"],
+        if tags:
-                    self.identdict[etudid]["prenom"],
+            dict_series = {tag: self.moyennes_tags[tag]["notes"] for tag in tags}
-                ]
+            df = pd.DataFrame(dict_series)
-            )
+            return df
-            descr += delim + self.str_res_d_un_etudiant(etudid, delim)
-            chaine += descr + "\n"
-
-        # Ajout des stats ... à faire
-
-        if decimal_sep != ".":
-            return chaine.replace(".", decimal_sep)
         else:
-            return chaine
+            return None
+
+    def str_tagtable(self):
+        """Renvoie une chaine de caractère listant toutes les moyennes,
+        les rangs des étudiants pour tous les tags."""
+
+        etudiants = self.etudiants
+        df = pd.DataFrame.from_dict(etudiants, orient="index", columns=["nom"])
+
+        for tag in self.get_all_tags():
+            df = df.join(self.moyennes_tags[tag]["notes"].rename(f"moy {tag}"))
+            df = df.join(self.moyennes_tags[tag]["classements"].rename(f"class {tag}"))
+
+        return df.to_csv(sep=";")
 
 
 # ************************************************************************

app/pe/pe_tools.py

@@ -1,960 +0,0 @@
-# -*- mode: python -*-
-# -*- coding: utf-8 -*-
-
-##############################################################################
-#
-# Gestion scolarite IUT
-#
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-#
-#   Emmanuel Viennet      emmanuel.viennet@viennet.net
-#
-##############################################################################
-
-##############################################################################
-#  Module "Avis de poursuite d'étude"
-#  conçu et développé par Cléo Baras (IUT de Grenoble)
-##############################################################################
-
-"""
-Created on Thu Sep  8 09:36:33 2016
-
-@author: barasc
-"""
-
-import os
-import datetime
-import re
-import unicodedata
-
-
-from flask import g
-
-import app.scodoc.sco_utils as scu
-from app import log
-from app.scodoc.sco_logos import find_logo
-
-PE_DEBUG = 0
-
-if not PE_DEBUG:
-    # log to notes.log
-    def pe_print(*a, **kw):
-        # kw is ignored. log always add a newline
-        log(" ".join(a))
-
-else:
-    pe_print = print  # print function
-
-
-# Generated LaTeX files are encoded as:
-PE_LATEX_ENCODING = "utf-8"
-
-# /opt/scodoc/tools/doc_poursuites_etudes
-REP_DEFAULT_AVIS = os.path.join(scu.SCO_TOOLS_DIR, "doc_poursuites_etudes/")
-REP_LOCAL_AVIS = os.path.join(scu.SCODOC_CFG_DIR, "doc_poursuites_etudes/")
-
-PE_DEFAULT_AVIS_LATEX_TMPL = REP_DEFAULT_AVIS + "distrib/modeles/un_avis.tex"
-PE_LOCAL_AVIS_LATEX_TMPL = REP_LOCAL_AVIS + "local/modeles/un_avis.tex"
-PE_DEFAULT_FOOTER_TMPL = REP_DEFAULT_AVIS + "distrib/modeles/un_footer.tex"
-PE_LOCAL_FOOTER_TMPL = REP_LOCAL_AVIS + "local/modeles/un_footer.tex"
-
-# ----------------------------------------------------------------------------------------
-
-
-# ----------------------------------------------------------------------------------------
-def print_semestres_description(sems, avec_affichage_debug=False):
-    """Dediee a l'affichage d'un semestre pour debug du module"""
-
-    def chaine_semestre(sem):
-        desc = (
-            "S"
-            + str(sem["semestre_id"])
-            + " "
-            + sem["modalite"]
-            + " "
-            + sem["anneescolaire"]
-        )
-        desc += " (" + sem["annee_debut"] + "/" + sem["annee_fin"] + ") "
-        desc += str(sem["formation_id"]) + " / " + str(sem["formsemestre_id"])
-        desc += " - " + sem["titre_num"]
-        return desc
-
-    if avec_affichage_debug == True:
-        if isinstance(sems, list):
-            for sem in sems:
-                pe_print(chaine_semestre(sem))
-        else:
-            pe_print(chaine_semestre(sems))
-
-
-# ----------------------------------------------------------------------------------------
-def calcul_age(born):
-    """Calcule l'age à partir de la date de naissance sous forme d'une chaine de caractère 'jj/mm/aaaa'.
-    Aucun test de validité sur le format de la date n'est fait.
-    """
-    if not isinstance(born, str) or born == "":
-        return ""
-
-    donnees = born.split("/")
-    naissance = datetime.datetime(int(donnees[2]), int(donnees[1]), int(donnees[0]))
-    today = datetime.date.today()
-    return (
-        today.year
-        - naissance.year
-        - ((today.month, today.day) < (naissance.month, naissance.day))
-    )
-
-
-# ----------------------------------------------------------------------------------------
-def remove_accents(input_unicode_str):
-    """Supprime les accents d'une chaine unicode"""
-    nfkd_form = unicodedata.normalize("NFKD", input_unicode_str)
-    only_ascii = nfkd_form.encode("ASCII", "ignore")
-    return only_ascii
-
-
-def escape_for_latex(s):
-    """Protège les caractères pour inclusion dans du source LaTeX"""
-    if not s:
-        return ""
-    conv = {
-        "&": r"\&",
-        "%": r"\%",
-        "$": r"\$",
-        "#": r"\#",
-        "_": r"\_",
-        "{": r"\{",
-        "}": r"\}",
-        "~": r"\textasciitilde{}",
-        "^": r"\^{}",
-        "\\": r"\textbackslash{}",
-        "<": r"\textless ",
-        ">": r"\textgreater ",
-    }
-    exp = re.compile(
-        "|".join(
-            re.escape(key)
-            for key in sorted(list(conv.keys()), key=lambda item: -len(item))
-        )
-    )
-    return exp.sub(lambda match: conv[match.group()], s)
-
-
-# ----------------------------------------------------------------------------------------
-def list_directory_filenames(path):
-    """List of regular filenames in a directory (recursive)
-    Excludes files and directories begining with .
-    """
-    R = []
-    for root, dirs, files in os.walk(path, topdown=True):
-        dirs[:] = [d for d in dirs if d[0] != "."]
-        R += [os.path.join(root, fn) for fn in files if fn[0] != "."]
-    return R
-
-
-def add_local_file_to_zip(zipfile, ziproot, pathname, path_in_zip):
-    """Read pathname server file and add content to zip under path_in_zip"""
-    rooted_path_in_zip = os.path.join(ziproot, path_in_zip)
-    zipfile.write(filename=pathname, arcname=rooted_path_in_zip)
-    # data = open(pathname).read()
-    # zipfile.writestr(rooted_path_in_zip, data)
-
-
-def add_refs_to_register(register, directory):
-    """Ajoute les fichiers trouvés dans directory au registre (dictionaire) sous la forme
-    filename => pathname
-    """
-    length = len(directory)
-    for pathname in list_directory_filenames(directory):
-        filename = pathname[length + 1 :]
-        register[filename] = pathname
-
-
-def add_pe_stuff_to_zip(zipfile, ziproot):
-    """Add auxiliary files to (already opened) zip
-    Put all local files found under config/doc_poursuites_etudes/local
-    and config/doc_poursuites_etudes/distrib
-    If a file is present in both subtrees, take the one in local.
-
-    Also copy logos
-    """
-    register = {}
-    # first add standard (distrib references)
-    distrib_dir = os.path.join(REP_DEFAULT_AVIS, "distrib")
-    add_refs_to_register(register=register, directory=distrib_dir)
-    # then add local references (some oh them may overwrite distrib refs)
-    local_dir = os.path.join(REP_LOCAL_AVIS, "local")
-    add_refs_to_register(register=register, directory=local_dir)
-    # at this point register contains all refs (filename, pathname) to be saved
-    for filename, pathname in register.items():
-        add_local_file_to_zip(zipfile, ziproot, pathname, "avis/" + filename)
-
-    # Logos: (add to logos/ directory in zip)
-    logos_names = ["header", "footer"]
-    for name in logos_names:
-        logo = find_logo(logoname=name, dept_id=g.scodoc_dept_id)
-        if logo is not None:
-            add_local_file_to_zip(
-                zipfile, ziproot, logo.filepath, "avis/logos/" + logo.filename
-            )
-
-
-# ----------------------------------------------------------------------------------------
-# Variable pour le debug des avislatex (en squeezant le calcul du jury souvent long)
-JURY_SYNTHESE_POUR_DEBUG = {
-    "EID1810": {
-        "nom": "ROUX",
-        "entree": "2016",
-        "civilite_str": "M.",
-        "promo": 2016,
-        "S2": {
-            "groupe": {
-                "informatique": (
-                    13.184230769230767,
-                    0.21666666666666667,
-                    "18",
-                    78,
-                    9.731491508491509,
-                    18.46846153846154,
-                    18.46846153846154,
-                ),
-                "technique": (
-                    12.975409073359078,
-                    0.6166666666666666,
-                    "16",
-                    78,
-                    9.948540264387688,
-                    18.29285714285714,
-                    18.29285714285714,
-                ),
-                "pe": (
-                    12.016584900684544,
-                    1.116666666666667,
-                    "20",
-                    78,
-                    9.83147528118408,
-                    17.691755169172936,
-                    17.691755169172936,
-                ),
-                "mathematiques": (
-                    12.25,
-                    0.1,
-                    "15 ex",
-                    78,
-                    8.45153073717949,
-                    19.0625,
-                    19.0625,
-                ),
-                "dut": (
-                    12.43750128724589,
-                    1.0,
-                    "19",
-                    78,
-                    10.151630181286441,
-                    17.881104750512645,
-                    17.881104750512645,
-                ),
-            },
-            "promo": {
-                "informatique": (
-                    13.184230769230767,
-                    0.21666666666666667,
-                    "25",
-                    73,
-                    11.696187214611871,
-                    18.51346153846154,
-                    18.51346153846154,
-                ),
-                "technique": (
-                    12.975409073359078,
-                    0.6166666666666666,
-                    "23",
-                    73,
-                    11.862307379173147,
-                    17.616047267953675,
-                    17.616047267953675,
-                ),
-                "pe": (
-                    12.016584900684544,
-                    1.116666666666667,
-                    "28",
-                    73,
-                    11.571004424603757,
-                    16.706338951857248,
-                    16.706338951857248,
-                ),
-                "mathematiques": (
-                    12.25,
-                    0.1,
-                    "18 ex",
-                    73,
-                    10.00886454908676,
-                    19.0625,
-                    19.0625,
-                ),
-                "dut": (
-                    12.43750128724589,
-                    1.0,
-                    "25",
-                    73,
-                    11.88798432763965,
-                    17.397627309377608,
-                    17.397627309377608,
-                ),
-            },
-        },
-        "S1": {
-            "groupe": {
-                "informatique": (
-                    16.064999999999998,
-                    0.16666666666666669,
-                    "11",
-                    82,
-                    11.020296296296294,
-                    19.325999999999997,
-                    19.325999999999997,
-                ),
-                "technique": (
-                    14.513007894736845,
-                    0.6333333333333333,
-                    "11",
-                    82,
-                    11.195082967479676,
-                    18.309764912280702,
-                    18.309764912280702,
-                ),
-                "pe": (
-                    13.260301515151516,
-                    1.1,
-                    "19",
-                    82,
-                    10.976036277232245,
-                    17.7460505050505,
-                    17.7460505050505,
-                ),
-                "mathematiques": (
-                    11.142850000000001,
-                    0.13333333333333333,
-                    "34",
-                    82,
-                    10.314605121951217,
-                    19.75,
-                    19.75,
-                ),
-                "dut": (
-                    13.54367375,
-                    1.0,
-                    "19",
-                    82,
-                    11.22193801880508,
-                    18.226902529333334,
-                    18.226902529333334,
-                ),
-            },
-            "promo": {
-                "informatique": (
-                    16.064999999999998,
-                    0.16666666666666669,
-                    "15",
-                    73,
-                    13.265276712328768,
-                    19.325999999999997,
-                    19.325999999999997,
-                ),
-                "technique": (
-                    14.513007894736845,
-                    0.6333333333333333,
-                    "16",
-                    73,
-                    12.996048795361693,
-                    18.309764912280702,
-                    18.309764912280702,
-                ),
-                "pe": (
-                    13.260301515151516,
-                    1.1,
-                    "25",
-                    73,
-                    12.4107195879539,
-                    17.7460505050505,
-                    17.7460505050505,
-                ),
-                "mathematiques": (
-                    11.142850000000001,
-                    0.13333333333333333,
-                    "39",
-                    73,
-                    11.320606952054794,
-                    19.75,
-                    19.75,
-                ),
-                "dut": (
-                    13.54367375,
-                    1.0,
-                    "25",
-                    73,
-                    12.730581289342638,
-                    18.226902529333334,
-                    18.226902529333334,
-                ),
-            },
-        },
-        "4S": {
-            "groupe": {
-                "informatique": (
-                    14.84359375,
-                    0.5333333333333333,
-                    "2",
-                    19,
-                    10.69933552631579,
-                    18.28646875,
-                    18.28646875,
-                ),
-                "pe": (
-                    12.93828572598162,
-                    3.75,
-                    "4",
-                    19,
-                    11.861967145815218,
-                    15.737718967605682,
-                    15.737718967605682,
-                ),
-                "mathematiques": (None, None, "1 ex", 19, None, None, None),
-                "ptut": (None, None, "1 ex", 19, None, None, None),
-                "dut": (
-                    13.511767410105122,
-                    4.0,
-                    "4",
-                    19,
-                    12.573349864933606,
-                    15.781651391587998,
-                    15.781651391587998,
-                ),
-            },
-            "promo": {
-                "informatique": (
-                    16.075,
-                    0.1,
-                    "4",
-                    73,
-                    10.316541095890413,
-                    19.333333333333336,
-                    19.333333333333336,
-                ),
-                "pe": (
-                    13.52416666666667,
-                    0.49999999999999994,
-                    "13",
-                    73,
-                    11.657102668465479,
-                    16.853208080808084,
-                    16.853208080808084,
-                ),
-                "mathematiques": (
-                    None,
-                    None,
-                    "55 ex",
-                    73,
-                    7.705091805555555,
-                    19.8,
-                    19.8,
-                ),
-                "dut": (
-                    14.425416666666665,
-                    1.0,
-                    "12",
-                    73,
-                    13.188168241098825,
-                    16.612613522048612,
-                    16.612613522048612,
-                ),
-            },
-        },
-        "S4": {
-            "groupe": {
-                "informatique": (
-                    16.075,
-                    0.1,
-                    "1",
-                    19,
-                    8.799078947368422,
-                    16.075,
-                    16.075,
-                ),
-                "technique": (
-                    13.835576923076923,
-                    0.4333333333333333,
-                    "4",
-                    19,
-                    12.238304655870447,
-                    16.521153846153847,
-                    16.521153846153847,
-                ),
-                "pe": (
-                    13.52416666666667,
-                    0.49999999999999994,
-                    "4",
-                    19,
-                    12.292846491228072,
-                    16.25833333333334,
-                    16.25833333333334,
-                ),
-                "dut": (
-                    14.425416666666665,
-                    1.0,
-                    "6",
-                    19,
-                    13.628367861842106,
-                    15.267566666666665,
-                    15.267566666666665,
-                ),
-            },
-            "promo": {
-                "informatique": (
-                    16.075,
-                    0.1,
-                    "4",
-                    73,
-                    10.316541095890413,
-                    19.333333333333336,
-                    19.333333333333336,
-                ),
-                "pe": (
-                    13.52416666666667,
-                    0.49999999999999994,
-                    "13",
-                    73,
-                    11.657102668465479,
-                    16.853208080808084,
-                    16.853208080808084,
-                ),
-                "technique": (
-                    13.835576923076923,
-                    0.4333333333333333,
-                    "11",
-                    73,
-                    12.086685508009952,
-                    17.25909420289855,
-                    17.25909420289855,
-                ),
-                "mathematiques": (
-                    None,
-                    None,
-                    "55 ex",
-                    73,
-                    7.705091805555555,
-                    19.8,
-                    19.8,
-                ),
-                "ptut": (
-                    13.5,
-                    0.13333333333333333,
-                    "50",
-                    73,
-                    13.898173515981734,
-                    17.083333333333332,
-                    17.083333333333332,
-                ),
-                "dut": (
-                    14.425416666666665,
-                    1.0,
-                    "12",
-                    73,
-                    13.188168241098825,
-                    16.612613522048612,
-                    16.612613522048612,
-                ),
-            },
-        },
-        "1A": {
-            "groupe": {
-                "informatique": (
-                    14.43673913043478,
-                    0.38333333333333336,
-                    "16",
-                    78,
-                    11.046040002787066,
-                    18.85992173913043,
-                    18.85992173913043,
-                ),
-                "technique": (
-                    13.754459142857144,
-                    1.25,
-                    "14",
-                    78,
-                    11.179785631638866,
-                    18.493250340136054,
-                    18.493250340136054,
-                ),
-                "pe": (
-                    12.633767581547854,
-                    2.216666666666667,
-                    "18",
-                    78,
-                    10.912253971396854,
-                    18.39547581699347,
-                    18.39547581699347,
-                ),
-                "mathematiques": (
-                    11.617342857142857,
-                    0.23333333333333334,
-                    "24",
-                    78,
-                    9.921286855287565,
-                    19.375000000000004,
-                    19.375000000000004,
-                ),
-                "dut": (
-                    12.990587518622945,
-                    2.0,
-                    "18",
-                    78,
-                    11.2117147027821,
-                    18.391345156695156,
-                    18.391345156695156,
-                ),
-            },
-            "promo": {
-                "informatique": (
-                    13.184230769230767,
-                    0.21666666666666667,
-                    "25",
-                    73,
-                    11.696187214611871,
-                    18.51346153846154,
-                    18.51346153846154,
-                ),
-                "technique": (
-                    12.975409073359078,
-                    0.6166666666666666,
-                    "23",
-                    73,
-                    11.862307379173147,
-                    17.616047267953675,
-                    17.616047267953675,
-                ),
-                "pe": (
-                    12.016584900684544,
-                    1.116666666666667,
-                    "28",
-                    73,
-                    11.571004424603757,
-                    16.706338951857248,
-                    16.706338951857248,
-                ),
-                "mathematiques": (
-                    12.25,
-                    0.1,
-                    "18 ex",
-                    73,
-                    10.00886454908676,
-                    19.0625,
-                    19.0625,
-                ),
-                "dut": (
-                    12.43750128724589,
-                    1.0,
-                    "25",
-                    73,
-                    11.88798432763965,
-                    17.397627309377608,
-                    17.397627309377608,
-                ),
-            },
-        },
-        "2A": {
-            "groupe": {
-                "informatique": (
-                    15.88333333333333,
-                    0.15000000000000002,
-                    "2",
-                    19,
-                    9.805818713450288,
-                    17.346666666666668,
-                    17.346666666666668,
-                ),
-                "pe": (
-                    13.378513043478259,
-                    1.5333333333333334,
-                    "6",
-                    19,
-                    12.099566454042717,
-                    16.06209927536232,
-                    16.06209927536232,
-                ),
-                "technique": (
-                    13.965093333333336,
-                    1.1666666666666665,
-                    "5",
-                    19,
-                    12.51068332957394,
-                    16.472092380952386,
-                    16.472092380952386,
-                ),
-                "mathematiques": (None, None, "1 ex", 19, None, None, None),
-                "dut": (
-                    14.032947301587301,
-                    2.0,
-                    "4",
-                    19,
-                    13.043386086541773,
-                    15.574706269841268,
-                    15.574706269841268,
-                ),
-            },
-            "promo": {
-                "informatique": (
-                    16.075,
-                    0.1,
-                    "4",
-                    73,
-                    10.316541095890413,
-                    19.333333333333336,
-                    19.333333333333336,
-                ),
-                "pe": (
-                    13.52416666666667,
-                    0.49999999999999994,
-                    "13",
-                    73,
-                    11.657102668465479,
-                    16.853208080808084,
-                    16.853208080808084,
-                ),
-                "technique": (
-                    13.835576923076923,
-                    0.4333333333333333,
-                    "11",
-                    73,
-                    12.086685508009952,
-                    17.25909420289855,
-                    17.25909420289855,
-                ),
-                "mathematiques": (
-                    None,
-                    None,
-                    "55 ex",
-                    73,
-                    7.705091805555555,
-                    19.8,
-                    19.8,
-                ),
-                "dut": (
-                    14.425416666666665,
-                    1.0,
-                    "12",
-                    73,
-                    13.188168241098825,
-                    16.612613522048612,
-                    16.612613522048612,
-                ),
-            },
-        },
-        "nbSemestres": 4,
-        "code_nip": "21414563",
-        "prenom": "Baptiste",
-        "age": "21",
-        "lycee": "PONCET",
-        "3S": {
-            "groupe": {
-                "informatique": (
-                    14.559423076923077,
-                    0.43333333333333335,
-                    "3",
-                    19,
-                    11.137856275303646,
-                    18.8095,
-                    18.8095,
-                ),
-                "pe": (
-                    12.84815019664546,
-                    3.25,
-                    "4",
-                    19,
-                    11.795678015751701,
-                    15.657624449801428,
-                    15.657624449801428,
-                ),
-                "technique": (
-                    13.860638395358142,
-                    1.9833333333333334,
-                    "3",
-                    19,
-                    12.395950358235925,
-                    17.340302131732695,
-                    17.340302131732695,
-                ),
-                "mathematiques": (
-                    11.494044444444445,
-                    0.3,
-                    "6",
-                    19,
-                    9.771571754385965,
-                    14.405358333333334,
-                    14.405358333333334,
-                ),
-                "dut": (
-                    13.207217657917942,
-                    3.0,
-                    "4",
-                    19,
-                    12.221677199297439,
-                    15.953012966561774,
-                    15.953012966561774,
-                ),
-            },
-            "promo": {
-                "informatique": (15.5, 0.05, "13", 73, 10.52222222222222, 20.0, 20.0),
-                "pe": (
-                    13.308035483870967,
-                    1.0333333333333334,
-                    "17",
-                    73,
-                    11.854843423685786,
-                    16.191317607526884,
-                    16.191317607526884,
-                ),
-                "technique": (
-                    14.041625757575758,
-                    0.7333333333333333,
-                    "10",
-                    73,
-                    11.929466899200335,
-                    16.6400384469697,
-                    16.6400384469697,
-                ),
-                "mathematiques": (
-                    11.0625,
-                    0.06666666666666667,
-                    "40",
-                    73,
-                    11.418430205479451,
-                    19.53,
-                    19.53,
-                ),
-                "dut": (
-                    13.640477936507937,
-                    1.0,
-                    "14",
-                    73,
-                    12.097377866597594,
-                    16.97088994741667,
-                    16.97088994741667,
-                ),
-            },
-        },
-        "bac": "STI2D",
-        "S3": {
-            "groupe": {
-                "informatique": (15.5, 0.05, "5", 19, 12.842105263157896, 20.0, 20.0),
-                "pe": (
-                    13.308035483870967,
-                    1.0333333333333334,
-                    "8",
-                    19,
-                    12.339608902093943,
-                    15.967147311827956,
-                    15.967147311827956,
-                ),
-                "technique": (
-                    14.041625757575758,
-                    0.7333333333333333,
-                    "7",
-                    19,
-                    13.128539816586922,
-                    16.44310151515152,
-                    16.44310151515152,
-                ),
-                "mathematiques": (
-                    11.0625,
-                    0.06666666666666667,
-                    "6",
-                    19,
-                    9.280921052631578,
-                    16.125,
-                    16.125,
-                ),
-                "dut": (
-                    13.640477936507937,
-                    1.0,
-                    "8",
-                    19,
-                    12.83638061385213,
-                    15.881845873015871,
-                    15.881845873015871,
-                ),
-            },
-            "promo": {
-                "informatique": (15.5, 0.05, "13", 73, 10.52222222222222, 20.0, 20.0),
-                "pe": (
-                    13.308035483870967,
-                    1.0333333333333334,
-                    "17",
-                    73,
-                    11.854843423685786,
-                    16.191317607526884,
-                    16.191317607526884,
-                ),
-                "technique": (
-                    14.041625757575758,
-                    0.7333333333333333,
-                    "10",
-                    73,
-                    11.929466899200335,
-                    16.6400384469697,
-                    16.6400384469697,
-                ),
-                "mathematiques": (
-                    11.0625,
-                    0.06666666666666667,
-                    "40",
-                    73,
-                    11.418430205479451,
-                    19.53,
-                    19.53,
-                ),
-                "dut": (
-                    13.640477936507937,
-                    1.0,
-                    "14",
-                    73,
-                    12.097377866597594,
-                    16.97088994741667,
-                    16.97088994741667,
-                ),
-            },
-        },
-        "parcours": [
-            {
-                "nom_semestre_dans_parcours": "semestre 4 FAP  2016",
-                "titreannee": "DUT RT UFA (PPN 2013), semestre 4 FAP  2016",
-            },
-            {
-                "nom_semestre_dans_parcours": "semestre 3 FAP  2015-2016",
-                "titreannee": "DUT RT UFA (PPN 2013), semestre 3 FAP  2015-2016",
-            },
-            {
-                "nom_semestre_dans_parcours": "semestre 2 FI  2015",
-                "titreannee": "DUT RT, semestre 2 FI  2015",
-            },
-            {
-                "nom_semestre_dans_parcours": "semestre 1 FI  2014-2015",
-                "titreannee": "DUT RT, semestre 1 FI  2014-2015",
-            },
-        ],
-    }
-}

app/pe/pe_trajectoire.py

@@ -0,0 +1,150 @@
+import app.pe.pe_comp as pe_tools
+from app.models import FormSemestre
+from app.pe.pe_etudiant import EtudiantsJuryPE, get_dernier_semestre_en_date
+
+
+class Trajectoire:
+    """Modélise, pour un aggrégat visé (par ex: 'S2', '3S', '2A')
+    et un ensemble d'étudiants donnés,
+    la combinaison des formsemestres des étudiants amenant à un semestre
+    terminal visé.
+
+    Si l'aggrégat est un semestre de type Si, elle stocke le (ou les)
+    formsemestres de numéro i qu'ont suivis l'étudiant pour atteindre le Si
+    (en général 1 si personnes n'a redoublé, mais 2 s'il y a des redoublants)
+
+    Pour des aggrégats de type iS ou iA (par ex, 3A=S1+S2+S3), elle identifie
+    les semestres que les étudiants ont suivis pour les amener jusqu'au semestre
+    terminal de la trajectoire (par ex: ici un S3).
+    Ces semestres peuvent être :
+    * des S1+S2+S1+S2+S3 si redoublement de la 1ère année
+    * des S1+S2+(année de césure)+S3 si césure, ...
+    """
+
+    def __init__(self, nom_aggregat: str, semestre_final: FormSemestre):
+        """Modélise un ensemble de formsemestres d'étudiants
+        amenant à un semestre terminal
+
+        Args:
+            nom_aggregat: Un nom d'aggrégat (par ex: '5S')
+            semestre_final: Le semestre final de l'aggrégat
+        """
+        self.nom = nom_aggregat
+        self.semestre_final = semestre_final
+        self.trajectoire_id = (nom_aggregat, semestre_final.formsemestre_id)
+
+        """Les semestres à aggréger"""
+        self.semestres_aggreges = {}
+
+
+    def add_semestres_a_aggreger(self, semestres: dict[int: FormSemestre]):
+        """Ajoute des semestres au semestre à aggréger
+
+        Args:
+            semestres: Dictionnaire ``{fid: FormSemestre(fid)} à ajouter``
+        """
+        self.semestres_aggreges = self.semestres_aggreges | semestres
+
+
+
+    def get_repr(self):
+        """Représentation textuelle d'une trajectoire
+        basée sur ses semestres aggrégés"""
+        noms = []
+        for fid in self.semestres_aggreges:
+            semestre = self.semestres_aggreges[fid]
+            noms.append(f"S{semestre.semestre_id}({fid})")
+        noms = sorted(noms)
+        repr = f"{self.nom} ({self.semestre_final.formsemestre_id}) {self.semestre_final.date_fin.year}"
+        if noms:
+            repr += " - " + "+".join(noms)
+        return repr
+
+
+class TrajectoiresJuryPE:
+    """Centralise toutes les trajectoires du jury PE"""
+
+    def __init__(self, annee_diplome: int):
+        """
+        Args:
+            annee_diplome: L'année de diplomation
+        """
+
+        self.annee_diplome = annee_diplome
+        """Toutes les trajectoires possibles"""
+        self.trajectoires: dict[tuple: Trajectoire] = {}
+        """Quelle trajectoires pour quel étudiant :
+        dictionnaire {etudid: {nom_aggregat: Trajectoire}}"""
+        self.suivi: dict[int: str] = {}
+
+
+    def cree_trajectoires(self, etudiants: EtudiantsJuryPE):
+        """Créé toutes les trajectoires, au regard du cursus des étudiants
+        analysés + les mémorise dans les données de l'étudiant
+        """
+
+        for nom_aggregat in pe_tools.TOUS_LES_SEMESTRES + pe_tools.TOUS_LES_AGGREGATS:
+
+            """L'aggrégat considéré (par ex: 3S=S1+S2+S3), son nom de son semestre terminal (par ex: S3) et son numéro (par ex: 3)"""
+            noms_semestre_de_aggregat = pe_tools.PARCOURS[nom_aggregat]["aggregat"]
+            nom_semestre_terminal = noms_semestre_de_aggregat[-1]
+
+            for etudid in etudiants.cursus:
+                if etudid not in self.suivi:
+                    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 
+                (par ex: son dernier S3 en date)"""
+                semestres = etudiants.cursus[etudid][nom_semestre_terminal]
+                if semestres:
+                    formsemestre_final = get_dernier_semestre_en_date(semestres)
+
+                    """Ajout ou récupération de la trajectoire"""
+                    trajectoire_id = (nom_aggregat, formsemestre_final.formsemestre_id)
+                    if trajectoire_id not in self.trajectoires:
+                        trajectoire = Trajectoire(nom_aggregat, formsemestre_final)
+                        self.trajectoires[trajectoire_id] = trajectoire
+                    else:
+                        trajectoire = self.trajectoires[trajectoire_id]
+
+                    """La liste des semestres de l'étudiant à prendre en compte
+                    pour cette trajectoire"""
+                    semestres_a_aggreger = etudiants.get_trajectoire(etudid, formsemestre_final)
+
+                    """Ajout des semestres à la trajectoire"""
+                    trajectoire.add_semestres_a_aggreger(semestres_a_aggreger)
+
+                    """Mémoire la trajectoire suivie par l'étudiant"""
+                    self.suivi[etudid][nom_aggregat] = trajectoire
+
+            """Vérifications"""
+            # dernier_semestre_aggregat = get_dernier_semestre_en_date(semestres_aggreges)
+            # assert dernier_semestre_aggregat == formsemestre_terminal
+
+
+def get_semestres_a_aggreger(self, aggregat: str, formsemestre_id_terminal: int):
+    """Pour un nom d'aggrégat donné (par ex: 'S3') et un semestre terminal cible
+    identifié par son formsemestre_id (par ex: 'S3 2022-2023'),
+    renvoie l'ensemble des semestres à prendre en compte dans
+    l'aggrégat sous la forme d'un dictionnaire {fid: FormSemestre(fid)}.
+
+    Fusionne les cursus individuels des étudiants, dont le cursus correspond
+    à l'aggrégat visé.
+
+    Args:
+        aggregat: Un aggrégat (par ex. 1A, 2A, 3S, 6S)
+        formsemestre_id_terminal: L'identifiant du formsemestre terminal de l'aggrégat, devant correspondre au
+                                  dernier semestre de l'aggrégat
+    """
+    noms_semestres_aggreges = pe_tools.PARCOURS[aggregat]["aggregat"]
+
+    formsemestres = {}
+    for etudid in self.cursus:
+        cursus_etudiant = self.cursus[etudid][aggregat]
+        if formsemestre_id_terminal in cursus_etudiant:
+            formsemestres_etudiant = cursus_etudiant[formsemestre_id_terminal]
+            formsemestres = formsemestres | formsemestres_etudiant
+    return formsemestres
+

app/pe/pe_trajectoiretag.py

@@ -0,0 +1,217 @@
+# -*- mode: python -*-
+# -*- coding: utf-8 -*-
+
+##############################################################################
+#
+# Gestion scolarite IUT
+#
+# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+#   Emmanuel Viennet      emmanuel.viennet@viennet.net
+#
+##############################################################################
+
+##############################################################################
+#  Module "Avis de poursuite d'étude"
+#  conçu et développé par Cléo Baras (IUT de Grenoble)
+##############################################################################
+
+"""
+Created on Fri Sep  9 09:15:05 2016
+
+@author: barasc
+"""
+
+from app.comp import moy_sem
+from app.comp.res_sem import load_formsemestre_results
+from app.pe.pe_semtag import SemestreTag
+from app.pe import pe_tabletags
+import pandas as pd
+import numpy as np
+from app.pe.pe_trajectoire import Trajectoire
+
+from app.pe.pe_etudiant import EtudiantsJuryPE
+from app.pe.pe_tabletags import TableTag
+
+
+class TrajectoireTag(TableTag):
+    """Calcule les moyennes par tag d'une combinaison de semestres
+    (trajectoires), identifiée par un nom d'aggrégat (par ex: '3S') et
+    par un semestre terminal, pour extraire les classements par tag pour un
+    groupe d'étudiants donnés. Le groupe d'étudiants est formé par ceux ayant tous
+    participé au semestre terminal.
+
+    Par ex: fusion d'un parcours ['S1', 'S2', 'S3'] donnant un nom_combinaison = '3S'
+
+    """
+
+    # -------------------------------------------------------------------------------------------------------------------
+    def __init__(
+        self,
+        nom: str,
+        trajectoire: Trajectoire,
+        semestres_taggues: dict[int, SemestreTag],
+        donnees_etudiants: EtudiantsJuryPE,
+    ):
+        """ """
+        TableTag.__init__(self, nom=nom)
+
+        """La trajectoire associée"""
+        self.trajectoire_id = trajectoire.trajectoire_id
+        self.trajectoire = trajectoire
+
+        """Le formsemestre terminal et les semestres aggrégés"""
+        self.formsemestre_terminal = trajectoire.semestre_final
+        nt = load_formsemestre_results(self.formsemestre_terminal)
+
+        self.semestres_aggreges = trajectoire.semestres_aggreges
+
+        """Les semestres tags associés aux semestres aggrégés"""
+        try:
+            self.semestres_tags_aggreges = {
+                frmsem_id: semestres_taggues[frmsem_id]
+                for frmsem_id in semestres_taggues
+            }
+        except:
+            raise ValueError("Semestres taggués manquants")
+
+        """Les étudiants (état civil + cursus connu)"""
+        self.etuds = nt.etuds
+        # assert self.etuds == trajectoire.suivi  # manque-t-il des étudiants ?
+        self.etudiants = {etud.etudid: etud.etat_civil for etud in self.etuds}
+
+        """Les tags extraits de tous les semestres"""
+        self.tags_sorted = self.do_taglist()
+
+        """Construit le cube de notes"""
+        self.notes_cube = self.compute_notes_cube()
+
+        """Calcul les moyennes par tag sous forme d'un dataframe"""
+        etudids = list(self.etudiants.keys())
+        self.notes = compute_tag_moy(self.notes_cube, etudids, self.tags_sorted)
+
+        """Synthétise les moyennes/classements par tag"""
+        self.moyennes_tags = {}
+        for tag in self.tags_sorted:
+            moy_gen_tag = self.notes[tag]
+            class_gen_tag = moy_sem.comp_ranks_series(moy_gen_tag)[1]  # en int
+            self.moyennes_tags[tag] = {
+                "notes": moy_gen_tag,
+                "classements": class_gen_tag,
+                "min": moy_gen_tag.min(),
+                "max": moy_gen_tag.max(),
+                "moy": moy_gen_tag.mean(),
+                "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
+        """
+        nb_tags = len(self.tags_sorted)
+        nb_etudiants = len(self.etuds)
+        nb_semestres = len(self.semestres_tags_aggreges)
+
+        """Index du cube (etudids -> dim 0, tags -> dim 1)"""
+        etudids = [etud.etudid for etud in self.etuds]
+        tags = self.tags_sorted
+        semestres_id = list(self.semestres_tags_aggreges.keys())
+
+        dfs = {}
+
+        for frmsem_id in semestres_id:
+            """Partant d'un dataframe vierge"""
+            df = pd.DataFrame(np.nan, index=etudids, columns=tags)
+
+            """Charge les notes du semestre tag"""
+            notes = self.semestres_tags_aggreges[frmsem_id].notes
+
+            """Les étudiants & les tags commun au dataframe final et aux notes du semestre)"""
+            etudids_communs = df.index.intersection(notes.index)
+            tags_communs = df.columns.intersection(notes.columns)
+
+            """Injecte les notes par tag"""
+            df.loc[etudids_communs, tags_communs] = notes.loc[
+                etudids_communs, tags_communs
+            ]
+
+            """Stocke le df"""
+            dfs[frmsem_id] = df
+
+        """Réunit les notes sous forme d'un cube etdids x tags x semestres"""
+        semestres_x_etudids_x_tags = [dfs[fid].values for fid in dfs]
+        etudids_x_tags_x_semestres = np.stack(semestres_x_etudids_x_tags, axis=-1)
+
+        return etudids_x_tags_x_semestres
+
+
+
+    def do_taglist(self):
+        """Synthétise les tags à partir des semestres (taggués) aggrégés
+
+        Returns:
+            Une liste de tags triés par ordre alphabétique
+        """
+        tags = []
+        for frmsem_id in self.semestres_tags_aggreges:
+            tags.extend(self.semestres_tags_aggreges[frmsem_id].tags_sorted)
+        return sorted(set(tags))
+
+
+def compute_tag_moy(set_cube: np.array, etudids: list, tags: list):
+    """Calcul de la moyenne par tag sur plusieurs semestres.
+    La moyenne est un nombre (note/20), ou NaN si pas de notes disponibles
+
+    *Remarque* : Adaptation de moy_ue.compute_ue_moys_apc au cas des moyennes de tag
+    par aggrégat de plusieurs semestres.
+
+    Args:
+        set_cube: notes moyennes aux modules ndarray
+                 (etuds x modimpls x UEs), des floats avec des NaN
+        etudids: liste des étudiants (dim. 0 du cube)
+        tags: liste des tags (dim. 1 du cube)
+    Returns:
+        Un DataFrame avec pour columns les moyennes par tags,
+        et pour rows les etudid
+    """
+    nb_etuds, nb_tags, nb_semestres = set_cube.shape
+    assert nb_etuds == len(etudids)
+    assert nb_tags == len(tags)
+
+    # Quelles entrées du cube contiennent des notes ?
+    mask = ~np.isnan(set_cube)
+
+    # Enlève les NaN du cube pour les entrées manquantes
+    set_cube_no_nan = np.nan_to_num(set_cube, nan=0.0)
+
+    # Les moyennes par tag
+    with np.errstate(invalid="ignore"):  # ignore les 0/0 (-> NaN)
+        etud_moy_tag = np.sum(set_cube_no_nan, axis=2) / np.sum(mask, axis=2)
+
+    # Le dataFrame
+    etud_moy_tag_df = pd.DataFrame(
+        etud_moy_tag,
+        index=etudids,  # les etudids
+        columns=tags,  # les tags
+    )
+
+    return etud_moy_tag_df

app/pe/pe_view.py

@@ -36,6 +36,8 @@
 """
 
 from flask import send_file, request
+
+from app.models import FormSemestre
 from app.scodoc.sco_exceptions import ScoValueError
 
 import app.scodoc.sco_utils as scu
@@ -43,12 +45,14 @@ from app.scodoc import sco_formsemestre
 from app.scodoc import html_sco_header
 from app.scodoc import sco_preferences
 
-from app.pe import pe_tools
+from app.pe import pe_comp
-from app.pe import pe_jurype
+from app.pe import pe_jury
 from app.pe import pe_avislatex
 
 
 def _pe_view_sem_recap_form(formsemestre_id):
+    sem_base = FormSemestre.get_formsemestre(formsemestre_id)
+    if not sem_base.formation.is_apc() or sem_base.formation.get_cursus().NB_SEM < 6:
         H = [
             html_sco_header.sco_header(page_title="Avis de poursuite d'études"),
             f"""<h2 class="formsemestre">Génération des avis de poursuites d'études</h2>
@@ -61,6 +65,30 @@ def _pe_view_sem_recap_form(formsemestre_id):
                     target="_blank" rel="noopener noreferrer">
                     voir la documentation
                 </a>.
+                Cette fonction (en Scodoc9) n'est prévue que pour le BUT. 
+                <br>
+                Rendez-vous donc sur un semestre de BUT.
+                </p>
+                <p class=
+                """,
+        ]
+        return "\n".join(H) + html_sco_header.sco_footer()
+
+    # L'année du diplome
+    diplome = pe_comp.get_annee_diplome_semestre(sem_base)
+
+    H = [
+        html_sco_header.sco_header(page_title="Avis de poursuite d'études"),
+        f"""<h2 class="formsemestre">Génération des avis de poursuites d'études</h2>
+        <p class="help">
+        Cette fonction génère un ensemble de fichiers permettant d'éditer des avis de
+        poursuites d'études pour les étudiants diplômés en {diplome}.
+        <br>
+        De nombreux aspects sont paramétrables:
+        <a href="https://scodoc.org/AvisPoursuiteEtudes"
+            target="_blank" rel="noopener noreferrer">
+            voir la documentation
+        </a>.
         </p>
         <form method="post" action="pe_view_sem_recap" id="pe_view_sem_recap_form"
             enctype="multipart/form-data">
@@ -96,16 +124,30 @@ def pe_view_sem_recap(
         return _pe_view_sem_recap_form(formsemestre_id)
     prefs = sco_preferences.SemPreferences(formsemestre_id=formsemestre_id)
 
-    semBase = sco_formsemestre.get_formsemestre(formsemestre_id)
+    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"
+        )
+
+    if sem_base.formation.get_cursus().NB_SEM < 6:
+        raise ScoValueError(
+            "Le module de Poursuites d'Etudes avec Scodoc 9 n'est pas prévu pour une formation de moins de 6 semestres"
+        )
+
+    # L'année du diplome
+    diplome = pe_comp.get_annee_diplome_semestre(sem_base)
+
+    jury = pe_jury.JuryPE(diplome, sem_base.formation.formation_id)
 
-    jury = pe_jurype.JuryPE(semBase)
     # Ajout avis LaTeX au même zip:
-    etudids = list(jury.syntheseJury.keys())
+    # etudids = list(jury.syntheseJury.keys())
 
     # Récupération du template latex, du footer latex et du tag identifiant les annotations relatives aux PE
     # (chaines unicodes, html non quoté)
     template_latex = ""
     # template fourni via le formulaire Web
+    if False:
         if avis_tmpl_file:
             try:
                 template_latex = avis_tmpl_file.read().decode("utf-8")
@@ -145,12 +187,13 @@ def pe_view_sem_recap(
     )
 
     # Ajout des annotations PE dans un fichier excel
-    sT = pe_avislatex.table_syntheseAnnotationPE(jury.syntheseJury, tag_annotation_pe)
+    # sT = pe_avislatex.table_syntheseAnnotationPE(jury.syntheseJury, tag_annotation_pe)
-    if sT:
+    # if sT:
-        jury.add_file_to_zip(
+    #    jury.add_file_to_zip(
-            jury.NOM_EXPORT_ZIP + "_annotationsPE" + scu.XLSX_SUFFIX, sT.excel()
+    #        jury.nom_export_zip + "_annotationsPE" + scu.XLSX_SUFFIX, sT.excel()
-        )
+    #    )
 
+    if False:
         latex_pages = {}  # Dictionnaire de la forme nom_fichier => contenu_latex
         for etudid in etudids:
             [nom_fichier, contenu_latex] = pe_avislatex.get_avis_poursuite_par_etudiant(
@@ -171,12 +214,13 @@ def pe_view_sem_recap(
         jury.add_file_to_zip("avis/avis_poursuite.tex", doc_latex)
 
         # Ajoute image, LaTeX class file(s) and modeles
-    pe_tools.add_pe_stuff_to_zip(jury.zipfile, jury.NOM_EXPORT_ZIP)
+        pe_tools.add_pe_stuff_to_zip(jury.zipfile, jury.nom_export_zip)
+
     data = jury.get_zipped_data()
 
     return send_file(
         data,
         mimetype="application/zip",
-        download_name=scu.sanitize_filename(jury.NOM_EXPORT_ZIP + ".zip"),
+        download_name=scu.sanitize_filename(jury.nom_export_zip + ".zip"),
         as_attachment=True,
     )

app/scodoc/sco_tag_module.py

@@ -292,24 +292,35 @@ def get_etud_tagged_modules(etudid, tagname):
     return R
 
 
-def split_tagname_coeff(tag, separateur=":"):
+def split_tagname_coeff(tag: str, separateur=":") -> tuple[str, float]:
-    """Découpe un tag saisi par un utilisateur pour en extraire un tagname
+    """Découpage d'un tag, tel que saisi par un utilisateur dans le programme,
-    (chaine de caractère correspondant au tag)
+    pour en extraire :
-    et un éventuel coefficient de pondération, avec le séparateur fourni (par défaut ":").
-    Renvoie le résultat sous la forme d'une liste [tagname, pond] où pond est un float
 
-    Auteur: CB
+    * son _nom de tag_ (tagname) (chaine de caractère correspondant au tag)
+    * un éventuel coefficient de pondération, avec le séparateur fourni (par défaut ":").
+
+    Args:
+        tag: La saisie utilisateur du tag dans le programme
+        separateur: Le séparateur des informations dans la saisie utilisateur
+
+    Return:
+        Tuple (tagname, coeff_de_ponderation) extrait de la saisie utilisateur
+        (avec coeff_de_ponderation=1.0 si non mentionné)
+
+    Author:
+        Cléo Baras
     """
     if separateur in tag:
         temp = tag.split(":")
         try:
             pond = float(temp[1])
-            return [temp[0], pond]
+            return (temp[0], pond)
         except:
-            return [tag, 1.0]  # renvoie tout le tag si le découpage à échouer
+            """Renvoie tout le tag si le découpage à échouer"""
+            return (tag, 1.0)
     else:
-        # initialise le coeff de pondération à 1 lorsqu'aucun coeff de pondération n'est indiqué dans le tag
+        """initialise le coeff de pondération à 1 lorsqu'aucun coeff de pondération n'est indiqué dans le tag"""
-        return [tag, 1.0]
+        return (tag, 1.0)
 
 
 """Tests: