.gitignore

@@ -176,6 +176,3 @@ copy
 
 # Symlinks static ScoDoc
 app/static/links/[0-9]*.*[0-9]
-
-# Essais locaux
-xp/

app/api/__init__.py

@@ -3,11 +3,9 @@
 from flask_json import as_json
 from flask import Blueprint
 from flask import request, g
-from flask_login import current_user
 from app import db
 from app.scodoc import sco_utils as scu
 from app.scodoc.sco_exceptions import AccessDenied, ScoException
-from app.scodoc.sco_permissions import Permission
 
 api_bp = Blueprint("api", __name__)
 api_web_bp = Blueprint("apiweb", __name__)
@@ -50,35 +48,20 @@ def requested_format(default_format="json", allowed_formats=None):
 
 
 @as_json
-def get_model_api_object(
-    model_cls: db.Model,
-    model_id: int,
-    join_cls: db.Model = None,
-    restrict: bool | None = None,
-):
+def get_model_api_object(model_cls: db.Model, model_id: int, join_cls: db.Model = None):
     """
     Retourne une réponse contenant la représentation api de l'objet "Model[model_id]"
 
     Filtrage du département en fonction d'une classe de jointure (eg: Identite, Formsemestre) -> join_cls
 
     exemple d'utilisation : fonction "justificatif()" -> app/api/justificatifs.py
-
-    L'agument restrict est passé to_dict, est signale que l'on veut une version restreinte
-    (sans données personnelles, ou sans informations sur le justificatif d'absence)
     """
     query = model_cls.query.filter_by(id=model_id)
     if g.scodoc_dept and join_cls is not None:
         query = query.join(join_cls).filter_by(dept_id=g.scodoc_dept_id)
-    unique: model_cls = query.first()
+    unique: model_cls = query.first_or_404()
 
-    if unique is None:
-        return scu.json_error(
-            404,
-            message=f"{model_cls.__name__} inexistant(e)",
-        )
-    if restrict is None:
     return unique.to_dict(format_api=True)
-    return unique.to_dict(format_api=True, restrict=restrict)
 
 
 from app.api import tokens

app/api/assiduites.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 """ScoDoc 9 API : Assiduités
@@ -39,7 +39,6 @@ from app.scodoc.sco_utils import json_error
 @api_web_bp.route("/assiduite/<int:assiduite_id>")
 @scodoc
 @permission_required(Permission.ScoView)
-@as_json
 def assiduite(assiduite_id: int = None):
     """Retourne un objet assiduité à partir de son id
 
@@ -173,7 +172,6 @@ def count_assiduites(
             404,
             message="étudiant inconnu",
         )
-    set_sco_dept(etud.departement.acronym)
 
     # Les filtres qui seront appliqués au comptage (type, date, etudid...)
     filtered: dict[str, object] = {}
@@ -337,7 +335,7 @@ def assiduites_group(with_query: bool = False):
     try:
         etuds = [int(etu) for etu in etuds]
     except ValueError:
-        return json_error(404, "Le champ etudids n'est pas correctement formé")
+        return json_error(404, "Le champs etudids n'est pas correctement formé")
 
     # Vérification que tous les étudiants sont du même département
     query = Identite.query.filter(Identite.id.in_(etuds))
@@ -446,8 +444,6 @@ def count_assiduites_formsemestre(
     if formsemestre is None:
         return json_error(404, "le paramètre 'formsemestre_id' n'existe pas")
 
-    set_sco_dept(formsemestre.departement.acronym)
-
     # Récupération des étudiants du formsemestre
     etuds = formsemestre.etuds.all()
     etuds_id = [etud.id for etud in etuds]
@@ -837,9 +833,9 @@ def assiduite_edit(assiduite_id: int):
     """
 
     # Récupération de l'assiduité à modifier
-    assiduite_unique: Assiduite = Assiduite.query.filter_by(id=assiduite_id).first()
-    if assiduite_unique is None:
-        return json_error(404, "Assiduité non existante")
+    assiduite_unique: Assiduite = Assiduite.query.filter_by(
+        id=assiduite_id
+    ).first_or_404()
     # Récupération des valeurs à modifier
     data = request.get_json(force=True)
 
@@ -1235,8 +1231,8 @@ def _filter_manager(requested, assiduites_query: Query) -> Query:
         annee: int = scu.annee_scolaire()
 
         assiduites_query: Query = assiduites_query.filter(
-            Assiduite.date_debut >= scu.date_debut_annee_scolaire(annee),
-            Assiduite.date_fin <= scu.date_fin_annee_scolaire(annee),
+            Assiduite.date_debut >= scu.date_debut_anne_scolaire(annee),
+            Assiduite.date_fin <= scu.date_fin_anne_scolaire(annee),
         )
 
     return assiduites_query

app/api/billets_absences.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 

app/api/departements.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 
@@ -295,7 +295,7 @@ def dept_formsemestres_courants_by_id(dept_id: int):
     if date_courante:
         test_date = datetime.fromisoformat(date_courante)
     else:
-        test_date = db.func.current_date()
+        test_date = app.db.func.now()
     # Les semestres en cours de ce département
     formsemestres = FormSemestre.query.filter(
         FormSemestre.dept_id == dept.id,

app/api/etudiants.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 
@@ -10,7 +10,7 @@
 from datetime import datetime
 from operator import attrgetter
 
-from flask import g, request, Response
+from flask import g, request
 from flask_json import as_json
 from flask_login import current_user
 from flask_login import login_required
@@ -18,7 +18,7 @@ from sqlalchemy import desc, func, or_
 from sqlalchemy.dialects.postgresql import VARCHAR
 
 import app
-from app import db, log
+from app import db
 from app.api import api_bp as bp, api_web_bp
 from app.api import tools
 from app.but import bulletin_but_court
@@ -26,7 +26,6 @@ from app.decorators import scodoc, permission_required
 from app.models import (
     Admission,
     Departement,
-    EtudAnnotation,
     FormSemestreInscription,
     FormSemestre,
     Identite,
@@ -55,32 +54,6 @@ import app.scodoc.sco_utils as scu
 #
 
 
-def _get_etud_by_code(
-    code_type: str, code: str, dept: Departement
-) -> tuple[bool, Response | Identite]:
-    """Get etud, using etudid, NIP or INE
-    Returns True, etud if ok, or False, error response.
-    """
-    if code_type == "nip":
-        query = Identite.query.filter_by(code_nip=code)
-    elif code_type == "etudid":
-        try:
-            etudid = int(code)
-        except ValueError:
-            return False, json_error(404, "invalid etudid type")
-        query = Identite.query.filter_by(id=etudid)
-    elif code_type == "ine":
-        query = Identite.query.filter_by(code_ine=code)
-    else:
-        return False, json_error(404, "invalid code_type")
-    if dept:
-        query = query.filter_by(dept_id=dept.id)
-    etud = query.first()
-    if etud is None:
-        return False, json_error(404, message="etudiant inexistant")
-    return True, etud
-
-
 @bp.route("/etudiants/courants", defaults={"long": False})
 @bp.route("/etudiants/courants/long", defaults={"long": True})
 @api_web_bp.route("/etudiants/courants", defaults={"long": False})
@@ -131,10 +104,7 @@ def etudiants_courants(long=False):
             or_(Departement.acronym == acronym for acronym in allowed_depts)
         )
     if long:
-        restrict = not current_user.has_permission(Permission.ViewEtudData)
-        data = [
-            etud.to_dict_api(restrict=restrict, with_annotations=True) for etud in etuds
-        ]
+        data = [etud.to_dict_api() for etud in etuds]
     else:
         data = [etud.to_dict_short() for etud in etuds]
     return data
@@ -168,8 +138,8 @@ def etudiant(etudid: int = None, nip: str = None, ine: str = None):
             404,
             message="étudiant inconnu",
         )
-    restrict = not current_user.has_permission(Permission.ViewEtudData)
-    return etud.to_dict_api(restrict=restrict, with_annotations=True)
+
+    return etud.to_dict_api()
 
 
 @bp.route("/etudiant/etudid/<int:etudid>/photo")
@@ -281,10 +251,7 @@ def etudiants(etudid: int = None, nip: str = None, ine: str = None):
         query = query.join(Departement).filter(
             or_(Departement.acronym == acronym for acronym in allowed_depts)
         )
-    restrict = not current_user.has_permission(Permission.ViewEtudData)
-    return [
-        etud.to_dict_api(restrict=restrict, with_annotations=True) for etud in query
-    ]
+    return [etud.to_dict_api() for etud in query]
 
 
 @bp.route("/etudiants/name/<string:start>")
@@ -311,11 +278,7 @@ def etudiants_by_name(start: str = "", min_len=3, limit=32):
         )
     etuds = query.order_by(Identite.nom, Identite.prenom).limit(limit)
     # Note: on raffine le tri pour les caractères spéciaux et nom usuel ici:
-    restrict = not current_user.has_permission(Permission.ViewEtudData)
-    return [
-        etud.to_dict_api(restrict=restrict)
-        for etud in sorted(etuds, key=attrgetter("sort_key"))
-    ]
+    return [etud.to_dict_api() for etud in sorted(etuds, key=attrgetter("sort_key"))]
 
 
 @bp.route("/etudiant/etudid/<int:etudid>/formsemestres")
@@ -416,15 +379,28 @@ def bulletin(
         pdf = True
     if version not in scu.BULLETINS_VERSIONS_BUT:
         return json_error(404, "version invalide")
+    # return f"{code_type}={code}, version={version}, pdf={pdf}"
     formsemestre = FormSemestre.query.filter_by(id=formsemestre_id).first_or_404()
     dept = Departement.query.filter_by(id=formsemestre.dept_id).first_or_404()
     if g.scodoc_dept and dept.acronym != g.scodoc_dept:
         return json_error(404, "formsemestre inexistant")
     app.set_sco_dept(dept.acronym)
 
-    ok, etud = _get_etud_by_code(code_type, code, dept)
-    if not ok:
-        return etud  # json error
+    if code_type == "nip":
+        query = Identite.query.filter_by(code_nip=code, dept_id=dept.id)
+    elif code_type == "etudid":
+        try:
+            etudid = int(code)
+        except ValueError:
+            return json_error(404, "invalid etudid type")
+        query = Identite.query.filter_by(id=etudid)
+    elif code_type == "ine":
+        query = Identite.query.filter_by(code_ine=code, dept_id=dept.id)
+    else:
+        return json_error(404, "invalid code_type")
+    etud = query.first()
+    if etud is None:
+        return json_error(404, message="etudiant inexistant")
 
     if version == "butcourt":
         if pdf:
@@ -567,8 +543,7 @@ def etudiant_create(force=False):
     # Note: je ne comprends pas pourquoi un refresh est nécessaire ici
     # sans ce refresh, etud.__dict__ est incomplet (pas de 'nom').
     db.session.refresh(etud)
-
-    r = etud.to_dict_api(restrict=False)  # pas de restriction, on vient de le créer
+    r = etud.to_dict_api()
     return r
 
 
@@ -576,15 +551,26 @@ def etudiant_create(force=False):
 @api_web_bp.route("/etudiant/<string:code_type>/<string:code>/edit", methods=["POST"])
 @scodoc
 @permission_required(Permission.EtudInscrit)
-@as_json
 def etudiant_edit(
     code_type: str = "etudid",
     code: str = None,
 ):
     """Edition des données étudiant (identité, admission, adresses)"""
-    ok, etud = _get_etud_by_code(code_type, code, g.scodoc_dept)
-    if not ok:
-        return etud  # json error
+    if code_type == "nip":
+        query = Identite.query.filter_by(code_nip=code)
+    elif code_type == "etudid":
+        try:
+            etudid = int(code)
+        except ValueError:
+            return json_error(404, "invalid etudid type")
+        query = Identite.query.filter_by(id=etudid)
+    elif code_type == "ine":
+        query = Identite.query.filter_by(code_ine=code)
+    else:
+        return json_error(404, "invalid code_type")
+    if g.scodoc_dept:
+        query = query.filter_by(dept_id=g.scodoc_dept_id)
+    etud: Identite = query.first()
     #
     args = request.get_json(force=True)  # may raise 400 Bad Request
     etud.from_dict(args)
@@ -604,70 +590,5 @@ def etudiant_edit(
     # Note: je ne comprends pas pourquoi un refresh est nécessaire ici
     # sans ce refresh, etud.__dict__ est incomplet (pas de 'nom').
     db.session.refresh(etud)
-    restrict = not current_user.has_permission(Permission.ViewEtudData)
-    r = etud.to_dict_api(restrict=restrict)
+    r = etud.to_dict_api()
     return r
-
-
-@bp.route("/etudiant/<string:code_type>/<string:code>/annotation", methods=["POST"])
-@api_web_bp.route(
-    "/etudiant/<string:code_type>/<string:code>/annotation", methods=["POST"]
-)
-@scodoc
-@permission_required(Permission.EtudInscrit)  # il faut en plus ViewEtudData
-@as_json
-def etudiant_annotation(
-    code_type: str = "etudid",
-    code: str = None,
-):
-    """Ajout d'une annotation sur un étudiant"""
-    if not current_user.has_permission(Permission.ViewEtudData):
-        return json_error(403, "non autorisé (manque ViewEtudData)")
-    ok, etud = _get_etud_by_code(code_type, code, g.scodoc_dept)
-    if not ok:
-        return etud  # json error
-    #
-    args = request.get_json(force=True)  # may raise 400 Bad Request
-    comment = args.get("comment", None)
-    if not isinstance(comment, str):
-        return json_error(404, "invalid comment (expected string)")
-    if len(comment) > scu.MAX_TEXT_LEN:
-        return json_error(404, "invalid comment (too large)")
-    annotation = EtudAnnotation(comment=comment, author=current_user.user_name)
-    etud.annotations.append(annotation)
-    db.session.add(etud)
-    db.session.commit()
-    log(f"etudiant_annotation/{etud.id}/{annotation.id}")
-    return annotation.to_dict()
-
-
-@bp.route(
-    "/etudiant/<string:code_type>/<string:code>/annotation/<int:annotation_id>/delete",
-    methods=["POST"],
-)
-@api_web_bp.route(
-    "/etudiant/<string:code_type>/<string:code>/annotation/<int:annotation_id>/delete",
-    methods=["POST"],
-)
-@login_required
-@scodoc
-@as_json
-@permission_required(Permission.EtudInscrit)
-def etudiant_annotation_delete(
-    code_type: str = "etudid", code: str = None, annotation_id: int = None
-):
-    """
-    Suppression d'une annotation
-    """
-    ok, etud = _get_etud_by_code(code_type, code, g.scodoc_dept)
-    if not ok:
-        return etud  # json error
-    annotation = EtudAnnotation.query.filter_by(
-        etudid=etud.id, id=annotation_id
-    ).first()
-    if annotation is None:
-        return json_error(404, "annotation not found")
-    log(f"etudiant_annotation_delete/{etud.id}/{annotation.id}")
-    db.session.delete(annotation)
-    db.session.commit()
-    return "ok"

app/api/evaluations.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 
@@ -67,7 +67,7 @@ def get_evaluation(evaluation_id: int):
 @scodoc
 @permission_required(Permission.ScoView)
 @as_json
-def moduleimpl_evaluations(moduleimpl_id: int):
+def evaluations(moduleimpl_id: int):
     """
     Retourne la liste des évaluations d'un moduleimpl
 
@@ -75,8 +75,14 @@ def moduleimpl_evaluations(moduleimpl_id: int):
 
     Exemple de résultat : voir /evaluation
     """
-    modimpl = ModuleImpl.get_modimpl(moduleimpl_id)
-    return [evaluation.to_dict_api() for evaluation in modimpl.evaluations]
+    query = Evaluation.query.filter_by(moduleimpl_id=moduleimpl_id)
+    if g.scodoc_dept:
+        query = (
+            query.join(ModuleImpl)
+            .join(FormSemestre)
+            .filter_by(dept_id=g.scodoc_dept_id)
+        )
+    return [e.to_dict_api() for e in query]
 
 
 @bp.route("/evaluation/<int:evaluation_id>/notes")

app/api/formations.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 

app/api/formsemestres.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 
@@ -11,7 +11,7 @@ from operator import attrgetter, itemgetter
 
 from flask import g, make_response, request
 from flask_json import as_json
-from flask_login import current_user, login_required
+from flask_login import login_required
 
 import app
 from app import db
@@ -124,8 +124,8 @@ def formsemestres_query():
             annee_scolaire_int = int(annee_scolaire)
         except ValueError:
             return json_error(API_CLIENT_ERROR, "invalid annee_scolaire: not int")
-        debut_annee = scu.date_debut_annee_scolaire(annee_scolaire_int)
-        fin_annee = scu.date_fin_annee_scolaire(annee_scolaire_int)
+        debut_annee = scu.date_debut_anne_scolaire(annee_scolaire_int)
+        fin_annee = scu.date_fin_anne_scolaire(annee_scolaire_int)
         formsemestres = formsemestres.filter(
             FormSemestre.date_fin >= debut_annee, FormSemestre.date_debut <= fin_annee
         )
@@ -360,8 +360,7 @@ def formsemestre_etudiants(
         inscriptions = formsemestre.inscriptions
 
     if long:
-        restrict = not current_user.has_permission(Permission.ViewEtudData)
-        etuds = [ins.etud.to_dict_api(restrict=restrict) for ins in inscriptions]
+        etuds = [ins.etud.to_dict_api() for ins in inscriptions]
     else:
         etuds = [ins.etud.to_dict_short() for ins in inscriptions]
     # Ajout des groupes de chaque étudiants
@@ -426,7 +425,7 @@ def etat_evals(formsemestre_id: int):
     for modimpl_id in nt.modimpls_results:
         modimpl_results: ModuleImplResults = nt.modimpls_results[modimpl_id]
         modimpl: ModuleImpl = ModuleImpl.query.get_or_404(modimpl_id)
-        modimpl_dict = modimpl.to_dict(convert_objects=True, with_module=False)
+        modimpl_dict = modimpl.to_dict(convert_objects=True)
 
         list_eval = []
         for evaluation_id in modimpl_results.evaluations_etat:

app/api/jury.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 
@@ -66,7 +66,7 @@ def _news_delete_jury_etud(etud: Identite):
     "génère news sur effacement décision"
     # n'utilise pas g.scodoc_dept, pas toujours dispo en mode API
     url = url_for(
-        "scolar.fiche_etud", scodoc_dept=etud.departement.acronym, etudid=etud.id
+        "scolar.ficheEtud", scodoc_dept=etud.departement.acronym, etudid=etud.id
     )
     ScolarNews.add(
         typ=ScolarNews.NEWS_JURY,

app/api/justificatifs.py

@@ -15,7 +15,7 @@ from werkzeug.exceptions import NotFound
 
 import app.scodoc.sco_assiduites as scass
 import app.scodoc.sco_utils as scu
-from app import db, set_sco_dept
+from app import db
 from app.api import api_bp as bp
 from app.api import api_web_bp
 from app.api import get_model_api_object, tools
@@ -53,19 +53,14 @@ def justificatif(justif_id: int = None):
         "date_fin": "2022-10-31T10:00+01:00",
         "etat": "valide",
         "fichier": "archive_id",
-        "raison": "une raison", // VIDE si pas le droit
+        "raison": "une raison",
         "entry_date": "2022-10-31T08:00+01:00",
         "user_id": 1 or null,
     }
 
     """
 
-    return get_model_api_object(
-        Justificatif,
-        justif_id,
-        Identite,
-        restrict=not current_user.has_permission(Permission.AbsJustifView),
-    )
+    return get_model_api_object(Justificatif, justif_id, Identite)
 
 
 # etudid
@@ -138,9 +133,8 @@ def justificatifs(etudid: int = None, nip=None, ine=None, with_query: bool = Fal
 
     # Mise en forme des données puis retour en JSON
     data_set: list[dict] = []
-    restrict = not current_user.has_permission(Permission.AbsJustifView)
     for just in justificatifs_query.all():
-        data = just.to_dict(format_api=True, restrict=restrict)
+        data = just.to_dict(format_api=True)
         data_set.append(data)
 
     return data_set
@@ -157,15 +151,10 @@ def justificatifs(etudid: int = None, nip=None, ine=None, with_query: bool = Fal
 @as_json
 @permission_required(Permission.ScoView)
 def justificatifs_dept(dept_id: int = None, with_query: bool = False):
-    """
-    Renvoie tous les justificatifs d'un département
-    (en ajoutant un champ "formsemestre" si possible)
-    """
+    """XXX TODO missing doc"""
 
     # Récupération du département et des étudiants du département
-    dept: Departement = Departement.query.get(dept_id)
-    if dept is None:
-        return json_error(404, "Assiduité non existante")
+    dept: Departement = Departement.query.get_or_404(dept_id)
     etuds: list[int] = [etud.id for etud in dept.etudiants]
 
     # Récupération des justificatifs des étudiants du département
@@ -178,15 +167,14 @@ def justificatifs_dept(dept_id: int = None, with_query: bool = False):
         justificatifs_query: Query = _filter_manager(request, justificatifs_query)
 
     # Mise en forme des données et retour JSON
-    restrict = not current_user.has_permission(Permission.AbsJustifView)
     data_set: list[dict] = []
     for just in justificatifs_query:
-        data_set.append(_set_sems(just, restrict=restrict))
+        data_set.append(_set_sems(just))
 
     return data_set
 
 
-def _set_sems(justi: Justificatif, restrict: bool) -> dict:
+def _set_sems(justi: Justificatif) -> dict:
     """
     _set_sems Ajoute le formsemestre associé au justificatif s'il existe
 
@@ -199,7 +187,7 @@ def _set_sems(justi: Justificatif, restrict: bool) -> dict:
         dict: La représentation de l'assiduité en dictionnaire
     """
     # Conversion du justificatif en dictionnaire
-    data = justi.to_dict(format_api=True, restrict=restrict)
+    data = justi.to_dict(format_api=True)
 
     # Récupération du formsemestre de l'assiduité
     formsemestre: FormSemestre = get_formsemestre_from_data(justi.to_dict())
@@ -253,10 +241,9 @@ def justificatifs_formsemestre(formsemestre_id: int, with_query: bool = False):
         justificatifs_query: Query = _filter_manager(request, justificatifs_query)
 
     # Retour des justificatifs en JSON
-    restrict = not current_user.has_permission(Permission.AbsJustifView)
     data_set: list[dict] = []
     for justi in justificatifs_query.all():
-        data = justi.to_dict(format_api=True, restrict=restrict)
+        data = justi.to_dict(format_api=True)
         data_set.append(data)
 
     return data_set
@@ -305,7 +292,6 @@ def justif_create(etudid: int = None, nip=None, ine=None):
             404,
             message="étudiant inconnu",
         )
-    set_sco_dept(etud.departement.acronym)
 
     # Récupération des justificatifs à créer
     create_list: list[object] = request.get_json(force=True)
@@ -888,8 +874,8 @@ def _filter_manager(requested, justificatifs_query: Query):
         annee: int = scu.annee_scolaire()
 
         justificatifs_query: Query = justificatifs_query.filter(
-            Justificatif.date_debut >= scu.date_debut_annee_scolaire(annee),
-            Justificatif.date_fin <= scu.date_fin_annee_scolaire(annee),
+            Justificatif.date_debut >= scu.date_debut_anne_scolaire(annee),
+            Justificatif.date_fin <= scu.date_fin_anne_scolaire(annee),
         )
 
     # cas 8 : group_id filtre les justificatifs d'un groupe d'étudiant

app/api/logos.py

@@ -5,7 +5,7 @@
 #
 # Gestion scolarite IUT
 #
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 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

app/api/moduleimpl.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 
@@ -8,14 +8,16 @@
   ScoDoc 9 API : accès aux moduleimpl
 """
 
+from flask import g
 from flask_json import as_json
 from flask_login import login_required
 
-import app
 from app.api import api_bp as bp, api_web_bp
 from app.decorators import scodoc, permission_required
-from app.models import ModuleImpl
-from app.scodoc import sco_liste_notes
+from app.models import (
+    FormSemestre,
+    ModuleImpl,
+)
 from app.scodoc.sco_permissions import Permission
 
 
@@ -60,7 +62,10 @@ def moduleimpl(moduleimpl_id: int):
           }
         }
     """
-    modimpl = ModuleImpl.get_modimpl(moduleimpl_id)
+    query = ModuleImpl.query.filter_by(id=moduleimpl_id)
+    if g.scodoc_dept:
+        query = query.join(FormSemestre).filter_by(dept_id=g.scodoc_dept_id)
+    modimpl: ModuleImpl = query.first_or_404()
     return modimpl.to_dict(convert_objects=True)
 
 
@@ -82,36 +87,8 @@ def moduleimpl_inscriptions(moduleimpl_id: int):
           ...
         ]
     """
-    modimpl = ModuleImpl.get_modimpl(moduleimpl_id)
+    query = ModuleImpl.query.filter_by(id=moduleimpl_id)
+    if g.scodoc_dept:
+        query = query.join(FormSemestre).filter_by(dept_id=g.scodoc_dept_id)
+    modimpl: ModuleImpl = query.first_or_404()
     return [i.to_dict() for i in modimpl.inscriptions]
-
-
-@bp.route("/moduleimpl/<int:moduleimpl_id>/notes")
-@api_web_bp.route("/moduleimpl/<int:moduleimpl_id>/notes")
-@login_required
-@scodoc
-@permission_required(Permission.ScoView)
-def moduleimpl_notes(moduleimpl_id: int):
-    """Liste des notes dans ce moduleimpl
-    Exemple de résultat :
-        [
-          {
-            "etudid": 17776, // code de l'étudiant
-            "nom": "DUPONT",
-            "prenom": "Luz",
-            "38411": 16.0, // Note dans l'évaluation d'id 38411
-            "38410": 15.0,
-            "moymod": 15.5, // Moyenne INDICATIVE module
-            "moy_ue_2875": 15.5, // Moyenne vers l'UE 2875
-            "moy_ue_2876": 15.5, // Moyenne vers l'UE 2876
-            "moy_ue_2877": 15.5  // Moyenne vers l'UE 2877
-          },
-          ...
-        ]
-    """
-    modimpl = ModuleImpl.get_modimpl(moduleimpl_id)
-    app.set_sco_dept(modimpl.formsemestre.departement.acronym)
-    table, _ = sco_liste_notes.do_evaluation_listenotes(
-        moduleimpl_id=modimpl.id, fmt="json"
-    )
-    return table

app/api/partitions.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 
@@ -311,13 +311,6 @@ def group_create(partition_id: int):  # partition-group-create
     args["group_name"] = args["group_name"].strip()
     if not GroupDescr.check_name(partition, args["group_name"]):
         return json_error(API_CLIENT_ERROR, "invalid group_name")
-
-    # le numero est optionnel
-    numero = args.get("numero")
-    if numero is None:
-        numeros = [gr.numero or 0 for gr in partition.groups]
-        numero = (max(numeros) + 1) if numeros else 0
-        args["numero"] = numero
     args["partition_id"] = partition_id
     try:
         group = GroupDescr(**args)

app/api/semset.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 

app/api/tools.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 """ScoDoc 9 API : outils

app/api/users.py

@@ -1,12 +1,13 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 
 """
   ScoDoc 9 API : accès aux utilisateurs
 """
+import datetime
 
 from flask import g, request
 from flask_json import as_json
@@ -14,14 +15,13 @@ from flask_login import current_user, login_required
 
 from app import db, log
 from app.api import api_bp as bp, api_web_bp, API_CLIENT_ERROR
+from app.scodoc.sco_utils import json_error
 from app.auth.models import User, Role, UserRole
 from app.auth.models import is_valid_password
 from app.decorators import scodoc, permission_required
-from app.models import Departement, ScoDocSiteConfig
-from app.scodoc import sco_edt_cal
+from app.models import Departement
 from app.scodoc.sco_exceptions import ScoValueError
 from app.scodoc.sco_permissions import Permission
-from app.scodoc.sco_utils import json_error
 from app.scodoc import sco_utils as scu
 
 
@@ -441,63 +441,3 @@ def role_delete(role_name: str):
     db.session.delete(role)
     db.session.commit()
     return {"OK": True}
-
-
-# @bp.route("/user/<int:uid>/edt")
-# @api_web_bp.route("/user/<int:uid>/edt")
-# @login_required
-# @scodoc
-# @permission_required(Permission.ScoView)
-# @as_json
-# def user_edt(uid: int):
-#     """L'emploi du temps de l'utilisateur.
-#     Si ok, une liste d'évènements. Sinon, une chaine indiquant un message d'erreur.
-
-#     show_modules_titles affiche le titre complet du module (défaut), sinon juste le code.
-
-#     Il faut la permission ScoView + (UsersView ou bien être connecté comme l'utilisateur demandé)
-#     """
-#     if g.scodoc_dept is None:  # route API non départementale
-#         if not current_user.has_permission(Permission.UsersView):
-#             return scu.json_error(403, "accès non autorisé")
-#     user: User = db.session.get(User, uid)
-#     if user is None:
-#         return json_error(404, "user not found")
-#     # Check permission
-#     if current_user.id != user.id:
-#         if g.scodoc_dept:
-#             allowed_depts = current_user.get_depts_with_permission(Permission.UsersView)
-#             if (None not in allowed_depts) and (user.dept not in allowed_depts):
-#                 return json_error(404, "user not found")
-
-#     show_modules_titles = scu.to_bool(request.args.get("show_modules_titles", False))
-
-#     # Cherche ics
-#     if not user.edt_id:
-#         return json_error(404, "user not configured")
-#     ics_filename = sco_edt_cal.get_ics_user_edt_filename(user.edt_id)
-#     if not ics_filename:
-#         return json_error(404, "no calendar for this user")
-
-#     _, calendar = sco_edt_cal.load_calendar(ics_filename)
-
-#     # TODO:
-#     # - Construire mapping edt2modimpl: edt_id -> modimpl
-#     #    pour cela, considérer tous les formsemestres de la période de l'edt
-#     #    (soit on considère l'année scolaire du 1er event, ou celle courante,
-#     #     soit on cherche min, max des dates des events)
-#     # - Modifier décodage des groupes dans convert_ics pour avoi run mapping
-#     #    de groupe par semestre (retrouvé grâce au modimpl associé à l'event)
-
-#     raise NotImplementedError()  # TODO XXX WIP
-
-#     events_scodoc, _ = sco_edt_cal.convert_ics(
-#         calendar,
-#         edt2group=edt2group,
-#         default_group=default_group,
-#         edt2modimpl=edt2modimpl,
-#     )
-#     edt_dict = sco_edt_cal.translate_calendar(
-#         events_scodoc, group_ids, show_modules_titles=show_modules_titles
-#     )
-#     return edt_dict

app/auth/models.py

@@ -102,8 +102,6 @@ class User(UserMixin, ScoDocModel):
     token = db.Column(db.Text(), index=True, unique=True)
     token_expiration = db.Column(db.DateTime)
 
-    # Define the back reference from User to ModuleImpl
-    modimpls = db.relationship("ModuleImpl", back_populates="responsable")
     roles = db.relationship("Role", secondary="user_role", viewonly=True)
     Permission = Permission
 
@@ -247,26 +245,24 @@ class User(UserMixin, ScoDocModel):
     def to_dict(self, include_email=True):
         """l'utilisateur comme un dict, avec des champs supplémentaires"""
         data = {
-            "date_expiration": (
-                self.date_expiration.isoformat() + "Z" if self.date_expiration else None
-            ),
-            "date_modif_passwd": (
-                self.date_modif_passwd.isoformat() + "Z"
+            "date_expiration": self.date_expiration.isoformat() + "Z"
+            if self.date_expiration
+            else None,
+            "date_modif_passwd": self.date_modif_passwd.isoformat() + "Z"
             if self.date_modif_passwd
-                else None
-            ),
-            "date_created": (
-                self.date_created.isoformat() + "Z" if self.date_created else None
-            ),
+            else None,
+            "date_created": self.date_created.isoformat() + "Z"
+            if self.date_created
+            else None,
             "dept": self.dept,
             "id": self.id,
             "active": self.active,
             "cas_id": self.cas_id,
             "cas_allow_login": self.cas_allow_login,
             "cas_allow_scodoc_login": self.cas_allow_scodoc_login,
-            "cas_last_login": (
-                self.cas_last_login.isoformat() + "Z" if self.cas_last_login else None
-            ),
+            "cas_last_login": self.cas_last_login.isoformat() + "Z"
+            if self.cas_last_login
+            else None,
             "edt_id": self.edt_id,
             "status_txt": "actif" if self.active else "fermé",
             "last_seen": self.last_seen.isoformat() + "Z" if self.last_seen else None,
@@ -481,8 +477,8 @@ class User(UserMixin, ScoDocModel):
         return f"{nom} {scu.format_prenom(self.prenom)} ({self.user_name})"
 
     @staticmethod
-    def get_user_from_nomplogin(nomplogin: str) -> Optional["User"]:
-        """Returns User instance from the string "Dupont Pierre (dupont)"
+    def get_user_id_from_nomplogin(nomplogin: str) -> Optional[int]:
+        """Returns id from the string "Dupont Pierre (dupont)"
         or None if user does not exist
         """
         match = re.match(r".*\((.*)\)", nomplogin.strip())
@@ -490,7 +486,7 @@ class User(UserMixin, ScoDocModel):
             user_name = match.group(1)
             u = User.query.filter_by(user_name=user_name).first()
             if u:
-                return u
+                return u.id
         return None
 
     def get_nom_fmt(self):

app/auth/routes.py

@@ -54,7 +54,6 @@ def _login_form():
         title=_("Sign In"),
         form=form,
         is_cas_enabled=ScoDocSiteConfig.is_cas_enabled(),
-        is_cas_forced=ScoDocSiteConfig.is_cas_forced(),
     )
 
 

app/but/apc_edit_ue.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 

app/but/bulletin_but.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 
@@ -349,12 +349,19 @@ class BulletinBUT:
             raise ScoValueError("bulletin_etud: version de bulletin demandée invalide")
         res = self.res
         formsemestre = res.formsemestre
+        etat_inscription = etud.inscription_etat(formsemestre.id)
+        nb_inscrits = self.res.get_inscriptions_counts()[scu.INSCRIT]
+        published = (not formsemestre.bul_hide_xml) or force_publishing
+        if formsemestre.formation.referentiel_competence is None:
+            etud_ues_ids = {ue.id for ue in res.ues if res.modimpls_in_ue(ue, etud.id)}
+        else:
+            etud_ues_ids = res.etud_ues_ids(etud.id)
+
         d = {
             "version": "0",
             "type": "BUT",
             "date": datetime.datetime.utcnow().isoformat() + "Z",
             "publie": not formsemestre.bul_hide_xml,
-            "etat_inscription": etud.inscription_etat(formsemestre.id),
             "etudiant": etud.to_dict_bul(),
             "formation": {
                 "id": formsemestre.formation.id,
@@ -363,20 +370,14 @@ class BulletinBUT:
                 "titre": formsemestre.formation.titre,
             },
             "formsemestre_id": formsemestre.id,
+            "etat_inscription": etat_inscription,
             "options": sco_preferences.bulletin_option_affichage(
                 formsemestre, self.prefs
             ),
         }
-        published = (not formsemestre.bul_hide_xml) or force_publishing
-        if not published or d["etat_inscription"] is False:
+        if not published:
             return d
 
-        nb_inscrits = self.res.get_inscriptions_counts()[scu.INSCRIT]
-        if formsemestre.formation.referentiel_competence is None:
-            etud_ues_ids = {ue.id for ue in res.ues if res.modimpls_in_ue(ue, etud.id)}
-        else:
-            etud_ues_ids = res.etud_ues_ids(etud.id)
-
         nbabs, nbabsjust = formsemestre.get_abs_count(etud.id)
         etud_groups = sco_groups.get_etud_formsemestre_groups(
             etud, formsemestre, only_to_show=True
@@ -409,7 +410,7 @@ class BulletinBUT:
             semestre_infos.update(
                 sco_bulletins_json.dict_decision_jury(etud, formsemestre)
             )
-        if d["etat_inscription"] == scu.INSCRIT:
+        if etat_inscription == scu.INSCRIT:
             # moyenne des moyennes générales du semestre
             semestre_infos["notes"] = {
                 "value": fmt_note(res.etud_moy_gen[etud.id]),
@@ -498,8 +499,10 @@ class BulletinBUT:
         d["etud"]["etat_civil"] = etud.etat_civil
         d.update(self.res.sem)
         etud_etat = self.res.get_etud_etat(etud.id)
-        d["filigranne"] = sco_bulletins_pdf.get_filigranne_apc(
-            etud_etat, self.prefs, etud.id, res=self.res
+        d["filigranne"] = sco_bulletins_pdf.get_filigranne(
+            etud_etat,
+            self.prefs,
+            decision_sem=d["semestre"].get("decision"),
         )
         if etud_etat == scu.DEMISSION:
             d["demission"] = "(Démission)"

app/but/bulletin_but_court.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 
@@ -104,10 +104,8 @@ def _build_bulletin_but_infos(
     bulletins_sem = BulletinBUT(formsemestre)
     if fmt == "pdf":
         bul: dict = bulletins_sem.bulletin_etud_complet(etud)
-        filigranne = bul["filigranne"]
     else:  # la même chose avec un peu moins d'infos
         bul: dict = bulletins_sem.bulletin_etud(etud, force_publishing=True)
-        filigranne = ""
     decision_ues = (
         {x["acronyme"]: x for x in bul["semestre"]["decision_ue"]}
         if "semestre" in bul and "decision_ue" in bul["semestre"]
@@ -133,7 +131,6 @@ def _build_bulletin_but_infos(
         "decision_ues": decision_ues,
         "ects_total": ects_total,
         "etud": etud,
-        "filigranne": filigranne,
         "formsemestre": formsemestre,
         "logo": logo,
         "prefs": bulletins_sem.prefs,

app/but/bulletin_but_court_pdf.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 
@@ -48,7 +48,6 @@ def make_bulletin_but_court_pdf(
         ects_total: float = 0.0,
         etud: Identite = None,
         formsemestre: FormSemestre = None,
-        filigranne=""
         logo: Logo = None,
         prefs: SemPreferences = None,
         title: str = "",
@@ -87,7 +86,6 @@ class BulletinGeneratorBUTCourt(BulletinGeneratorStandard):
         decision_ues: dict = None,
         ects_total: float = 0.0,
         etud: Identite = None,
-        filigranne="",
         formsemestre: FormSemestre = None,
         logo: Logo = None,
         prefs: SemPreferences = None,
@@ -97,7 +95,7 @@ class BulletinGeneratorBUTCourt(BulletinGeneratorStandard):
         ] = None,
         ues_acronyms: list[str] = None,
     ):
-        super().__init__(bul, authuser=current_user, filigranne=filigranne)
+        super().__init__(bul, authuser=current_user)
         self.bul = bul
         self.cursus = cursus
         self.decision_ues = decision_ues
@@ -194,7 +192,7 @@ class BulletinGeneratorBUTCourt(BulletinGeneratorStandard):
         """Génère la partie "titre" du bulletin de notes.
         Renvoie une liste d'objets platypus
         """
-        # comme les bulletins standards, mais avec notre préférence
+        # comme les bulletins standard, mais avec notre préférence
         return super().bul_title_pdf(preference_field=preference_field)
 
     def bul_part_below(self, fmt="pdf") -> list:
@@ -406,8 +404,6 @@ class BulletinGeneratorBUTCourt(BulletinGeneratorStandard):
 
     def boite_identite(self) -> list:
         "Les informations sur l'identité et l'inscription de l'étudiant"
-        parcour = self.formsemestre.etuds_inscriptions[self.etud.id].parcour
-
         return [
             Paragraph(
                 SU(f"""{self.etud.nomprenom}"""),
@@ -418,8 +414,7 @@ class BulletinGeneratorBUTCourt(BulletinGeneratorStandard):
                     f"""
             <b>{self.bul["demission"]}</b><br/>
             Formation: {self.formsemestre.titre_num()}<br/>
-            {'Parcours ' + parcour.code + '<br/>' if parcour else ''}
-            Année universitaire: {self.formsemestre.annee_scolaire_str()}<br/>
+            Année scolaire: {self.formsemestre.annee_scolaire_str()}<br/>
             """
                 ),
                 style=self.style_base,

app/but/bulletin_but_pdf.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 

app/but/bulletin_but_xml_compat.py

@@ -5,7 +5,7 @@
 #
 # Gestion scolarite IUT
 #
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 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

app/but/cursus_but.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 
@@ -119,13 +119,9 @@ class EtudCursusBUT:
 
         self.validation_par_competence_et_annee = {}
         """{ competence_id : { 'BUT1' : validation_rcue (la "meilleure"), ... } }"""
-        validation_rcue: ApcValidationRCUE
         for validation_rcue in ApcValidationRCUE.query.filter_by(etud=etud):
             niveau = validation_rcue.niveau()
-            if (
-                niveau is None
-                or not niveau.competence.id in self.validation_par_competence_et_annee
-            ):
+            if not niveau.competence.id in self.validation_par_competence_et_annee:
                 self.validation_par_competence_et_annee[niveau.competence.id] = {}
             previous_validation = self.validation_par_competence_et_annee.get(
                 niveau.competence.id
@@ -447,24 +443,8 @@ def formsemestre_warning_apc_setup(
         }">formation n'est pas associée à un référentiel de compétence.</a>
         </div>
         """
-    H = []
-    # Le semestre n'a pas de parcours, mais les UE ont des parcours ?
-    if not formsemestre.parcours:
-        nb_ues_sans_parcours = len(
-            formsemestre.formation.query_ues_parcour(None)
-            .filter(UniteEns.semestre_idx == formsemestre.semestre_id)
-            .all()
-        )
-        nb_ues_tot = (
-            UniteEns.query.filter_by(formation=formsemestre.formation, type=UE_STANDARD)
-            .filter(UniteEns.semestre_idx == formsemestre.semestre_id)
-            .count()
-        )
-        if nb_ues_sans_parcours != nb_ues_tot:
-            H.append(
-                f"""Le semestre n'est associé à aucun parcours, mais les UEs de la formation ont des parcours"""
-            )
     # Vérifie les niveaux de chaque parcours
+    H = []
     for parcour in formsemestre.parcours or [None]:
         annee = (formsemestre.semestre_id + 1) // 2
         niveaux_ids = {

app/but/forms/jury_but_forms.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 

app/but/forms/refcomp_forms.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 

app/but/import_refcomp.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 from xml.etree import ElementTree

app/but/jury_but.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 
@@ -380,24 +380,14 @@ class DecisionsProposeesAnnee(DecisionsProposees):
                 sco_codes.ADJ,
             ] + self.codes
             explanation += f" et {self.nb_rcues_under_8} < 8"
-        else:  # autres cas: non admis, non passage, non dem, pas la moitié des rcue:
-            if formsemestre.semestre_id % 2 and self.formsemestre_pair is None:
-                # Si jury sur un seul semestre impair, ne  propose pas redoublement
-                # et efface décision éventuellement existante
-                codes = [None]
         else:
-                codes = []
-            self.codes = (
-                codes
-                + [
+            self.codes = [
                 sco_codes.RED,
                 sco_codes.NAR,
                 sco_codes.PAS1NCI,
                 sco_codes.ADJ,
                 sco_codes.PASD,  # voir #488 (discutable, conventions locales)
-                ]
-                + self.codes
-            )
+            ] + self.codes
             explanation += f""" et {self.nb_rcues_under_8
                                     } niveau{'x' if self.nb_rcues_under_8 > 1 else ''} < 8"""
 
@@ -417,7 +407,7 @@ class DecisionsProposeesAnnee(DecisionsProposees):
                 + '</div><div class="warning">'.join(messages)
                 + "</div>"
             )
-        self.codes = [self.codes[0]] + sorted((c or "") for c in self.codes[1:])
+        self.codes = [self.codes[0]] + sorted(self.codes[1:])
 
     def passage_de_droit_en_but3(self) -> tuple[bool, str]:
         """Vérifie si les conditions supplémentaires de passage BUT2 vers BUT3 sont satisfaites"""
@@ -524,21 +514,19 @@ class DecisionsProposeesAnnee(DecisionsProposees):
         """Les deux formsemestres auquel est inscrit l'étudiant (ni DEM ni DEF)
         du niveau auquel appartient formsemestre.
 
-        -> S_impair, S_pair (de la même année scolaire)
+        -> S_impair, S_pair
 
         Si l'origine est impair, S_impair est l'origine et S_pair est None
         Si l'origine est paire, S_pair est l'origine, et S_impair l'antérieur
         suivi par cet étudiant (ou None).
-
-        Note: si l'option "block_moyennes" est activée, ne prend pas en compte le semestre.
         """
         if not formsemestre.formation.is_apc():  # garde fou
             return None, None
 
         if formsemestre.semestre_id % 2:
-            idx_autre = formsemestre.semestre_id + 1  # impair, autre = suivant
+            idx_autre = formsemestre.semestre_id + 1
         else:
-            idx_autre = formsemestre.semestre_id - 1  # pair: autre = précédent
+            idx_autre = formsemestre.semestre_id - 1
 
         # Cherche l'autre semestre de la même année scolaire:
         autre_formsemestre = None
@@ -551,8 +539,6 @@ class DecisionsProposeesAnnee(DecisionsProposees):
                     inscr.formsemestre.formation.referentiel_competence
                     == formsemestre.formation.referentiel_competence
                 )
-                # Non bloqué
-                and not inscr.formsemestre.block_moyennes
                 # L'autre semestre
                 and (inscr.formsemestre.semestre_id == idx_autre)
                 # de la même année scolaire
@@ -624,7 +610,6 @@ class DecisionsProposeesAnnee(DecisionsProposees):
     def next_semestre_ids(self, code: str) -> set[int]:
         """Les indices des semestres dans lequels l'étudiant est autorisé
         à poursuivre après le semestre courant.
-        code: code jury sur année BUT
         """
         # La poursuite d'études dans un semestre pair d'une même année
         # est de droit pour tout étudiant.
@@ -668,8 +653,6 @@ class DecisionsProposeesAnnee(DecisionsProposees):
 
         Si les code_rcue et le code_annee ne sont pas fournis,
         et qu'il n'y en a pas déjà, enregistre ceux par défaut.
-
-        Si le code_annee est None, efface le code déjà enregistré.
         """
         log("jury_but.DecisionsProposeesAnnee.record_form")
         code_annee = self.codes[0]  # si pas dans le form, valeur par defaut
@@ -714,7 +697,6 @@ class DecisionsProposeesAnnee(DecisionsProposees):
     def record(self, code: str, mark_recorded: bool = True) -> bool:
         """Enregistre le code de l'année, et au besoin l'autorisation d'inscription.
         Si l'étudiant est DEM ou DEF, ne fait rien.
-        Si le code est None, efface le code déjà enregistré.
         Si mark_recorded est vrai, positionne self.recorded
         """
         if self.inscription_etat != scu.INSCRIT:
@@ -764,9 +746,7 @@ class DecisionsProposeesAnnee(DecisionsProposees):
         return True
 
     def record_autorisation_inscription(self, code: str):
-        """Autorisation d'inscription dans semestre suivant.
-        code: code jury sur année BUT
-        """
+        """Autorisation d'inscription dans semestre suivant"""
         if self.autorisations_recorded:
             return
         if self.inscription_etat != scu.INSCRIT:

app/but/jury_but_pv.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 
@@ -154,7 +154,7 @@ def pvjury_table_but(
             "_nom_target_attrs": f'class="etudinfo" id="{etud.id}"',
             "_nom_td_attrs": f'id="{etud.id}" class="etudinfo"',
             "_nom_target": url_for(
-                "scolar.fiche_etud",
+                "scolar.ficheEtud",
                 scodoc_dept=g.scodoc_dept,
                 etudid=etud.id,
             ),

app/but/jury_but_results.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 

app/but/jury_but_validation_auto.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 

app/but/jury_but_view.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 
@@ -97,7 +97,7 @@ def show_etud(deca: DecisionsProposeesAnnee, read_only: bool = True) -> str:
         <span class="avertissement_redoublement">{formsemestre_2.annee_scolaire_str()
             if formsemestre_2 else ""}</span>
     </div>
-    <div class="titre" title="Décisions sur RCUEs enregistrées sur l'ensemble du cursus">RCUE</div>
+    <div class="titre">RCUE</div>
     """
     )
     for dec_rcue in deca.get_decisions_rcues_annee():
@@ -256,7 +256,7 @@ def _gen_but_niveau_ue(
     return f"""<div class="but_niveau_ue {ue_class}
         {'annee_prec' if annee_prec else ''}
         ">
-    <div title="{ue.titre or ''}">{ue.acronyme}</div>
+    <div title="{ue.titre}">{ue.acronyme}</div>
     <div class="but_note with_scoplement">
         <div>{moy_ue_str}</div>
         {scoplement}
@@ -447,7 +447,7 @@ def jury_but_semestriel(
                     <div class="nom_etud">{etud.nomprenom}</div>
                 </div>
                 <div class="bull_photo"><a href="{
-                    url_for("scolar.fiche_etud", scodoc_dept=g.scodoc_dept, etudid=etud.id)
+                    url_for("scolar.ficheEtud", scodoc_dept=g.scodoc_dept, etudid=etud.id)
                     }">{etud.photo_html(title="fiche de " + etud.nomprenom)}</a>
                 </div>
             </div>

app/but/jury_edit_manual.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 

app/but/rcue.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 

app/but/validations_view.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 

app/comp/aux_stats.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 
@@ -30,9 +30,7 @@ class StatsMoyenne:
                 self.max = np.nanmax(vals)
                 self.size = len(vals)
                 self.nb_vals = self.size - np.count_nonzero(np.isnan(vals))
-        except (
-            TypeError
-        ):  # que des NaN dans un array d'objets, ou ce genre de choses exotiques...
+        except TypeError:  # que des NaN dans un array d'objets, ou ce genre de choses exotiques...
             self.moy = self.min = self.max = self.size = self.nb_vals = 0
 
     def to_dict(self):

app/comp/bonus_spo.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 
@@ -667,12 +667,10 @@ class BonusCalais(BonusSportAdditif):
     sur 20 obtenus dans chacune des matières optionnelles sont cumulés
     dans la limite de 10 points. 6% de ces points cumulés s'ajoutent :
     <ul>
-    <li><b>en BUT</b> à la moyenne de chaque UE;
+    <li><b>en DUT</b> à la moyenne générale du semestre déjà obtenue par l'étudiant.
     </li>
-    <li><b>en DUT</b> à la moyenne générale du semestre déjà obtenue par l'étudiant;
-    </li>
-    <li><b>en LP</b>, et en BUT avant 2023-2024, à la moyenne de chaque UE dont
-    l'acronyme termine par <b>BS</b> (comme UE2.1BS, UE32BS).
+    <li><b>en BUT et LP</b> à la moyenne des UE dont l'acronyme fini par <b>BS</b>
+    (ex : UE2.1BS, UE32BS)
     </li>
     </ul>
     """
@@ -694,11 +692,6 @@ class BonusCalais(BonusSportAdditif):
         else:
             self.classic_use_bonus_ues = True  # pour les LP
             super().compute_bonus(sem_modimpl_moys_inscrits, modimpl_coefs_etuds_no_nan)
-            if (
-                self.formsemestre.annee_scolaire() < 2023
-                or not self.formsemestre.formation.is_apc()
-            ):
-                # LP et anciens semestres: ne s'applique qu'aux UE dont l'acronyme termine par BS
             ues = self.formsemestre.get_ues(with_sport=False)
             ues_sans_bs = [
                 ue for ue in ues if ue.acronyme[-2:].upper() != "BS"

app/comp/df_cache.py

@@ -5,7 +5,7 @@
 #
 # Gestion scolarite IUT
 #
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 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

app/comp/jury.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 

app/comp/moy_mat.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 

app/comp/moy_mod.py

@@ -5,7 +5,7 @@
 #
 # Gestion scolarite IUT
 #
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 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
@@ -56,7 +56,6 @@ class EvaluationEtat:
 
     evaluation_id: int
     nb_attente: int
-    nb_notes: int  # nb notes d'étudiants inscrits au semestre et au modimpl
     is_complete: bool
 
     def to_dict(self):
@@ -169,34 +168,25 @@ class ModuleImplResults:
             # NULL en base => ABS (= -999)
             eval_df.fillna(scu.NOTES_ABSENCE, inplace=True)
             # Ce merge ne garde que les étudiants inscrits au module
-            # et met à NULL (NaN) les notes non présentes
+            # et met à NULL les notes non présentes
             #  (notes non saisies ou etuds non inscrits au module):
             evals_notes = evals_notes.merge(
                 eval_df, how="left", left_index=True, right_index=True
             )
             # Notes en attente: (ne prend en compte que les inscrits, non démissionnaires)
             eval_notes_inscr = evals_notes[str(evaluation.id)][list(inscrits_module)]
-            # Nombre de notes (non vides, incluant ATT etc) des inscrits:
-            nb_notes = eval_notes_inscr.notna().sum()
-            # Etudiants avec notes en attente:
-            #  = ceux avec note ATT
             eval_etudids_attente = set(
                 eval_notes_inscr.iloc[
                     (eval_notes_inscr == scu.NOTES_ATTENTE).to_numpy()
                 ].index
             )
-            if evaluation.publish_incomplete:
-                # et en "imédiat", tous ceux sans note
-                eval_etudids_attente |= etudids_sans_note
-            # Synthèse pour état du module:
             self.etudids_attente |= eval_etudids_attente
             self.evaluations_etat[evaluation.id] = EvaluationEtat(
                 evaluation_id=evaluation.id,
                 nb_attente=len(eval_etudids_attente),
-                nb_notes=int(nb_notes),
                 is_complete=is_complete,
             )
-        # au moins une note en attente (ATT ou manquante en mode "immédiat") dans ce modimpl:
+        # au moins une note en ATT dans ce modimpl:
         self.en_attente = bool(self.etudids_attente)
 
         # Force columns names to integers (evaluation ids)

app/comp/moy_sem.py

@@ -5,7 +5,7 @@
 #
 # Gestion scolarite IUT
 #
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 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
@@ -100,7 +100,7 @@ def compute_sem_moys_apc_using_ects(
 
 
 def comp_ranks_series(notes: pd.Series) -> tuple[pd.Series, pd.Series]:
-    """Calcul rangs à partir d'une série ("vecteur") de notes (index etudid, valeur
+    """Calcul rangs à partir d'une séries ("vecteur") de notes (index etudid, valeur
      numérique) en tenant compte des ex-aequos.
 
     Result: couple (tuple)

app/comp/moy_ue.py

@@ -5,7 +5,7 @@
 #
 # Gestion scolarite IUT
 #
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 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

app/comp/res_but.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 
@@ -273,7 +273,7 @@ class ResultatsSemestreBUT(NotesTableCompat):
         return s.index[s.notna()]
 
     def etud_parcours_ues_ids(self, etudid: int) -> set[int]:
-        """Ensemble des id des UEs que l'étudiant doit valider dans ce semestre compte tenu
+        """Ensemble les id des UEs que l'étudiant doit valider dans ce semestre compte tenu
         du parcours dans lequel il est inscrit.
         Se base sur le parcours dans ce semestre, et le référentiel de compétences.
         Note: il n'est pas nécessairement inscrit à toutes ces UEs.

app/comp/res_cache.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 

app/comp/res_classic.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 
@@ -234,7 +234,7 @@ class ResultatsSemestreClassic(NotesTableCompat):
         raise ScoValueError(
             f"""<div class="scovalueerror"><p>Coefficient de l'UE capitalisée {ue.acronyme}
             impossible à déterminer pour l'étudiant <a href="{
-            url_for("scolar.fiche_etud", scodoc_dept=g.scodoc_dept, etudid=etudid)
+            url_for("scolar.ficheEtud", scodoc_dept=g.scodoc_dept, etudid=etudid)
             }" class="discretelink">{etud.nom_disp()}</a></p>
             <p>Il faut <a href="{
             url_for("notes.formsemestre_edit_uecoefs", scodoc_dept=g.scodoc_dept,

app/comp/res_common.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 
@@ -9,13 +9,12 @@
 
 from collections import Counter, defaultdict
 from collections.abc import Generator
-import datetime
 from functools import cached_property
 from operator import attrgetter
 
 import numpy as np
 import pandas as pd
-import sqlalchemy as sa
+
 from flask import g, url_for
 
 from app import db
@@ -23,19 +22,14 @@ from app.comp import res_sem
 from app.comp.res_cache import ResultatsCache
 from app.comp.jury import ValidationsSemestre
 from app.comp.moy_mod import ModuleImplResults
-from app.models import (
-    Evaluation,
-    FormSemestre,
-    FormSemestreUECoef,
-    Identite,
-    ModuleImpl,
-    ModuleImplInscription,
-    ScolarAutorisationInscription,
-    UniteEns,
-)
+from app.models import FormSemestre, FormSemestreUECoef
+from app.models import Identite
+from app.models import ModuleImpl, ModuleImplInscription
+from app.models import ScolarAutorisationInscription
+from app.models.ues import UniteEns
 from app.scodoc.sco_cache import ResultatsSemestreCache
 from app.scodoc.codes_cursus import UE_SPORT
-from app.scodoc.sco_exceptions import ScoValueError, ScoTemporaryError
+from app.scodoc.sco_exceptions import ScoValueError
 from app.scodoc import sco_utils as scu
 
 
@@ -198,82 +192,16 @@ class ResultatsSemestre(ResultatsCache):
             *[mr.etudids_attente for mr in self.modimpls_results.values()]
         )
 
-    # Etat des évaluations
-    def get_evaluation_etat(self, evaluation: Evaluation) -> dict:
-        """État d'une évaluation
-        {
-            "coefficient" : float, # 0 si None
-            "description" : str, # de l'évaluation, "" si None
-            "etat" {
-                "evalcomplete" : bool,
-                "last_modif" : datetime.datetime | None, # saisie de note la plus récente
-                "nb_notes" : int, # nb notes d'étudiants inscrits
-            },
-            "evaluatiuon_id" : int,
-            "jour" : datetime.datetime, # e.date_debut or datetime.datetime(1900, 1, 1)
-            "publish_incomplete" : bool,
-        }
-        """
-        mod_results = self.modimpls_results.get(evaluation.moduleimpl_id)
-        if mod_results is None:
-            raise ScoTemporaryError()  # argh !
-        etat = mod_results.evaluations_etat.get(evaluation.id)
-        if etat is None:
-            raise ScoTemporaryError()  # argh !
-        # Date de dernière saisie de note
-        cursor = db.session.execute(
-            sa.text(
-                "SELECT MAX(date) FROM notes_notes WHERE evaluation_id = :evaluation_id"
-            ),
-            {"evaluation_id": evaluation.id},
-        )
-        date_modif = cursor.one_or_none()
-        last_modif = date_modif[0] if date_modif else None
-        return {
-            "coefficient": evaluation.coefficient or 0.0,
-            "description": evaluation.description or "",
-            "evaluation_id": evaluation.id,
-            "jour": evaluation.date_debut or datetime.datetime(1900, 1, 1),
-            "etat": {
-                "evalcomplete": etat.is_complete,
-                "nb_notes": etat.nb_notes,
-                "last_modif": last_modif,
-            },
-            "publish_incomplete": evaluation.publish_incomplete,
-        }
-
-    def get_mod_evaluation_etat_list(self, modimpl: ModuleImpl) -> list[dict]:
-        """Liste des états des évaluations de ce module
-        [ evaluation_etat, ... ] (voir get_evaluation_etat)
-        trié par (numero desc, date_debut desc)
-        """
-        # nouvelle version 2024-02-02
-        return list(
-            reversed(
-                [
-                    self.get_evaluation_etat(evaluation)
-                    for evaluation in modimpl.evaluations
-                ]
-            )
-        )
-
-    # modernisation de get_mod_evaluation_etat_list
-    # utilisé par:
-    # sco_evaluations.do_evaluation_etat_in_mod
-    #   e["etat"]["evalcomplete"]
-    #   e["etat"]["nb_notes"]
-    #   e["etat"]["last_modif"]
-    #
-    # sco_formsemestre_status.formsemestre_description_table
-    #   "jour" (qui est e.date_debut or datetime.date(1900, 1, 1))
-    #   "description"
-    #   "coefficient"
-    #   e["etat"]["evalcomplete"]
-    #   publish_incomplete
-    #
-    # sco_formsemestre_status.formsemestre_tableau_modules
-    #   e["etat"]["nb_notes"]
-    #
+    # # Etat des évaluations
+    # #  (se substitue à do_evaluation_etat, sans les moyennes par groupes)
+    # def get_evaluations_etats(evaluation_id: int) -> dict:
+    #     """Renvoie dict avec les clés:
+    #         last_modif
+    #         nb_evals_completes
+    #         nb_evals_en_cours
+    #         nb_evals_vides
+    #         attente
+    #     """
 
     # --- JURY...
     def get_formsemestre_validations(self) -> ValidationsSemestre:

app/comp/res_compat.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 
@@ -423,37 +423,30 @@ class NotesTableCompat(ResultatsSemestre):
                 )
         return evaluations
 
-    def get_evaluations_etats(self) -> dict[int, dict]:
-        """ "état" de chaque évaluation du semestre
-        {
-           evaluation_id : {
-                "evalcomplete" : bool,
-                "last_modif" : datetime | None
-                "nb_notes" : int,
-            }, ...
-        }
-        """
-        # utilisé par do_evaluation_etat_in_sem
-        evaluations_etats = {}
-        for modimpl in self.formsemestre.modimpls_sorted:
-            for evaluation in modimpl.evaluations:
-                evaluation_etat = self.get_evaluation_etat(evaluation)
-                evaluations_etats[evaluation.id] = evaluation_etat["etat"]
-        return evaluations_etats
+    def get_evaluations_etats(self) -> list[dict]:
+        """Liste de toutes les évaluations du semestre
+        [ {...evaluation et son etat...} ]"""
+        # TODO: à moderniser (voir dans ResultatsSemestre)
+        # utilisé par
+        # do_evaluation_etat_in_sem
 
-    # ancienne version < 2024-02-02
-    # def get_mod_evaluation_etat_list(self, moduleimpl_id) -> list[dict]:
-    #     """Liste des états des évaluations de ce module
-    #     ordonnée selon (numero desc, date_debut desc)
-    #     """
-    #     # à moderniser: lent, recharge des données que l'on a déjà...
-    #     # remplacemé par ResultatsSemestre.get_mod_evaluation_etat_list
-    #     #
-    #     return [
-    #         e
-    #         for e in self.get_evaluations_etats()
-    #         if e["moduleimpl_id"] == moduleimpl_id
-    #     ]
+        from app.scodoc import sco_evaluations
+
+        if not hasattr(self, "_evaluations_etats"):
+            self._evaluations_etats = sco_evaluations.do_evaluation_list_in_sem(
+                self.formsemestre.id
+            )
+
+        return self._evaluations_etats
+
+    def get_mod_evaluation_etat_list(self, moduleimpl_id) -> list[dict]:
+        """Liste des états des évaluations de ce module"""
+        # XXX TODO à moderniser: lent, recharge des données que l'on a déjà...
+        return [
+            e
+            for e in self.get_evaluations_etats()
+            if e["moduleimpl_id"] == moduleimpl_id
+        ]
 
     def get_moduleimpls_attente(self):
         """Liste des modimpls du semestre ayant des notes en attente"""

app/comp/res_sem.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 

app/email.py

@@ -1,7 +1,7 @@
 # -*- coding: UTF-8 -*
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 

app/entreprises/app_relations_entreprises.py

@@ -5,7 +5,7 @@
 #
 # Gestion scolarite IUT
 #
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 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

app/entreprises/forms.py

@@ -5,7 +5,7 @@
 #
 # Gestion scolarite IUT
 #
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 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

app/forms/assiduite/ajout_assiduite_etud.py

@@ -4,7 +4,7 @@
 #
 # ScoDoc
 #
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 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
@@ -32,7 +32,6 @@ Formulaire ajout d'un justificatif sur un étudiant
 from flask_wtf import FlaskForm
 from flask_wtf.file import MultipleFileField
 from wtforms import (
-    BooleanField,
     SelectField,
     StringField,
     SubmitField,
@@ -102,7 +101,7 @@ class AjoutAssiOrJustForm(FlaskForm):
     )
 
     entry_date = StringField(
-        "Date de dépôt ou saisie",
+        "Date de dépot ou saisie",
         validators=[validators.Length(max=10)],
         render_kw={
             "class": "datepicker",
@@ -110,16 +109,6 @@ class AjoutAssiOrJustForm(FlaskForm):
             "id": "entry_date",
         },
     )
-    entry_time = StringField(
-        "Heure dépôt",
-        default="",
-        validators=[validators.Length(max=5)],
-        render_kw={
-            "class": "timepicker",
-            "size": 5,
-            "id": "assi_heure_fin",
-        },
-    )
     submit = SubmitField("Enregistrer")
     cancel = SubmitField("Annuler", render_kw={"formnovalidate": True})
 
@@ -147,7 +136,6 @@ class AjoutAssiduiteEtudForm(AjoutAssiOrJustForm):
         "Module",
         choices={},  # will be populated dynamically
     )
-    est_just = BooleanField("Justifiée")
 
 
 class AjoutJustificatifEtudForm(AjoutAssiOrJustForm):
@@ -173,30 +161,3 @@ class AjoutJustificatifEtudForm(AjoutAssiOrJustForm):
         validators=[DataRequired(message="This field is required.")],
     )
     fichiers = MultipleFileField(label="Ajouter des fichiers")
-
-
-class ChoixDateForm(FlaskForm):
-    def __init__(self, *args, **kwargs):
-        "Init form, adding a filed for our error messages"
-        super().__init__(*args, **kwargs)
-        self.ok = True
-        self.error_messages: list[str] = []  # used to report our errors
-
-    def set_error(self, err_msg, field=None):
-        "Set error message both in form and field"
-        self.ok = False
-        self.error_messages.append(err_msg)
-        if field:
-            field.errors.append(err_msg)
-
-    date = StringField(
-        "Date",
-        validators=[validators.Length(max=10)],
-        render_kw={
-            "class": "datepicker",
-            "size": 10,
-            "id": "date",
-        },
-    )
-    submit = SubmitField("Enregistrer")
-    cancel = SubmitField("Annuler", render_kw={"formnovalidate": True})

app/forms/formation/ue_parcours_ects.py

@@ -17,7 +17,7 @@ def UEParcoursECTSForm(ue: UniteEns) -> FlaskForm:
         pass
 
     parcours: list[ApcParcours] = ue.formation.referentiel_competence.parcours
-    # Initialise un champ de saisie par parcours
+    # Initialise un champs de saisie par parcours
     for parcour in parcours:
         ects = ue.get_ects(parcour, only_parcours=True)
         setattr(

app/forms/formsemestre/change_formation.py

@@ -4,7 +4,7 @@
 #
 # ScoDoc
 #
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 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
@@ -43,7 +43,6 @@ def gen_formsemestre_change_formation_form(
     formations: list[Formation],
 ) -> FormSemestreChangeFormationForm:
     "Create our dynamical form"
-
     # see https://wtforms.readthedocs.io/en/2.3.x/specific_problems/#dynamic-form-composition
     class F(FormSemestreChangeFormationForm):
         pass

app/forms/main/config_apo.py

@@ -5,7 +5,7 @@
 #
 # ScoDoc
 #
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 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

app/forms/main/config_assiduites.py

@@ -5,7 +5,7 @@
 #
 # ScoDoc
 #
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 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
@@ -34,11 +34,52 @@ import re
 from flask_wtf import FlaskForm
 from wtforms import DecimalField, SubmitField, ValidationError
 from wtforms.fields.simple import StringField
-from wtforms.validators import Optional, Length
+from wtforms.validators import Optional
 
 from wtforms.widgets import TimeInput
 
 
+class TimeField(StringField):
+    """HTML5 time input.
+    tiré de : https://gist.github.com/tachyondecay/6016d32f65a996d0d94f
+    """
+
+    widget = TimeInput()
+
+    def __init__(self, label=None, validators=None, fmt="%H:%M:%S", **kwargs):
+        super(TimeField, self).__init__(label, validators, **kwargs)
+        self.fmt = fmt
+        self.data = None
+
+    def _value(self):
+        if self.raw_data:
+            return " ".join(self.raw_data)
+        if self.data and isinstance(self.data, str):
+            self.data = datetime.time(*map(int, self.data.split(":")))
+        return self.data and self.data.strftime(self.fmt) or ""
+
+    def process_formdata(self, valuelist):
+        if valuelist:
+            time_str = " ".join(valuelist)
+            try:
+                components = time_str.split(":")
+                hour = 0
+                minutes = 0
+                seconds = 0
+                if len(components) in range(2, 4):
+                    hour = int(components[0])
+                    minutes = int(components[1])
+
+                    if len(components) == 3:
+                        seconds = int(components[2])
+                else:
+                    raise ValueError
+                self.data = datetime.time(hour, minutes, seconds)
+            except ValueError as exc:
+                self.data = None
+                raise ValueError(self.gettext("Not a valid time string")) from exc
+
+
 def check_tick_time(form, field):
     """Le tick_time doit être entre 0 et 60 minutes"""
     if field.data < 1 or field.data > 59:
@@ -77,38 +118,16 @@ def check_ics_regexp(form, field):
 
 class ConfigAssiduitesForm(FlaskForm):
     "Formulaire paramétrage Module Assiduité"
-    assi_morning_time = StringField(
-        "Début de la journée",
-        default="",
-        validators=[Length(max=5)],
-        render_kw={
-            "class": "timepicker",
-            "size": 5,
-            "id": "assi_morning_time",
-        },
-    )
-    assi_lunch_time = StringField(
-        "Heure de midi (date pivot entre matin et après-midi)",
-        default="",
-        validators=[Length(max=5)],
-        render_kw={
-            "class": "timepicker",
-            "size": 5,
-            "id": "assi_lunch_time",
-        },
-    )
-    assi_afternoon_time = StringField(
-        "Fin de la journée",
-        validators=[Length(max=5)],
-        default="",
-        render_kw={
-            "class": "timepicker",
-            "size": 5,
-            "id": "assi_afternoon_time",
-        },
-    )
 
-    assi_tick_time = DecimalField(
+    morning_time = TimeField(
+        "Début de la journée"
+    )  # TODO utiliser TextField + timepicker voir AjoutAssiOrJustForm
+    lunch_time = TimeField(
+        "Heure de midi (date pivot entre matin et après-midi)"
+    )  # TODO
+    afternoon_time = TimeField("Fin de la journée")  # TODO
+
+    tick_time = DecimalField(
         "Granularité de la timeline (temps en minutes)",
         places=0,
         validators=[check_tick_time],
@@ -122,16 +141,6 @@ class ConfigAssiduitesForm(FlaskForm):
         Si ce champ n'est pas renseigné, les emplois du temps ne seront pas utilisés.""",
         validators=[Optional(), check_ics_path],
     )
-    edt_ics_user_path = StringField(
-        label="Chemin vers les ics des utilisateurs (enseignants)",
-        description="""Optionnel. Chemin absolu unix sur le serveur vers le fichier ics donnant l'emploi
-        du temps d'un enseignant. La balise <tt>{edt_id}</tt> sera remplacée par l'edt_id du
-        de l'utilisateur.
-        Dans certains cas (XXX), ScoDoc peut générer ces fichiers et les écrira suivant
-        ce chemin (avec edt_id).
-        """,
-        validators=[Optional(), check_ics_path],
-    )
 
     edt_ics_title_field = StringField(
         label="Champ contenant le titre",
@@ -173,16 +182,15 @@ class ConfigAssiduitesForm(FlaskForm):
         validators=[Optional(), check_ics_regexp],
     )
     edt_ics_uid_field = StringField(
-        label="Champ contenant les enseignants",
+        label="Champ contenant l'enseignant",
         description="""champ de l'évènement calendrier: DESCRIPTION, SUMMARY, ...""",
         validators=[Optional(), check_ics_field],
     )
     edt_ics_uid_regexp = StringField(
-        label="Extraction des enseignants",
-        description=r"""expression régulière python permettant d'extraire les
-            identifiants des enseignants associés à l'évènement.
-            (contrairement aux autres champs, il peut y avoir plusieurs enseignants par évènement.)
-            Exemple: <tt>[0-9]+</tt>
+        label="Extraction de l'enseignant",
+        description=r"""expression régulière python dont le premier groupe doit
+            correspondre à l'identifiant (edt_id) de l'enseignant associé à l'évènement.
+            Exemple: <tt>Enseignant : ([0-9]+)</tt>
             """,
         validators=[Optional(), check_ics_regexp],
     )

app/forms/main/config_cas.py

@@ -5,7 +5,7 @@
 #
 # ScoDoc
 #
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 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
@@ -82,7 +82,7 @@ class ConfigCASForm(FlaskForm):
 
     cas_attribute_id = StringField(
         label="Attribut CAS utilisé comme id (laissez vide pour prendre l'id par défaut)",
-        description="""Le champ CAS qui sera considéré comme l'id unique des
+        description="""Le champs CAS qui sera considéré comme l'id unique des
         comptes utilisateurs.""",
     )
 

app/forms/main/config_logos.py

@@ -5,7 +5,7 @@
 #
 # ScoDoc
 #
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 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

app/forms/main/config_main.py

@@ -5,7 +5,7 @@
 #
 # ScoDoc
 #
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 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
@@ -77,9 +77,6 @@ class ScoDocConfigurationForm(FlaskForm):
             Attention: si ce champ peut aussi être défini dans chaque département.""",
         validators=[Optional(), Email()],
     )
-    user_require_email_institutionnel = BooleanField(
-        "imposer la saisie du mail institutionnel dans le formulaire de création utilisateur"
-    )
     disable_bul_pdf = BooleanField(
         "interdire les exports des bulletins en PDF (déconseillé)"
     )
@@ -102,7 +99,6 @@ def configuration():
             "month_debut_periode2": ScoDocSiteConfig.get_month_debut_periode2(),
             "email_from_addr": ScoDocSiteConfig.get("email_from_addr"),
             "disable_bul_pdf": ScoDocSiteConfig.is_bul_pdf_disabled(),
-            "user_require_email_institutionnel": ScoDocSiteConfig.is_user_require_email_institutionnel_enabled(),
         }
     )
     if request.method == "POST" and (
@@ -155,18 +151,6 @@ def configuration():
                 "Exports PDF "
                 + ("désactivés" if form_scodoc.data["disable_bul_pdf"] else "réactivés")
             )
-        if ScoDocSiteConfig.set(
-            "user_require_email_institutionnel",
-            "on" if form_scodoc.data["user_require_email_institutionnel"] else "",
-        ):
-            flash(
-                (
-                    "impose"
-                    if form_scodoc.data["user_require_email_institutionnel"]
-                    else "n'impose pas"
-                )
-                + " la saisie du mail institutionnel des utilisateurs"
-            )
         return redirect(url_for("scodoc.index"))
 
     return render_template(

app/forms/main/config_rgpd.py

@@ -1,49 +0,0 @@
-# -*- mode: python -*-
-# -*- coding: utf-8 -*-
-
-##############################################################################
-#
-# ScoDoc
-#
-# 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
-#
-##############################################################################
-
-"""
-Formulaire configuration RGPD
-"""
-
-from flask_wtf import FlaskForm
-from wtforms import SubmitField
-from wtforms.fields.simple import TextAreaField
-
-
-class ConfigRGPDForm(FlaskForm):
-    "Formulaire paramétrage RGPD"
-    rgpd_coordonnees_dpo = TextAreaField(
-        label="Optionnel: coordonnées du DPO",
-        description="""Le délégué à la protection des données (DPO) est chargé de mettre en œuvre
-        la conformité au règlement européen sur la protection des données (RGPD) au sein de l’organisme.
-        Indiquer ici les coordonnées (format libre) qui seront affichées aux utilisateurs de ScoDoc.
-        """,
-        render_kw={"rows": 5, "cols": 72},
-    )
-
-    submit = SubmitField("Valider")
-    cancel = SubmitField("Annuler", render_kw={"formnovalidate": True})

app/forms/main/create_dept.py

@@ -5,7 +5,7 @@
 #
 # ScoDoc
 #
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 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

app/forms/main/role_create.py

@@ -5,7 +5,7 @@
 #
 # ScoDoc
 #
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 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

app/models/__init__.py

@@ -52,7 +52,7 @@ class ScoDocModel(db.Model):
     def create_from_dict(cls, data: dict) -> "ScoDocModel":
         """Create a new instance of the model with attributes given in dict.
         The instance is added to the session (but not flushed nor committed).
-        Use only relevant attributes for the given model and ignore others.
+        Use only relevant arributes for the given model and ignore others.
         """
         if data:
             args = cls.convert_dict_fields(cls.filter_model_attributes(data))

app/models/assiduites.py

@@ -2,10 +2,8 @@
 """Gestion de l'assiduité (assiduités + justificatifs)
 """
 from datetime import datetime
-
 from flask_login import current_user
 from flask_sqlalchemy.query import Query
-from sqlalchemy.exc import DataError
 
 from app import db, log, g, set_sco_dept
 from app.models import (
@@ -27,7 +25,6 @@ from app.scodoc.sco_utils import (
     EtatJustificatif,
     localize_datetime,
     is_assiduites_module_forced,
-    NonWorkDays,
 )
 
 
@@ -89,10 +86,8 @@ class Assiduite(ScoDocModel):
         lazy="select",
     )
 
-    def to_dict(self, format_api=True, restrict: bool | None = None) -> dict:
-        """Retourne la représentation json de l'assiduité
-        restrict n'est pas utilisé ici.
-        """
+    def to_dict(self, format_api=True) -> dict:
+        """Retourne la représentation json de l'assiduité"""
         etat = self.etat
         user: User | None = None
         if format_api:
@@ -159,39 +154,11 @@ class Assiduite(ScoDocModel):
             )
         if date_fin.tzinfo is None:
             log(f"Warning: create_assiduite: date_fin without timezone ({date_fin})")
-
-        # Vérification jours non travaillés
-        # -> vérifie si la date de début ou la date de fin est sur un jour non travaillé
-        # On récupère les formsemestres des dates de début et de fin
-        formsemestre_date_debut: FormSemestre = get_formsemestre_from_data(
-            {
-                "etudid": etud.id,
-                "date_debut": date_debut,
-                "date_fin": date_debut,
-            }
-        )
-        formsemestre_date_fin: FormSemestre = get_formsemestre_from_data(
-            {
-                "etudid": etud.id,
-                "date_debut": date_fin,
-                "date_fin": date_fin,
-            }
-        )
-        if date_debut.weekday() in NonWorkDays.get_all_non_work_days(
-            formsemestre_id=formsemestre_date_debut
-        ):
-            raise ScoValueError("La date de début n'est pas un jour travaillé")
-        if date_fin.weekday() in NonWorkDays.get_all_non_work_days(
-            formsemestre_id=formsemestre_date_fin
-        ):
-            raise ScoValueError("La date de fin n'est pas un jour travaillé")
-
         # Vérification de non duplication des périodes
         assiduites: Query = etud.assiduites
         if is_period_conflicting(date_debut, date_fin, assiduites, Assiduite):
             log(
-                f"""create_assiduite: period_conflicting etudid={etud.id} date_debut={
-                    date_debut} date_fin={date_fin}"""
+                f"create_assiduite: period_conflicting etudid={etud.id} date_debut={date_debut} date_fin={date_fin}"
             )
             raise ScoValueError(
                 "Duplication: la période rentre en conflit avec une plage enregistrée"
@@ -253,57 +220,50 @@ class Assiduite(ScoDocModel):
             sco_abs_notification.abs_notify(etud.id, nouv_assiduite.date_debut)
         return nouv_assiduite
 
-    def set_moduleimpl(self, moduleimpl_id: int | str):
-        """Mise à jour du moduleimpl_id
-        Les valeurs du champ "moduleimpl_id" possibles sont :
-            - <int> (un id classique)
-            - <str> ("autre" ou "<id>")
-            - "" (pas de moduleimpl_id)
-        Si la valeur est "autre" il faut:
-            - mettre à None assiduité.moduleimpl_id
-            - mettre à jour assiduite.external_data["module"] = "autre"
-        En fonction de la configuration du semestre (option force_module) la valeur "" peut-être
-        considérée comme invalide.
-            - Il faudra donc vérifier que ce n'est pas le cas avant de mettre à jour l'assiduité
-        """
-        moduleimpl: ModuleImpl = None
-        if moduleimpl_id == "autre":
-            # Configuration de external_data pour Module Autre
-            # Si self.external_data None alors on créé un dictionnaire {"module": "autre"}
-            # Sinon on met à jour external_data["module"] à "autre"
-
-            if self.external_data is None:
-                self.external_data = {"module": "autre"}
-            else:
-                self.external_data["module"] = "autre"
-
-            # Dans tous les cas une fois fait, assiduite.moduleimpl_id doit être None
-            self.moduleimpl_id = None
-
-            # Ici pas de vérification du force module car on l'a mis dans "external_data"
-            return
-
-        if moduleimpl_id != "":
+    def set_moduleimpl(self, moduleimpl_id: int | str) -> bool:
+        """TODO"""
+        # je ne comprend pas cette fonction WIP
+        # moduleimpl_id peut être == "autre", ce qui plante
+        # ci-dessous un fix temporaire en attendant explication de @iziram
+        if moduleimpl_id is None:
+            raise ScoValueError("invalid moduleimpl_id")
         try:
-                moduleimpl_id = int(moduleimpl_id)
+            moduleimpl_id_int = int(moduleimpl_id)
         except ValueError as exc:
-                raise ScoValueError("Module non reconnu") from exc
-            moduleimpl: ModuleImpl = ModuleImpl.query.get(moduleimpl_id)
-
-        # ici moduleimpl est None si non spécifié
-
-        # Vérification ModuleImpl not None (raise ScoValueError)
-        if moduleimpl is None:
-            self._check_force_module()
-            # Ici uniquement si on est autorisé à ne pas avoir de module
-            self.moduleimpl_id = None
-            return
-
-        # Vérification Inscription ModuleImpl (raise ScoValueError)
+            raise ScoValueError("invalid moduleimpl_id") from exc
+        # /fix
+        moduleimpl: ModuleImpl = ModuleImpl.query.get(moduleimpl_id_int)
+        if moduleimpl is not None:
+            # Vérification de l'inscription de l'étudiant
             if moduleimpl.est_inscrit(self.etudiant):
                 self.moduleimpl_id = moduleimpl.id
             else:
                 raise ScoValueError("L'étudiant n'est pas inscrit au module")
+        elif isinstance(moduleimpl_id, str):
+            if self.external_data is None:
+                self.external_data = {"module": moduleimpl_id}
+            else:
+                self.external_data["module"] = moduleimpl_id
+            self.moduleimpl_id = None
+        else:
+            # Vérification si module forcé
+            formsemestre: FormSemestre = get_formsemestre_from_data(
+                {
+                    "etudid": self.etudid,
+                    "date_debut": self.date_debut,
+                    "date_fin": self.date_fin,
+                }
+            )
+            force: bool
+
+            if formsemestre:
+                force = is_assiduites_module_forced(formsemestre_id=formsemestre.id)
+            else:
+                force = is_assiduites_module_forced(dept_id=self.etudiant.dept_id)
+
+            if force:
+                raise ScoValueError("Module non renseigné")
+        return True
 
     def supprime(self):
         "Supprime l'assiduité. Log et commit."
@@ -333,7 +293,7 @@ class Assiduite(ScoDocModel):
         return get_formsemestre_from_data(self.to_dict())
 
     def get_module(self, traduire: bool = False) -> int | str:
-        "TODO documenter"
+        "TODO"
         if self.moduleimpl_id is not None:
             if traduire:
                 modimpl: ModuleImpl = ModuleImpl.query.get(self.moduleimpl_id)
@@ -349,41 +309,6 @@ class Assiduite(ScoDocModel):
 
         return "Non spécifié" if traduire else None
 
-    def get_saisie(self) -> str:
-        """
-        retourne le texte "saisie le <date> par <User>"
-        """
-
-        date: str = self.entry_date.strftime("%d/%m/%Y à %H:%M")
-        utilisateur: str = ""
-        if self.user != None:
-            self.user: User
-            utilisateur = f"par {self.user.get_prenomnom()}"
-
-        return f"saisie le {date} {utilisateur}"
-
-    def _check_force_module(self):
-        """Vérification si module forcé:
-        Si le module est requis, raise ScoValueError
-        sinon ne fait rien.
-        """
-        # cherche le formsemestre affecté pour utiliser ses préférences
-        formsemestre: FormSemestre = get_formsemestre_from_data(
-            {
-                "etudid": self.etudid,
-                "date_debut": self.date_debut,
-                "date_fin": self.date_fin,
-            }
-        )
-        formsemestre_id = formsemestre.id if formsemestre else None
-        # si pas de formsemestre, utilisera les prefs globales du département
-        dept_id = self.etudiant.dept_id
-        force = is_assiduites_module_forced(
-            formsemestre_id=formsemestre_id, dept_id=dept_id
-        )
-        if force:
-            raise ScoValueError("Module non renseigné")
-
 
 class Justificatif(ScoDocModel):
     """
@@ -418,7 +343,7 @@ class Justificatif(ScoDocModel):
 
     entry_date = db.Column(db.DateTime(timezone=True), server_default=db.func.now())
     "date de création de l'élément: date de saisie"
-    # pourrait devenir date de dépôt au secrétariat, si différente
+    # pourrait devenir date de dépot au secrétariat, si différente
 
     user_id = db.Column(
         db.Integer,
@@ -437,14 +362,6 @@ class Justificatif(ScoDocModel):
     etudiant = db.relationship(
         "Identite", back_populates="justificatifs", lazy="joined"
     )
-    # En revanche, user est rarement accédé:
-    user = db.relationship(
-        "User",
-        backref=db.backref(
-            "justificatifs", lazy="select", order_by="Justificatif.entry_date"
-        ),
-        lazy="select",
-    )
 
     external_data = db.Column(db.JSON, nullable=True)
 
@@ -456,16 +373,20 @@ class Justificatif(ScoDocModel):
             query = query.join(Identite).filter_by(dept_id=g.scodoc_dept_id)
         return query.first_or_404()
 
-    def to_dict(self, format_api: bool = False, restrict: bool = False) -> dict:
-        """L'objet en dictionnaire sérialisable.
-        Si restrict, ne donne par la raison et les fichiers et external_data
-        """
+    def to_dict(self, format_api: bool = False) -> dict:
+        """transformation de l'objet en dictionnaire sérialisable"""
 
         etat = self.etat
-        user: User = self.user if self.user_id is not None else None
+        username = self.user_id
 
         if format_api:
             etat = EtatJustificatif.inverse().get(self.etat).name
+            if self.user_id is not None:
+                user: User = db.session.get(User, self.user_id)
+                if user is None:
+                    username = "Non renseigné"
+                else:
+                    username = user.get_prenomnom()
 
         data = {
             "justif_id": self.justif_id,
@@ -474,13 +395,11 @@ class Justificatif(ScoDocModel):
             "date_debut": self.date_debut,
             "date_fin": self.date_fin,
             "etat": etat,
-            "raison": None if restrict else self.raison,
-            "fichier": None if restrict else self.fichier,
+            "raison": self.raison,
+            "fichier": self.fichier,
             "entry_date": self.entry_date,
-            "user_id": None if user is None else user.id,  # l'uid
-            "user_name": None if user is None else user.user_name,  # le login
-            "user_nom_complet": None if user is None else user.get_nomcomplet(),
-            "external_data": None if restrict else self.external_data,
+            "user_id": username,
+            "external_data": self.external_data,
         }
         return data
 
@@ -627,12 +546,6 @@ def compute_assiduites_justified(
     Returns:
         list[int]: la liste des assiduités qui ont été justifiées.
     """
-    # TODO à optimiser (car très long avec 40000 assiduités)
-    # On devrait :
-    # - récupérer uniquement les assiduités qui sont sur la période des justificatifs donnés
-    # - Pour chaque assiduité trouvée, il faut récupérer les justificatifs qui la justifie
-    # - Si au moins un justificatif valide couvre la période de l'assiduité alors on la justifie
-
     # Si on ne donne pas de justificatifs on prendra par défaut tous les justificatifs de l'étudiant
     if justificatifs is None:
         justificatifs: list[Justificatif] = Justificatif.query.filter_by(

app/models/but_refcomp.py

@@ -1,6 +1,6 @@
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 """ScoDoc 9 models : Référentiel Compétence BUT 2021

app/models/but_validations.py

@@ -9,7 +9,6 @@ from app.models.but_refcomp import ApcNiveau
 from app.models.etudiants import Identite
 from app.models.formsemestre import FormSemestre
 from app.models.ues import UniteEns
-from app.scodoc import sco_preferences
 
 
 class ApcValidationRCUE(db.Model):
@@ -77,12 +76,10 @@ class ApcValidationRCUE(db.Model):
         niveau = self.niveau()
         return niveau.annee if niveau else None
 
-    def niveau(self) -> ApcNiveau | None:
+    def niveau(self) -> ApcNiveau:
         """Le niveau de compétence associé à cet RCUE."""
         # Par convention, il est donné par la seconde UE
-        # à défaut (si l'UE a été désacciée entre temps), la première
-        # et à défaut, renvoie None
-        return self.ue2.niveau_competence or self.ue1.niveau_competence
+        return self.ue2.niveau_competence
 
     def to_dict(self):
         "as a dict"
@@ -221,7 +218,6 @@ def dict_decision_jury(etud: Identite, formsemestre: FormSemestre) -> dict:
         decisions["descr_decisions_rcue"] = ""
         decisions["descr_decisions_niveaux"] = ""
     # --- Année: prend la validation pour l'année scolaire et l'ordre de ce semestre
-    if sco_preferences.get_preference("bul_but_code_annuel", formsemestre.id):
     annee_but = (formsemestre.semestre_id + 1) // 2
     validation = ApcValidationAnnee.query.filter_by(
         etudid=etud.id,
@@ -233,6 +229,4 @@ def dict_decision_jury(etud: Identite, formsemestre: FormSemestre) -> dict:
         decisions["decision_annee"] = validation.to_dict_bul()
     else:
         decisions["decision_annee"] = None
-    else:
-        decisions["decision_annee"] = None
     return decisions

app/models/config.py

@@ -95,7 +95,6 @@ class ScoDocSiteConfig(db.Model):
         "month_debut_annee_scolaire": int,
         "month_debut_periode2": int,
         "disable_bul_pdf": bool,
-        "user_require_email_institutionnel": bool,
         # CAS
         "cas_enable": bool,
         "cas_server": str,
@@ -232,26 +231,12 @@ class ScoDocSiteConfig(db.Model):
         cfg = ScoDocSiteConfig.query.filter_by(name="cas_enable").first()
         return cfg is not None and cfg.value
 
-    @classmethod
-    def is_cas_forced(cls) -> bool:
-        """True si CAS forcé"""
-        cfg = ScoDocSiteConfig.query.filter_by(name="cas_force").first()
-        return cfg is not None and cfg.value
-
     @classmethod
     def is_entreprises_enabled(cls) -> bool:
         """True si on doit activer le module entreprise"""
         cfg = ScoDocSiteConfig.query.filter_by(name="enable_entreprises").first()
         return cfg is not None and cfg.value
 
-    @classmethod
-    def is_user_require_email_institutionnel_enabled(cls) -> bool:
-        """True si impose saisie email_institutionnel"""
-        cfg = ScoDocSiteConfig.query.filter_by(
-            name="user_require_email_institutionnel"
-        ).first()
-        return cfg is not None and cfg.value
-
     @classmethod
     def is_bul_pdf_disabled(cls) -> bool:
         """True si on interdit les exports PDF des bulltins"""
@@ -259,14 +244,36 @@ class ScoDocSiteConfig(db.Model):
         return cfg is not None and cfg.value
 
     @classmethod
-    def enable_entreprises(cls, enabled: bool = True) -> bool:
+    def enable_entreprises(cls, enabled=True) -> bool:
         """Active (ou déactive) le module entreprises. True si changement."""
-        return cls.set("enable_entreprises", "on" if enabled else "")
+        if enabled != ScoDocSiteConfig.is_entreprises_enabled():
+            cfg = ScoDocSiteConfig.query.filter_by(name="enable_entreprises").first()
+            if cfg is None:
+                cfg = ScoDocSiteConfig(
+                    name="enable_entreprises", value="on" if enabled else ""
+                )
+            else:
+                cfg.value = "on" if enabled else ""
+            db.session.add(cfg)
+            db.session.commit()
+            return True
+        return False
 
     @classmethod
     def disable_bul_pdf(cls, enabled=True) -> bool:
-        """Interdit (ou autorise) les exports PDF. True si changement."""
-        return cls.set("disable_bul_pdf", "on" if enabled else "")
+        """Interedit (ou autorise) les exports PDF. True si changement."""
+        if enabled != ScoDocSiteConfig.is_bul_pdf_disabled():
+            cfg = ScoDocSiteConfig.query.filter_by(name="disable_bul_pdf").first()
+            if cfg is None:
+                cfg = ScoDocSiteConfig(
+                    name="disable_bul_pdf", value="on" if enabled else ""
+                )
+            else:
+                cfg.value = "on" if enabled else ""
+            db.session.add(cfg)
+            db.session.commit()
+            return True
+        return False
 
     @classmethod
     def get(cls, name: str, default: str = "") -> str:
@@ -285,10 +292,9 @@ class ScoDocSiteConfig(db.Model):
             if cfg is None:
                 cfg = ScoDocSiteConfig(name=name, value=value_str)
             else:
-                cfg.value = value_str
+                cfg.value = str(value or "")
             current_app.logger.info(
-                f"""ScoDocSiteConfig: recording {cfg.name}='{cfg.value[:32]}{
-                    '...' if len(cfg.value)>32 else ''}'"""
+                f"""ScoDocSiteConfig: recording {cfg.name}='{cfg.value[:32]}...'"""
             )
             db.session.add(cfg)
             db.session.commit()
@@ -297,7 +303,7 @@ class ScoDocSiteConfig(db.Model):
 
     @classmethod
     def _get_int_field(cls, name: str, default=None) -> int:
-        """Valeur d'un champ integer"""
+        """Valeur d'un champs integer"""
         cfg = ScoDocSiteConfig.query.filter_by(name=name).first()
         if (cfg is None) or cfg.value is None:
             return default
@@ -311,7 +317,7 @@ class ScoDocSiteConfig(db.Model):
         default=None,
         range_values: tuple = (),
     ) -> bool:
-        """Set champ integer. True si changement."""
+        """Set champs integer. True si changement."""
         if value != cls._get_int_field(name, default=default):
             if not isinstance(value, int) or (
                 range_values and (value < range_values[0]) or (value > range_values[1])

app/models/etudiants.py

@@ -19,7 +19,7 @@ from app.models.departements import Departement
 from app.models.scolar_event import ScolarEvent
 from app.scodoc import notesdb as ndb
 from app.scodoc.sco_bac import Baccalaureat
-from app.scodoc.sco_exceptions import ScoGenError, ScoInvalidParamError, ScoValueError
+from app.scodoc.sco_exceptions import ScoInvalidParamError, ScoValueError
 import app.scodoc.sco_utils as scu
 
 
@@ -101,12 +101,7 @@ class Identite(models.ScoDocModel):
     adresses = db.relationship(
         "Adresse", back_populates="etud", cascade="all,delete", lazy="dynamic"
     )
-    annotations = db.relationship(
-        "EtudAnnotation",
-        backref="etudiant",
-        cascade="all, delete-orphan",
-        lazy="dynamic",
-    )
+
     billets = db.relationship("BilletAbsence", backref="etudiant", lazy="dynamic")
     #
     dispense_ues = db.relationship(
@@ -124,9 +119,6 @@ class Identite(models.ScoDocModel):
         "Justificatif", back_populates="etudiant", lazy="dynamic", cascade="all, delete"
     )
 
-    # Champs "protégés" par ViewEtudData (RGPD)
-    protected_attrs = {"boursier"}
-
     def __repr__(self):
         return (
             f"<Etud {self.id}/{self.departement.acronym} {self.nom!r} {self.prenom!r}>"
@@ -184,7 +176,7 @@ class Identite(models.ScoDocModel):
     def url_fiche(self) -> str:
         "url de la fiche étudiant"
         return url_for(
-            "scolar.fiche_etud", scodoc_dept=self.departement.acronym, etudid=self.id
+            "scolar.ficheEtud", scodoc_dept=self.departement.acronym, etudid=self.id
         )
 
     @classmethod
@@ -238,15 +230,6 @@ class Identite(models.ScoDocModel):
         log(f"Identite.create {etud}")
         return etud
 
-    def from_dict(self, args, **kwargs) -> bool:
-        """Check arguments, then modify.
-        Add to session but don't commit.
-        True if modification.
-        """
-        check_etud_duplicate_code(args, "code_nip")
-        check_etud_duplicate_code(args, "code_ine")
-        return super().from_dict(args, **kwargs)
-
     @classmethod
     def filter_model_attributes(cls, data: dict, excluded: set[str] = None) -> dict:
         """Returns a copy of dict with only the keys belonging to the Model and not in excluded."""
@@ -367,8 +350,8 @@ class Identite(models.ScoDocModel):
         { formsemestre_id : [ modimpl, ... ] }
         annee_scolaire est un nombre: eg 2023
         """
-        date_debut_annee = scu.date_debut_annee_scolaire(annee_scolaire)
-        date_fin_annee = scu.date_fin_annee_scolaire(annee_scolaire)
+        date_debut_annee = scu.date_debut_anne_scolaire(annee_scolaire)
+        date_fin_annee = scu.date_fin_anne_scolaire(annee_scolaire)
         modimpls = (
             ModuleImpl.query.join(ModuleImplInscription)
             .join(FormSemestre)
@@ -435,7 +418,7 @@ class Identite(models.ScoDocModel):
         return args_dict
 
     def to_dict_short(self) -> dict:
-        """Les champs essentiels (aucune donnée perso protégée)"""
+        """Les champs essentiels"""
         return {
             "id": self.id,
             "civilite": self.civilite,
@@ -450,11 +433,9 @@ class Identite(models.ScoDocModel):
             "prenom_etat_civil": self.prenom_etat_civil,
         }
 
-    def to_dict_scodoc7(self, restrict=False, with_inscriptions=False) -> dict:
+    def to_dict_scodoc7(self) -> dict:
         """Représentation dictionnaire,
-        compatible ScoDoc7 mais sans infos admission.
-        Si restrict, cache les infos "personnelles" si pas permission ViewEtudData
-        Si with_inscriptions, inclut les champs "inscription"
+        compatible ScoDoc7 mais sans infos admission
         """
         e_dict = self.__dict__.copy()  # dict(self.__dict__)
         e_dict.pop("_sa_instance_state", None)
@@ -465,9 +446,7 @@ class Identite(models.ScoDocModel):
         e_dict["nomprenom"] = self.nomprenom
         adresse = self.adresses.first()
         if adresse:
-            e_dict.update(adresse.to_dict(restrict=restrict))
-        if with_inscriptions:
-            e_dict.update(self.inscription_descr())
+            e_dict.update(adresse.to_dict())
         return {k: v or "" for k, v in e_dict.items()}  # convert_null_outputs_to_empty
 
     def to_dict_bul(self, include_urls=True):
@@ -482,9 +461,9 @@ class Identite(models.ScoDocModel):
             "civilite": self.civilite,
             "code_ine": self.code_ine or "",
             "code_nip": self.code_nip or "",
-            "date_naissance": (
-                self.date_naissance.strftime("%d/%m/%Y") if self.date_naissance else ""
-            ),
+            "date_naissance": self.date_naissance.strftime("%d/%m/%Y")
+            if self.date_naissance
+            else "",
             "dept_acronym": self.departement.acronym,
             "dept_id": self.dept_id,
             "dept_naissance": self.dept_naissance or "",
@@ -502,7 +481,7 @@ class Identite(models.ScoDocModel):
         if include_urls and has_request_context():
             # test request context so we can use this func in tests under the flask shell
             d["fiche_url"] = url_for(
-                "scolar.fiche_etud", scodoc_dept=g.scodoc_dept, etudid=self.id
+                "scolar.ficheEtud", scodoc_dept=g.scodoc_dept, etudid=self.id
             )
             d["photo_url"] = sco_photos.get_etud_photo_url(self.id)
         adresse = self.adresses.first()
@@ -511,33 +490,16 @@ class Identite(models.ScoDocModel):
             d["id"] = self.id  # a été écrasé par l'id de adresse
         return d
 
-    def to_dict_api(self, restrict=False, with_annotations=False) -> dict:
-        """Représentation dictionnaire pour export API, avec adresses et admission.
-        Si restrict, supprime les infos "personnelles" (boursier)
-        """
+    def to_dict_api(self) -> dict:
+        """Représentation dictionnaire pour export API, avec adresses et admission."""
         e = dict(self.__dict__)
         e.pop("_sa_instance_state", None)
         admission = self.admission
         e["admission"] = admission.to_dict() if admission is not None else None
-        e["adresses"] = [adr.to_dict(restrict=restrict) for adr in self.adresses]
+        e["adresses"] = [adr.to_dict() for adr in self.adresses]
         e["dept_acronym"] = self.departement.acronym
         e.pop("departement", None)
         e["sort_key"] = self.sort_key
-        if with_annotations:
-            e["annotations"] = (
-                [
-                    annot.to_dict()
-                    for annot in EtudAnnotation.query.filter_by(
-                        etudid=self.id
-                    ).order_by(desc(EtudAnnotation.date))
-                ]
-                if not restrict
-                else []
-            )
-        if restrict:
-            # Met à None les attributs protégés:
-            for attr in self.protected_attrs:
-                e[attr] = None
         return e
 
     def inscriptions(self) -> list["FormSemestreInscription"]:
@@ -593,9 +555,7 @@ class Identite(models.ScoDocModel):
         return r[0] if r else None
 
     def inscription_descr(self) -> dict:
-        """Description de l'état d'inscription
-        avec champs compatibles templates ScoDoc7
-        """
+        """Description de l'état d'inscription"""
         inscription_courante = self.inscription_courante()
         if inscription_courante:
             titre_sem = inscription_courante.formsemestre.titre_mois()
@@ -606,7 +566,7 @@ class Identite(models.ScoDocModel):
             else:
                 inscr_txt = "Inscrit en"
 
-            result = {
+            return {
                 "etat_in_cursem": inscription_courante.etat,
                 "inscription_courante": inscription_courante,
                 "inscription": titre_sem,
@@ -629,20 +589,15 @@ class Identite(models.ScoDocModel):
                     inscription = "ancien"
                     situation = "ancien élève"
             else:
-                inscription = "non inscrit"
+                inscription = ("non inscrit",)
                 situation = inscription
-            result = {
+            return {
                 "etat_in_cursem": "?",
                 "inscription_courante": None,
                 "inscription": inscription,
                 "inscription_str": inscription,
                 "situation": situation,
             }
-        # aliases pour compat templates ScoDoc7
-        result["etatincursem"] = result["etat_in_cursem"]
-        result["inscriptionstr"] = result["inscription_str"]
-
-        return result
 
     def inscription_etat(self, formsemestre_id: int) -> str:
         """État de l'inscription de cet étudiant au semestre:
@@ -763,58 +718,6 @@ class Identite(models.ScoDocModel):
         )
 
 
-def check_etud_duplicate_code(args, code_name, edit=True):
-    """Vérifie que le code n'est pas dupliqué.
-    Raises ScoGenError si problème.
-    """
-    etudid = args.get("etudid", None)
-    if not args.get(code_name, None):
-        return
-    etuds = Identite.query.filter_by(
-        **{code_name: str(args[code_name]), "dept_id": g.scodoc_dept_id}
-    ).all()
-    duplicate = False
-    if edit:
-        duplicate = (len(etuds) > 1) or ((len(etuds) == 1) and etuds[0].id != etudid)
-    else:
-        duplicate = len(etuds) > 0
-    if duplicate:
-        listh = []  # liste des doubles
-        for etud in etuds:
-            listh.append(f"Autre étudiant: {etud.html_link_fiche()}")
-        if etudid:
-            submit_label = "retour à la fiche étudiant"
-            dest_endpoint = "scolar.fiche_etud"
-            parameters = {"etudid": etudid}
-        else:
-            if "tf_submitted" in args:
-                del args["tf_submitted"]
-                submit_label = "Continuer"
-                dest_endpoint = "scolar.etudident_create_form"
-                parameters = args
-            else:
-                submit_label = "Annuler"
-                dest_endpoint = "notes.index_html"
-                parameters = {}
-
-        err_page = f"""<h3><h3>Code étudiant ({code_name}) dupliqué !</h3>
-        <p class="help">Le {code_name} {args[code_name]} est déjà utilisé: un seul étudiant peut avoir
-        ce code. Vérifier votre valeur ou supprimer l'autre étudiant avec cette valeur.
-        </p>
-        <ul><li>
-        { '</li><li>'.join(listh) }
-        </li></ul>
-        <p>
-        <a href="{ url_for(dest_endpoint, scodoc_dept=g.scodoc_dept, **parameters) }
-        ">{submit_label}</a>
-        </p>
-        """
-
-        log(f"*** error: code {code_name} duplique: {args[code_name]}")
-
-        raise ScoGenError(err_page)
-
-
 def make_etud_args(
     etudid=None, code_nip=None, use_request=True, raise_exc=False, abort_404=True
 ) -> dict:
@@ -922,25 +825,12 @@ class Adresse(models.ScoDocModel):
     )
     description = db.Column(db.Text)
 
-    # Champs "protégés" par ViewEtudData (RGPD)
-    protected_attrs = {
-        "emailperso",
-        "domicile",
-        "codepostaldomicile",
-        "villedomicile",
-        "telephone",
-        "telephonemobile",
-        "fax",
-    }
-
-    def to_dict(self, convert_nulls_to_str=False, restrict=False):
-        """Représentation dictionnaire. Si restrict, filtre les champs protégés (RGPD)."""
+    def to_dict(self, convert_nulls_to_str=False):
+        """Représentation dictionnaire,"""
         e = dict(self.__dict__)
         e.pop("_sa_instance_state", None)
         if convert_nulls_to_str:
-            e = {k: v or "" for k, v in e.items()}
-        if restrict:
-            e = {k: v for (k, v) in e.items() if k not in self.protected_attrs}
+            return {k: e[k] or "" for k in e}
         return e
 
 
@@ -995,16 +885,12 @@ class Admission(models.ScoDocModel):
     # classement (1..Ngr) par le jury dans le groupe APB
     apb_classement_gr = db.Column(db.Integer)
 
-    # Tous les champs sont "protégés" par ViewEtudData (RGPD)
-    # sauf:
-    not_protected_attrs = {"bac", "specialite", "anne_bac"}
-
     def get_bac(self) -> Baccalaureat:
         "Le bac. utiliser bac.abbrev() pour avoir une chaine de caractères."
         return Baccalaureat(self.bac, specialite=self.specialite)
 
-    def to_dict(self, no_nulls=False, restrict=False):
-        """Représentation dictionnaire. Si restrict, filtre les champs protégés (RGPD)."""
+    def to_dict(self, no_nulls=False):
+        """Représentation dictionnaire,"""
         d = dict(self.__dict__)
         d.pop("_sa_instance_state", None)
         if no_nulls:
@@ -1019,8 +905,6 @@ class Admission(models.ScoDocModel):
                         d[key] = 0
                     elif isinstance(col_type, sqlalchemy.Boolean):
                         d[key] = False
-        if restrict:
-            d = {k: v for (k, v) in d.items() if k in self.not_protected_attrs}
         return d
 
     @classmethod
@@ -1088,16 +972,10 @@ class EtudAnnotation(db.Model):
 
     id = db.Column(db.Integer, primary_key=True)
     date = db.Column(db.DateTime(timezone=True), server_default=db.func.now())
-    etudid = db.Column(db.Integer, db.ForeignKey(Identite.id))
+    etudid = db.Column(db.Integer)  # sans contrainte (compat ScoDoc 7))
     author = db.Column(db.Text)  # le pseudo (user_name), was zope_authenticated_user
     comment = db.Column(db.Text)
 
-    def to_dict(self):
-        """Représentation dictionnaire."""
-        e = dict(self.__dict__)
-        e.pop("_sa_instance_state", None)
-        return e
-
 
 from app.models.formsemestre import FormSemestre
 from app.models.modules import Module

app/models/evaluations.py

@@ -5,7 +5,7 @@
 import datetime
 from operator import attrgetter
 
-from flask import abort, g, url_for
+from flask import g, url_for
 from flask_login import current_user
 import sqlalchemy as sa
 
@@ -184,7 +184,7 @@ class Evaluation(db.Model):
         # ScoDoc7 output_formators
         e_dict["evaluation_id"] = self.id
         e_dict["date_debut"] = self.date_debut.isoformat() if self.date_debut else None
-        e_dict["date_fin"] = self.date_fin.isoformat() if self.date_fin else None
+        e_dict["date_fin"] = self.date_debut.isoformat() if self.date_fin else None
         e_dict["numero"] = self.numero or 0
         e_dict["poids"] = self.get_ue_poids_dict()  # { ue_id : poids }
 
@@ -241,25 +241,6 @@ class Evaluation(db.Model):
             if k != "_sa_instance_state" and k != "id" and k in data:
                 setattr(self, k, data[k])
 
-    @classmethod
-    def get_evaluation(
-        cls, evaluation_id: int | str, dept_id: int = None
-    ) -> "Evaluation":
-        """Evaluation ou 404, cherche uniquement dans le département spécifié ou le courant."""
-        from app.models import FormSemestre, ModuleImpl
-
-        if not isinstance(evaluation_id, int):
-            try:
-                evaluation_id = int(evaluation_id)
-            except (TypeError, ValueError):
-                abort(404, "evaluation_id invalide")
-        if g.scodoc_dept:
-            dept_id = dept_id if dept_id is not None else g.scodoc_dept_id
-        query = cls.query.filter_by(id=evaluation_id)
-        if dept_id is not None:
-            query = query.join(ModuleImpl).join(FormSemestre).filter_by(dept_id=dept_id)
-        return query.first_or_404()
-
     @classmethod
     def get_max_numero(cls, moduleimpl_id: int) -> int:
         """Return max numero among evaluations in this
@@ -284,9 +265,7 @@ class Evaluation(db.Model):
         evaluations = moduleimpl.evaluations.order_by(
             Evaluation.date_debut, Evaluation.numero
         ).all()
-        numeros_distincts = {e.numero for e in evaluations if e.numero is not None}
-        # pas de None, pas de dupliqués
-        all_numbered = len(numeros_distincts) == len(evaluations)
+        all_numbered = all(e.numero is not None for e in evaluations)
         if all_numbered and only_if_unumbered:
             return  # all ok
 
@@ -449,8 +428,8 @@ class Evaluation(db.Model):
 
     def get_ue_poids_str(self) -> str:
         """string describing poids, for excel cells and pdfs
-        Note: les poids nuls ou non initialisés (poids par défaut),
-        ne sont pas affichés.
+        Note: si les poids ne sont pas initialisés (poids par défaut),
+        ils ne sont pas affichés.
         """
         # restreint aux UE du semestre dans lequel est cette évaluation
         # au cas où le module ait changé de semestre et qu'il reste des poids
@@ -461,7 +440,7 @@ class Evaluation(db.Model):
                 for p in sorted(
                     self.ue_poids, key=lambda p: (p.ue.numero or 0, p.ue.acronyme)
                 )
-                if evaluation_semestre_idx == p.ue.semestre_idx and (p.poids or 0) > 0
+                if evaluation_semestre_idx == p.ue.semestre_idx
             ]
         )
 
@@ -605,10 +584,20 @@ def check_convert_evaluation_args(moduleimpl: "ModuleImpl", data: dict):
     if date_debut and date_fin:
         duration = data["date_fin"] - data["date_debut"]
         if duration.total_seconds() < 0 or duration > MAX_EVALUATION_DURATION:
-            raise ScoValueError(
-                "Heures de l'évaluation incohérentes !",
-                dest_url="javascript:history.back();",
-            )
+            raise ScoValueError("Heures de l'évaluation incohérentes !")
+    # # --- heures
+    # heure_debut = data.get("heure_debut", None)
+    # if heure_debut and not isinstance(heure_debut, datetime.time):
+    #     if date_format == "dmy":
+    #         data["heure_debut"] = heure_to_time(heure_debut)
+    #     else:  # ISO
+    #         data["heure_debut"] = datetime.time.fromisoformat(heure_debut)
+    # heure_fin = data.get("heure_fin", None)
+    # if heure_fin and not isinstance(heure_fin, datetime.time):
+    #     if date_format == "dmy":
+    #         data["heure_fin"] = heure_to_time(heure_fin)
+    #     else:  # ISO
+    #         data["heure_fin"] = datetime.time.fromisoformat(heure_fin)
 
 
 def heure_to_time(heure: str) -> datetime.time:

app/models/formsemestre.py

@@ -1,7 +1,7 @@
 # -*- coding: UTF-8 -*
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 
@@ -10,15 +10,13 @@
 
 """ScoDoc models: formsemestre
 """
-from collections import defaultdict
 import datetime
 from functools import cached_property
-from itertools import chain
 from operator import attrgetter
 
 from flask_login import current_user
 
-from flask import abort, flash, g, url_for
+from flask import flash, g, url_for
 from sqlalchemy.sql import text
 from sqlalchemy import func
 
@@ -37,11 +35,7 @@ from app.models.etudiants import Identite
 from app.models.evaluations import Evaluation
 from app.models.formations import Formation
 from app.models.groups import GroupDescr, Partition
-from app.models.moduleimpls import (
-    ModuleImpl,
-    ModuleImplInscription,
-    notes_modules_enseignants,
-)
+from app.models.moduleimpls import ModuleImpl, ModuleImplInscription
 from app.models.modules import Module
 from app.models.ues import UniteEns
 from app.models.validations import ScolarFormSemestreValidation
@@ -51,6 +45,8 @@ from app.scodoc.sco_permissions import Permission
 from app.scodoc.sco_utils import MONTH_NAMES_ABBREV, translate_assiduites_metric
 from app.scodoc.sco_vdi import ApoEtapeVDI
 
+from app.scodoc.sco_utils import translate_assiduites_metric
+
 GROUPS_AUTO_ASSIGNMENT_DATA_MAX = 1024 * 1024  # bytes
 
 
@@ -68,7 +64,7 @@ class FormSemestre(db.Model):
     semestre_id = db.Column(db.Integer, nullable=False, default=1, server_default="1")
     titre = db.Column(db.Text(), nullable=False)
     date_debut = db.Column(db.Date(), nullable=False)
-    date_fin = db.Column(db.Date(), nullable=False)  # jour inclus
+    date_fin = db.Column(db.Date(), nullable=False)
     edt_id: str | None = db.Column(db.Text(), index=True, nullable=True)
     "identifiant emplois du temps (unicité non imposée)"
     etat = db.Column(db.Boolean(), nullable=False, default=True, server_default="true")
@@ -185,14 +181,9 @@ class FormSemestre(db.Model):
 
     @classmethod
     def get_formsemestre(
-        cls, formsemestre_id: int | str, dept_id: int = None
+        cls, formsemestre_id: int, dept_id: int = None
     ) -> "FormSemestre":
-        """FormSemestre ou 404, cherche uniquement dans le département spécifié ou le courant"""
-        if not isinstance(formsemestre_id, int):
-            try:
-                formsemestre_id = int(formsemestre_id)
-            except (TypeError, ValueError):
-                abort(404, "formsemestre_id invalide")
+        """ "FormSemestre ou 404, cherche uniquement dans le département spécifié ou le courant"""
         if g.scodoc_dept:
             dept_id = dept_id if dept_id is not None else g.scodoc_dept_id
         if dept_id is not None:
@@ -280,10 +271,7 @@ class FormSemestre(db.Model):
         raise ScoValueError("Le semestre n'a pas de groupe par défaut")
 
     def get_edt_ids(self) -> list[str]:
-        """Les ids pour l'emploi du temps: à défaut, les codes étape Apogée.
-        Les edt_id de formsemestres ne sont pas normalisés afin de contrôler
-        précisément l'accès au fichier ics.
-        """
+        "l'ids pour l'emploi du temps: à défaut, les codes étape Apogée"
         return (
             scu.split_id(self.edt_id)
             or [e.etape_apo.strip() for e in self.etapes if e.etape_apo]
@@ -392,80 +380,6 @@ class FormSemestre(db.Model):
         _cache[key] = ues
         return ues
 
-    @classmethod
-    def get_user_formsemestres_annee_by_dept(
-        cls, user: User
-    ) -> tuple[
-        defaultdict[int, list["FormSemestre"]], defaultdict[int, list[ModuleImpl]]
-    ]:
-        """Liste des formsemestres de l'année scolaire
-        dans lesquels user intervient (comme resp., resp. de module ou enseignant),
-        ainsi que la liste des modimpls concernés dans chaque formsemestre
-        Attention: les semestres et modimpls peuvent être de différents départements !
-        Résultat:
-            { dept_id : [ formsemestre, ... ] },
-            { formsemestre_id : [ modimpl, ... ]}
-        """
-        debut_annee_scolaire = scu.date_debut_annee_scolaire()
-        fin_annee_scolaire = scu.date_fin_annee_scolaire()
-
-        query = FormSemestre.query.filter(
-            FormSemestre.date_fin >= debut_annee_scolaire,
-            FormSemestre.date_debut < fin_annee_scolaire,
-        )
-        # responsable ?
-        formsemestres_resp = query.join(notes_formsemestre_responsables).filter_by(
-            responsable_id=user.id
-        )
-        # Responsable d'un modimpl ?
-        modimpls_resp = (
-            ModuleImpl.query.filter_by(responsable_id=user.id)
-            .join(FormSemestre)
-            .filter(
-                FormSemestre.date_fin >= debut_annee_scolaire,
-                FormSemestre.date_debut < fin_annee_scolaire,
-            )
-        )
-        # Enseignant dans un modimpl ?
-        modimpls_ens = (
-            ModuleImpl.query.join(notes_modules_enseignants)
-            .filter_by(ens_id=user.id)
-            .join(FormSemestre)
-            .filter(
-                FormSemestre.date_fin >= debut_annee_scolaire,
-                FormSemestre.date_debut < fin_annee_scolaire,
-            )
-        )
-        # Liste les modimpls, uniques
-        modimpls = modimpls_resp.all()
-        ids = {modimpl.id for modimpl in modimpls}
-        for modimpl in modimpls_ens:
-            if modimpl.id not in ids:
-                modimpls.append(modimpl)
-                ids.add(modimpl.id)
-        # Liste les formsemestres et modimpls associés
-        modimpls_by_formsemestre = defaultdict(lambda: [])
-        formsemestres = formsemestres_resp.all()
-        ids = {formsemestre.id for formsemestre in formsemestres}
-        for modimpl in chain(modimpls_resp, modimpls_ens):
-            if modimpl.formsemestre_id not in ids:
-                formsemestres.append(modimpl.formsemestre)
-                ids.add(modimpl.formsemestre_id)
-            modimpls_by_formsemestre[modimpl.formsemestre_id].append(modimpl)
-        # Tris et organisation par département
-        formsemestres_by_dept = defaultdict(lambda: [])
-        formsemestres.sort(key=lambda x: (x.departement.acronym,) + x.sort_key())
-        for formsemestre in formsemestres:
-            formsemestres_by_dept[formsemestre.dept_id].append(formsemestre)
-            modimpls = modimpls_by_formsemestre[formsemestre.id]
-            if formsemestre.formation.is_apc():
-                key = lambda x: x.module.sort_key_apc()
-            else:
-                key = lambda x: x.module.sort_key()
-            modimpls.sort(key=key)
-
-        return formsemestres_by_dept, modimpls_by_formsemestre
-
     def get_evaluations(self) -> list[Evaluation]:
         "Liste de toutes les évaluations du semestre, triées par module/numero"
         return (
@@ -673,7 +587,7 @@ class FormSemestre(db.Model):
     ) -> db.Query:
         """Liste (query) ordonnée des formsemestres courants, c'est
         à dire contenant la date courant (si None, la date actuelle)"""
-        date_courante = date_courante or db.func.current_date()
+        date_courante = date_courante or db.func.now()
         # Les semestres en cours de ce département
         formsemestres = FormSemestre.query.filter(
             FormSemestre.dept_id == dept.id,

app/models/groups.py

@@ -1,7 +1,7 @@
 # -*- coding: UTF-8 -*
 ##############################################################################
 # ScoDoc
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
 # See LICENSE
 ##############################################################################
 
@@ -251,11 +251,8 @@ class GroupDescr(ScoDocModel):
         return d
 
     def get_edt_ids(self) -> list[str]:
-        "les ids normalisés pour l'emploi du temps: à défaut, le nom scodoc du groupe"
-        return [
-            scu.normalize_edt_id(x)
-            for x in scu.split_id(self.edt_id) or [self.group_name] or []
-        ]
+        "les ids pour l'emploi du temps: à défaut, le nom scodoc du groupe"
+        return scu.split_id(self.edt_id) or [self.group_name] or []
 
     def get_nb_inscrits(self) -> int:
         """Nombre inscrits à ce group et au formsemestre.

app/models/moduleimpls.py

@@ -2,14 +2,13 @@
 """ScoDoc models: moduleimpls
 """
 import pandas as pd
-from flask import abort, g
-from flask_login import current_user
 from flask_sqlalchemy.query import Query
+import sqlalchemy as sa
 
 from app import db
 from app.auth.models import User
 from app.comp import df_cache
-from app.models import APO_CODE_STR_LEN, ScoDocModel
+from app.models import APO_CODE_STR_LEN
 from app.models.etudiants import Identite
 from app.models.evaluations import Evaluation
 from app.models.modules import Module
@@ -18,7 +17,7 @@ from app.scodoc.sco_permissions import Permission
 from app.scodoc import sco_utils as scu
 
 
-class ModuleImpl(ScoDocModel):
+class ModuleImpl(db.Model):
     """Mise en oeuvre d'un module pour une annee/semestre"""
 
     __tablename__ = "notes_moduleimpl"
@@ -37,10 +36,7 @@ class ModuleImpl(ScoDocModel):
         index=True,
         nullable=False,
     )
-    responsable_id = db.Column(
-        "responsable_id", db.Integer, db.ForeignKey("user.id", ondelete="SET NULL")
-    )
-    responsable = db.relationship("User", back_populates="modimpls")
+    responsable_id = db.Column("responsable_id", db.Integer, db.ForeignKey("user.id"))
     # formule de calcul moyenne:
     computation_expr = db.Column(db.Text())
 
@@ -56,8 +52,8 @@ class ModuleImpl(ScoDocModel):
         secondary="notes_modules_enseignants",
         lazy="dynamic",
         backref="moduleimpl",
+        viewonly=True,
     )
-    "enseignants du module (sans le responsable)"
 
     def __repr__(self):
         return f"<{self.__class__.__name__} {self.id} module={repr(self.module)}>"
@@ -72,10 +68,11 @@ class ModuleImpl(ScoDocModel):
 
     def get_edt_ids(self) -> list[str]:
         "les ids pour l'emploi du temps: à défaut, les codes Apogée"
-        return [
-            scu.normalize_edt_id(x)
-            for x in scu.split_id(self.edt_id) or scu.split_id(self.code_apogee)
-        ] or self.module.get_edt_ids()
+        return (
+            scu.split_id(self.edt_id)
+            or scu.split_id(self.code_apogee)
+            or self.module.get_edt_ids()
+        )
 
     def get_evaluations_poids(self) -> pd.DataFrame:
         """Les poids des évaluations vers les UE (accès via cache)"""
@@ -87,23 +84,6 @@ class ModuleImpl(ScoDocModel):
             df_cache.EvaluationsPoidsCache.set(self.id, evaluations_poids)
         return evaluations_poids
 
-    @classmethod
-    def get_modimpl(cls, moduleimpl_id: int | str, dept_id: int = None) -> "ModuleImpl":
-        """ModuleImpl ou 404, cherche uniquement dans le département spécifié ou le courant."""
-        from app.models.formsemestre import FormSemestre
-
-        if not isinstance(moduleimpl_id, int):
-            try:
-                moduleimpl_id = int(moduleimpl_id)
-            except (TypeError, ValueError):
-                abort(404, "moduleimpl_id invalide")
-        if g.scodoc_dept:
-            dept_id = dept_id if dept_id is not None else g.scodoc_dept_id
-        query = cls.query.filter_by(id=moduleimpl_id)
-        if dept_id is not None:
-            query = query.join(FormSemestre).filter_by(dept_id=dept_id)
-        return query.first_or_404()
-
     def invalidate_evaluations_poids(self):
         """Invalide poids cachés"""
         df_cache.EvaluationsPoidsCache.delete(self.id)
@@ -191,7 +171,7 @@ class ModuleImpl(ScoDocModel):
             return allow_ens and user.id in (ens.id for ens in self.enseignants)
         return True
 
-    def can_change_responsable(self, user: User, raise_exc=False) -> bool:
+    def can_change_ens_by(self, user: User, raise_exc=False) -> bool:
         """Check if user can modify module resp.
         If raise_exc, raises exception (AccessDenied or ScoLockedSemError) if not.
         = Admin, et dir des etud. (si option l'y autorise)
@@ -212,27 +192,6 @@ class ModuleImpl(ScoDocModel):
             raise AccessDenied(f"Modification impossible pour {user}")
         return False
 
-    def can_change_ens(self, user: User | None = None, raise_exc=True) -> bool:
-        """check if user can modify ens list (raise exception if not)"
-        if user is None, current user.
-        """
-        user = current_user if user is None else user
-        if not self.formsemestre.etat:
-            if raise_exc:
-                raise ScoLockedSemError("Modification impossible: semestre verrouille")
-            return False
-        # -- check access
-        # admin, resp. module ou resp. semestre
-        if (
-            user.id != self.responsable_id
-            and not user.has_permission(Permission.EditFormSemestre)
-            and user.id not in (u.id for u in self.formsemestre.responsables)
-        ):
-            if raise_exc:
-                raise AccessDenied(f"Modification impossible pour {user}")
-            return False
-        return True
-
     def est_inscrit(self, etud: Identite) -> bool:
         """
         Vérifie si l'étudiant est bien inscrit au moduleimpl (même si DEM ou DEF au semestre).

app/models/modules.py

@@ -1,6 +1,6 @@
 """ScoDoc 9 models : Modules
 """
-from flask import current_app, g
+from flask import current_app
 
 from app import db
 from app.models import APO_CODE_STR_LEN
@@ -160,10 +160,6 @@ class Module(db.Model):
         "Identifiant du module à afficher : abbrev ou titre ou code"
         return self.abbrev or self.titre or self.code
 
-    def sort_key(self) -> tuple:
-        """Clé de tri pour formations classiques"""
-        return self.numero or 0, self.code
-
     def sort_key_apc(self) -> tuple:
         """Clé de tri pour avoir
         présentation par type (res, sae), parcours, type, numéro
@@ -292,10 +288,7 @@ class Module(db.Model):
 
     def get_edt_ids(self) -> list[str]:
         "les ids pour l'emploi du temps: à défaut, le 1er code Apogée"
-        return [
-            scu.normalize_edt_id(x)
-            for x in scu.split_id(self.edt_id) or scu.split_id(self.code_apogee) or []
-        ]
+        return scu.split_id(self.edt_id) or scu.split_id(self.code_apogee) or []
 
     def get_parcours(self) -> list[ApcParcours]:
         """Les parcours utilisant ce module.
@@ -310,14 +303,6 @@ class Module(db.Model):
             return []
         return self.parcours
 
-    def add_tag(self, tag: "NotesTag"):
-        """Add tag to module. Check if already has it."""
-        if tag.id in {t.id for t in self.tags}:
-            return
-        self.tags.append(tag)
-        db.session.add(self)
-        db.session.flush()
-
 
 class ModuleUECoef(db.Model):
     """Coefficients des modules vers les UE (APC, BUT)
@@ -380,19 +365,6 @@ class NotesTag(db.Model):
     dept_id = db.Column(db.Integer, db.ForeignKey("departement.id"), index=True)
     title = db.Column(db.Text(), nullable=False)
 
-    @classmethod
-    def get_or_create(cls, title: str, dept_id: int | None = None) -> "NotesTag":
-        """Get tag, or create it if it doesn't yet exists.
-        If dept_id unspecified, use current dept.
-        """
-        dept_id = dept_id if dept_id is not None else g.scodoc_dept_id
-        tag = NotesTag.query.filter_by(dept_id=dept_id, title=title).first()
-        if tag is None:
-            tag = NotesTag(dept_id=dept_id, title=title)
-            db.session.add(tag)
-            db.session.flush()
-        return tag
-
 
 # Association tag <-> module
 notes_modules_tags = db.Table(

app/models/ues.py

@@ -5,7 +5,6 @@ from flask import g
 import pandas as pd
 
 from app import db, log
-from app import models
 from app.models import APO_CODE_STR_LEN
 from app.models import SHORT_STR_LEN
 from app.models.but_refcomp import ApcNiveau, ApcParcours
@@ -13,7 +12,7 @@ from app.models.modules import Module
 from app.scodoc import sco_utils as scu
 
 
-class UniteEns(models.ScoDocModel):
+class UniteEns(db.Model):
     """Unité d'Enseignement (UE)"""
 
     __tablename__ = "notes_ue"
@@ -82,7 +81,7 @@ class UniteEns(models.ScoDocModel):
             'EXTERNE' if self.is_external else ''})>"""
 
     def clone(self):
-        """Create a new copy of this ue, add to session.
+        """Create a new copy of this ue.
         Ne copie pas le code, ni le code Apogée, ni les liens au réf. de comp.
         (parcours et niveau).
         """
@@ -101,26 +100,8 @@ class UniteEns(models.ScoDocModel):
             coef_rcue=self.coef_rcue,
             color=self.color,
         )
-        db.session.add(ue)
         return ue
 
-    @classmethod
-    def convert_dict_fields(cls, args: dict) -> dict:
-        """Convert fields from the given dict to model's attributes values. No side effect.
-
-        args: dict with args in application.
-        returns: dict to store in model's db.
-        """
-        args = args.copy()
-        if "type" in args:
-            args["type"] = int(args["type"] or 0)
-        if "is_external" in args:
-            args["is_external"] = scu.to_bool(args["is_external"])
-        if "ects" in args:
-            args["ects"] = float(args["ects"])
-
-        return args
-
     def to_dict(self, convert_objects=False, with_module_ue_coefs=True):
         """as a dict, with the same conversions as in ScoDoc7.
         If convert_objects, convert all attributes to native types

app/pe/pe_affichage.py

@@ -1,44 +0,0 @@
-##############################################################################
-#  Module "Avis de poursuite d'étude"
-#  conçu et développé par Cléo Baras (IUT de Grenoble)
-##############################################################################
-
-"""Affichages, debug
-"""
-
-from flask import g
-from app import log
-
-PE_DEBUG = False
-
-
-# On stocke les logs PE dans g.scodoc_pe_log
-# pour ne pas modifier les nombreux appels à pe_print.
-def pe_start_log() -> list[str]:
-    "Initialize log"
-    g.scodoc_pe_log = []
-    return g.scodoc_pe_log
-
-
-def pe_print(*a):
-    "Log (or print in PE_DEBUG mode) and store in g"
-    lines = getattr(g, "scodoc_pe_log")
-    if lines is None:
-        lines = pe_start_log()
-    msg = " ".join(a)
-    lines.append(msg)
-    if PE_DEBUG:
-        print(msg)
-    else:
-        log(msg)
-
-
-def pe_get_log() -> str:
-    "Renvoie une chaîne avec tous les messages loggués"
-    return "\n".join(getattr(g, "scodoc_pe_log", []))
-
-
-# Affichage dans le tableur pe en cas d'absence de notes
-SANS_NOTE = "-"
-NOM_STAT_GROUPE = "statistiques du groupe"
-NOM_STAT_PROMO = "statistiques de la promo"

app/pe/pe_avislatex.py

@@ -0,0 +1,517 @@
+# -*- mode: python -*-
+# -*- coding: utf-8 -*-
+
+##############################################################################
+#
+# Gestion scolarite IUT
+#
+# Copyright (c) 1999 - 2023 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

@@ -1,286 +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.models import FormSemestre
-from app.pe.pe_rcs import TYPES_RCS
-from app.scodoc import sco_formsemestre
-from app.scodoc.sco_logos import find_logo
-
-
-# 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
-"""
-
-NBRE_SEMESTRES_DIPLOMANT = 6
-AGGREGAT_DIPLOMANT = (
-    "6S"  # aggrégat correspondant à la totalité des notes pour le diplôme
-)
-TOUS_LES_SEMESTRES = TYPES_RCS[AGGREGAT_DIPLOMANT]["aggregat"]
-
-
-# ----------------------------------------------------------------------------------------
-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))
-
-
-# Nota: scu.suppress_accents fait la même chose mais renvoie un str et non un bytes
-def remove_accents(input_unicode_str: str) -> bytes:
-    """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: str) -> list[str]:
-    """List of regular filenames (paths) in a directory (recursive)
-    Excludes files and directories begining with .
-    """
-    paths = []
-    for root, dirs, files in os.walk(path, topdown=True):
-        dirs[:] = [d for d in dirs if d[0] != "."]
-        paths += [os.path.join(root, fn) for fn in files if fn[0] != "."]
-    return paths
-
-
-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: FormSemestre | dict, nbre_sem_formation: int = 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 ??
-        nb_sem_restants = (
-            nbre_sem_formation - sem_id
-        )  # nombre de semestres restant avant diplome
-        nb_annees_restantes = (
-            nb_sem_restants // 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 = nb_sem_restants % 2  # 0 si S4, 1 si S3, 0 si S2, 1 si S1
-        increment = decalage * (1 - delta)
-        return annee_fin + nb_annees_restantes + increment
-
-
-def get_cosemestres_diplomants(annee_diplome: int) -> dict[int, FormSemestre]:
-    """Ensemble des cosemestres donnant lieu à diplomation à l'``annee_diplome``.
-
-    **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
-
-    Args:
-        annee_diplome: L'année de diplomation
-
-    Returns:
-        Un dictionnaire {fid: FormSemestre(fid)} contenant les cosemestres
-    """
-    tous_les_sems = (
-        sco_formsemestre.do_formsemestre_list()
-    )  # tous les semestres memorisés dans scodoc
-
-    cosemestres_fids = {
-        sem["id"]
-        for sem in tous_les_sems
-        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

@@ -1,618 +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 17/01/2024
-
-@author: barasc
-"""
-import pandas as pd
-
-from app.models import FormSemestre, Identite, Formation
-from app.pe import pe_comp, pe_affichage
-from app.scodoc import codes_cursus
-from app.scodoc import sco_utils as scu
-from app.comp.res_sem import load_formsemestre_results
-
-
-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
-        """L'année du diplôme"""
-
-        self.identites: dict[int, Identite] = {}  # ex. ETUDINFO_DICT
-        "Les identités des étudiants traités pour le jury"
-
-        self.cursus: dict[int, dict] = {}
-        "Les cursus (semestres suivis, abandons) des étudiants"
-
-        self.trajectoires = {}
-        """Les trajectoires/chemins de semestres suivis par les étudiants
-        pour atteindre un aggrégat donné
-        (par ex: 3S=S1+S2+S3 à prendre en compte avec d'éventuels redoublements)"""
-
-        self.etudiants_diplomes = {}
-        """Les identités des étudiants à considérer au jury (ceux qui seront effectivement
-        diplômés)"""
-
-        self.diplomes_ids = {}
-        """Les etudids des étudiants diplômés"""
-
-        self.etudiants_ids = {}
-        """Les etudids des étudiants dont il faut calculer les moyennes/classements
-        (même si d'éventuels abandons).
-        Il s'agit des étudiants inscrits dans les co-semestres (ceux du jury mais aussi
-        d'autres ayant été réorientés ou ayant abandonnés)"""
-
-        self.cosemestres: dict[int, FormSemestre] = None
-        "Les cosemestres donnant lieu à même année de diplome"
-
-        self.abandons = {}
-        """Les étudiants qui ne seront pas diplômés à ce jury (redoublants/réorientés)"""
-        self.abandons_ids = {}
-        """Les etudids des étudiants redoublants/réorientés"""
-
-    def find_etudiants(self):
-        """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``.
-
-        Les données obtenues sont stockées dans les attributs de EtudiantsJuryPE.
-
-        *Remarque* : ex: JuryPE.get_etudiants_in_jury()
-        """
-        cosemestres = pe_comp.get_cosemestres_diplomants(self.annee_diplome)
-        self.cosemestres = cosemestres
-
-        pe_affichage.pe_print(
-            f"1) Recherche des coSemestres -> {len(cosemestres)} trouvés"
-        )
-
-        pe_affichage.pe_print("2) Liste des étudiants dans les différents co-semestres")
-        self.etudiants_ids = get_etudiants_dans_semestres(cosemestres)
-        pe_affichage.pe_print(
-            f" => {len(self.etudiants_ids)} étudiants trouvés dans les cosemestres"
-        )
-
-        # Analyse des parcours étudiants pour déterminer leur année effective de diplome
-        # avec prise en compte des redoublements, des abandons, ....
-        pe_affichage.pe_print("3) Analyse des parcours individuels des étudiants")
-
-        for etudid in self.etudiants_ids:
-            self.identites[etudid] = Identite.get_etud(etudid)
-
-            # Analyse son cursus
-            self.analyse_etat_etudiant(etudid, cosemestres)
-
-            # Analyse son parcours pour atteindre chaque semestre de la formation
-            self.structure_cursus_etudiant(etudid)
-
-        # 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())
-        self.etudiants_ids = set(self.identites.keys())
-
-        # Les abandons (pour debug)
-        self.abandons = self.get_etudiants_redoublants_ou_reorientes()
-        # Les identités des étudiants ayant redoublés ou ayant abandonnés
-
-        self.abandons_ids = set(self.abandons)
-        # Les identifiants des étudiants ayant redoublés ou ayant abandonnés
-
-        # Synthèse
-        pe_affichage.pe_print(
-            f"  => {len(self.etudiants_diplomes)} étudiants à diplômer en {self.annee_diplome}"
-        )
-        nbre_abandons = len(self.etudiants_ids) - len(self.etudiants_diplomes)
-        assert nbre_abandons == len(self.abandons_ids)
-
-        pe_affichage.pe_print(
-            f"  => {nbre_abandons} étudiants non considérés (redoublement, réorientation, abandon"
-        )
-        # pe_affichage.pe_print(
-        #    "  => quelques étudiants futurs diplômés : "
-        #    + ", ".join([str(etudid) for etudid in list(self.etudiants_diplomes)[:10]])
-        # )
-        # pe_affichage.pe_print(
-        #    "  => semestres dont il faut calculer les moyennes : "
-        #    + ", ".join([str(fid) for fid in list(self.formsemestres_jury_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, cursus_etud in self.cursus.items()
-            if cursus_etud["diplome"] == self.annee_diplome
-            and cursus_etud["abandon"] is False
-        ]
-        etudiants = {etudid: self.identites[etudid] for etudid in etudids}
-        return etudiants
-
-    def get_etudiants_redoublants_ou_reorientes(self) -> dict[int, Identite]:
-        """Identités des étudiants (sous forme d'un dictionnaire `{etudid: Identite(etudid)}`
-        dont les notes seront prises en compte (pour les classements) mais qui n'apparaitront
-        pas dans le jury car diplômé une autre année (redoublants) ou réorienté ou démissionnaire.
-
-        Returns:
-            Un dictionnaire `{etudid: Identite(etudid)}`
-        """
-        etudids = [
-            etudid
-            for etudid, cursus_etud in self.cursus.items()
-            if cursus_etud["diplome"] != self.annee_diplome
-            or cursus_etud["abandon"] is True
-        ]
-        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 = {
-            formsemestre.formsemestre_id: formsemestre
-            for formsemestre in formsemestres
-            if formsemestre.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": get_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 démissionnaire : charge son dernier semestre pour connaitre son état ?
-        dernier_semes_etudiant = formsemestres[0]
-        res = load_formsemestre_results(dernier_semes_etudiant)
-        etud_etat = res.get_etud_etat(etudid)
-        if etud_etat == scu.DEMISSION:
-            self.cursus[etudid]["abandon"] |= True
-        else:
-            # Est-il réorienté 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 i in range(1, pe_comp.NBRE_SEMESTRES_DIPLOMANT + 1):
-            # les semestres de n°i de l'étudiant:
-            semestres_i = {
-                fid: sem_sig
-                for fid, sem_sig in semestres_significatifs.items()
-                if sem_sig.semestre_id == i
-            }
-            self.cursus[etudid][f"S{i}"] = semestres_i
-
-    def get_formsemestres_terminaux_aggregat(
-        self, aggregat: str
-    ) -> dict[int, FormSemestre]:
-        """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 trajectoire_aggr in self.trajectoires.values():
-            trajectoire = trajectoire_aggr[aggregat]
-            if trajectoire:
-                # Le semestre terminal de l'étudiant de l'aggrégat
-                fid = trajectoire.formsemestre_final.formsemestre_id
-                formsemestres_terminaux[fid] = trajectoire.formsemestre_final
-        return formsemestres_terminaux
-
-    def nbre_etapes_max_diplomes(self, etudids: list[int]) -> int:
-        """Partant d'un ensemble d'étudiants,
-        nombre de semestres (étapes) maximum suivis par les étudiants du jury.
-
-        Args:
-            etudids: Liste d'étudid d'étudiants
-        """
-        nbres_semestres = []
-        for etudid in etudids:
-            nbres_semestres.append(self.cursus[etudid]["nb_semestres"])
-        if not nbres_semestres:
-            return 0
-        return max(nbres_semestres)
-
-    def df_administratif(self, etudids: list[int]) -> pd.DataFrame:
-        """Synthétise toutes les données administratives d'un groupe
-        d'étudiants fournis par les etudid dans un dataFrame
-
-        Args:
-            etudids: La liste des étudiants à prendre en compte
-        """
-
-        etudids = list(etudids)
-
-        # Récupération des données des étudiants
-        administratif = {}
-        nbre_semestres_max = self.nbre_etapes_max_diplomes(etudids)
-
-        for etudid in etudids:
-            etudiant = self.identites[etudid]
-            cursus = self.cursus[etudid]
-            formsemestres = cursus["formsemestres"]
-
-            if cursus["diplome"]:
-                diplome = cursus["diplome"]
-            else:
-                diplome = "indéterminé"
-
-            administratif[etudid] = {
-                "etudid": etudiant.id,
-                "INE": etudiant.code_ine or "",
-                "NIP": etudiant.code_nip or "",
-                "Nom": etudiant.nom,
-                "Prenom": etudiant.prenom,
-                "Civilite": etudiant.civilite_str,
-                "Age": pe_comp.calcul_age(etudiant.date_naissance),
-                "Date entree": cursus["entree"],
-                "Date diplome": diplome,
-                "Nb semestres": len(formsemestres),
-            }
-
-            # Ajout des noms de semestres parcourus
-            etapes = 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 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 sem in semestres.values():  # pour chacun des semestres de la liste
-        etudiants_du_sem = {ins.etudid for ins in sem.inscriptions}
-
-        pe_affichage.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 get_annee_diplome(etud: Identite) -> int | None:
-    """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, ou None si aucun semestre
-    """
-    formsemestres_apc = get_semestres_apc(etud)
-
-    if formsemestres_apc:
-        dates_possibles_diplome = []
-        # Années de diplômation prédites en fonction des semestres
-        # (d'une formation APC) d'un étudiant
-        for sem_base in formsemestres_apc:
-            annee = pe_comp.get_annee_diplome_semestre(sem_base)
-            if annee:
-                dates_possibles_diplome.append(annee)
-        if dates_possibles_diplome:
-            return max(dates_possibles_diplome)
-
-    return None
-
-
-def get_semestres_apc(identite: Identite) -> list:
-    """Liste des semestres d'un étudiant qui corresponde à une formation APC.
-
-    Args:
-        identite: L'identité d'un étudiant
-
-    Returns:
-        Liste de ``FormSemestre`` correspondant à une formation APC
-    """
-    semestres = identite.get_formsemestres()
-    semestres_apc = []
-    for sem in semestres:
-        if sem.formation.is_apc():
-            semestres_apc.append(sem)
-    return semestres_apc
-
-
-def arret_de_formation(etud: 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:
-        etud: 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
-    """
-    # Les semestres APC de l'étudiant
-    semestres = get_semestres_apc(etud)
-    semestres_apc = {sem.semestre_id: sem for sem in semestres}
-    if not semestres_apc:
-        return True
-
-    # Son dernier semestre APC en date
-    dernier_formsemestre = get_dernier_semestre_en_date(semestres_apc)
-    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
-    return None
-
-
-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
-
-
-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.formsemestre_id})")
-
-    return " ".join(description)

app/pe/pe_interclasstag.py

@@ -1,160 +0,0 @@
-##############################################################################
-#
-# 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 pandas as pd
-import numpy as np
-
-from app.pe.pe_tabletags import TableTag, MoyenneTag
-from app.pe.pe_etudiant import EtudiantsJuryPE
-from app.pe.pe_rcs import RCS, RCSsJuryPE
-from app.pe.pe_rcstag import RCSTag
-
-
-class RCSInterclasseTag(TableTag):
-    """
-    Interclasse l'ensemble des étudiants diplômés à une année
-    donnée (celle du jury), pour un RCS 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
-    formsemestre)
-    * calculant le classement sur les étudiants diplômes
-    """
-
-    def __init__(
-        self,
-        nom_rcs: str,
-        etudiants: EtudiantsJuryPE,
-        rcss_jury_pe: RCSsJuryPE,
-        rcss_tags: dict[tuple, RCSTag],
-    ):
-        TableTag.__init__(self)
-
-        self.nom_rcs = nom_rcs
-        """Le nom du RCS interclassé"""
-
-        self.nom = self.get_repr()
-
-        """Les étudiants diplômés et leurs rcss"""  # TODO
-        self.diplomes_ids = etudiants.etudiants_diplomes
-        self.etudiants_diplomes = {etudid for etudid in self.diplomes_ids}
-        # pour les exports sous forme de dataFrame
-        self.etudiants = {
-            etudid: etudiants.identites[etudid].etat_civil
-            for etudid in self.diplomes_ids
-        }
-
-        # Les trajectoires (et leur version tagguées), en ne gardant que
-        # celles associées à l'aggrégat
-        self.rcss: dict[int, RCS] = {}
-        """Ensemble des trajectoires associées à l'aggrégat"""
-        for trajectoire_id in rcss_jury_pe.rcss:
-            trajectoire = rcss_jury_pe.rcss[trajectoire_id]
-            if trajectoire_id[0] == nom_rcs:
-                self.rcss[trajectoire_id] = trajectoire
-
-        self.trajectoires_taggues: dict[int, RCS] = {}
-        """Ensemble des trajectoires tagguées associées à l'aggrégat"""
-        for trajectoire_id in self.rcss:
-            self.trajectoires_taggues[trajectoire_id] = rcss_tags[trajectoire_id]
-
-        # Les trajectoires suivies par les étudiants du jury, en ne gardant que
-        # celles associées aux diplomés
-        self.suivi: dict[int, RCS] = {}
-        """Association entre chaque étudiant et la trajectoire tagguée à prendre en
-        compte pour l'aggrégat"""
-        for etudid in self.diplomes_ids:
-            self.suivi[etudid] = rcss_jury_pe.suivi[etudid][nom_rcs]
-
-        self.tags_sorted = self.do_taglist()
-        """Liste des tags (triés par ordre alphabétique)"""
-
-        # Construit la matrice de notes
-        self.notes = self.compute_notes_matrice()
-        """Matrice des notes de l'aggrégat"""
-
-        # Synthétise les moyennes/classements par tag
-        self.moyennes_tags: dict[str, MoyenneTag] = {}
-        for tag in self.tags_sorted:
-            moy_gen_tag = self.notes[tag]
-            self.moyennes_tags[tag] = MoyenneTag(tag, moy_gen_tag)
-
-        # Est significatif ? (aka a-t-il des tags et des notes)
-        self.significatif = len(self.tags_sorted) > 0
-
-    def get_repr(self) -> str:
-        """Une représentation textuelle"""
-        return f"Aggrégat {self.nom_rcs}"
-
-    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 in self.trajectoires_taggues.values():
-            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)   unused ?
-        # 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 in self.trajectoires_taggues.values():
-            # Charge les moyennes par tag de la trajectoire tagguée
-            notes = trajectoire.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

@@ -1,734 +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
-"""
-
-# ----------------------------------------------------------
-# 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
-import time
-from zipfile import ZipFile
-
-import numpy as np
-import pandas as pd
-
-from app.pe.pe_affichage import NOM_STAT_PROMO, SANS_NOTE, NOM_STAT_GROUPE
-import app.pe.pe_affichage as pe_affichage
-from app.pe.pe_etudiant import *  # TODO A éviter -> pe_etudiant.
-from app.pe.pe_rcs import *  # TODO A éviter
-from app.pe.pe_rcstag import RCSTag
-from app.pe.pe_semtag import SemestreTag
-from app.pe.pe_interclasstag import RCSInterclasseTag
-
-
-class JuryPE(object):
-    """
-    Classe mémorisant toutes les informations nécessaires pour établir un jury de PE, sur la base
-    d'une année de diplôme. 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:
-        diplome : l'année d'obtention du diplome BUT et du jury de PE (généralement février XXXX)
-    """
-
-    def __init__(self, diplome):
-        pe_affichage.pe_start_log()
-        self.diplome = diplome
-        "L'année du diplome"
-
-        self.nom_export_zip = f"Jury_PE_{self.diplome}"
-        "Nom du zip où ranger les fichiers générés"
-
-        pe_affichage.pe_print(
-            f"Données de poursuite d'étude générées le {time.strftime('%d/%m/%Y à %H:%M')}\n"
-        )
-        # Chargement des étudiants à prendre en compte dans le jury
-        pe_affichage.pe_print(
-            f"""*** Recherche et chargement des étudiants diplômés en {
-                self.diplome}"""
-        )
-        self.etudiants = EtudiantsJuryPE(self.diplome)  # Les infos sur les étudiants
-        self.etudiants.find_etudiants()
-        self.diplomes_ids = self.etudiants.diplomes_ids
-
-        self.zipdata = io.BytesIO()
-        with ZipFile(self.zipdata, "w") as zipfile:
-            if not self.diplomes_ids:
-                pe_affichage.pe_print("*** Aucun étudiant diplômé")
-            else:
-                self._gen_xls_diplomes(zipfile)
-                self._gen_xls_semestre_taggues(zipfile)
-                self._gen_xls_rcss_tags(zipfile)
-                self._gen_xls_interclassements_rcss(zipfile)
-                self._gen_xls_synthese_jury_par_tag(zipfile)
-                self._gen_xls_synthese_par_etudiant(zipfile)
-            # et le log
-            self._add_log_to_zip(zipfile)
-
-        # Fin !!!! Tada :)
-
-    def _gen_xls_diplomes(self, zipfile: ZipFile):
-        "Intègre le bilan des semestres taggués au zip"
-        output = io.BytesIO()
-        with pd.ExcelWriter(  # pylint: disable=abstract-class-instantiated
-            output, engine="openpyxl"
-        ) as writer:
-            if self.diplomes_ids:
-                onglet = "diplômés"
-                df_diplome = self.etudiants.df_administratif(self.diplomes_ids)
-                df_diplome.to_excel(writer, onglet, index=True, header=True)
-            if self.etudiants.abandons_ids:
-                onglet = "redoublants-réorientés"
-                df_abandon = self.etudiants.df_administratif(
-                    self.etudiants.abandons_ids
-                )
-                df_abandon.to_excel(writer, onglet, index=True, header=True)
-        output.seek(0)
-
-        self.add_file_to_zip(
-            zipfile,
-            f"etudiants_{self.diplome}.xlsx",
-            output.read(),
-            path="details",
-        )
-
-    def _gen_xls_semestre_taggues(self, zipfile: ZipFile):
-        "Génère les semestres taggués (avec le calcul des moyennes) pour le jury PE"
-        pe_affichage.pe_print("*** Génère les semestres taggués")
-        self.sems_tags = compute_semestres_tag(self.etudiants)
-
-        # Intègre le bilan des semestres taggués au zip final
-        output = io.BytesIO()
-        with pd.ExcelWriter(  # pylint: disable=abstract-class-instantiated
-            output, engine="openpyxl"
-        ) as writer:
-            for formsemestretag in self.sems_tags.values():
-                onglet = formsemestretag.nom
-                df = formsemestretag.df_moyennes_et_classements()
-                # écriture dans l'onglet
-                df.to_excel(writer, onglet, index=True, header=True)
-        output.seek(0)
-
-        self.add_file_to_zip(
-            zipfile,
-            f"semestres_taggues_{self.diplome}.xlsx",
-            output.read(),
-            path="details",
-        )
-
-    def _gen_xls_rcss_tags(self, zipfile: ZipFile):
-        """Génère les RCS (combinaisons de semestres suivis
-        par un étudiant)
-        """
-        pe_affichage.pe_print(
-            "*** Génère les trajectoires (différentes combinaisons de semestres) des étudiants"
-        )
-        self.rcss = RCSsJuryPE(self.diplome)
-        self.rcss.cree_rcss(self.etudiants)
-
-        # Génère les moyennes par tags des trajectoires
-        pe_affichage.pe_print("*** Calcule les moyennes par tag des RCS possibles")
-        self.rcss_tags = compute_trajectoires_tag(
-            self.rcss, self.etudiants, self.sems_tags
-        )
-
-        # Intègre le bilan des trajectoires tagguées au zip final
-        output = io.BytesIO()
-        with pd.ExcelWriter(  # pylint: disable=abstract-class-instantiated
-            output, engine="openpyxl"
-        ) as writer:
-            for rcs_tag in self.rcss_tags.values():
-                onglet = rcs_tag.get_repr()
-                df = rcs_tag.df_moyennes_et_classements()
-                # écriture dans l'onglet
-                df.to_excel(writer, onglet, index=True, header=True)
-        output.seek(0)
-
-        self.add_file_to_zip(
-            zipfile,
-            f"RCS_taggues_{self.diplome}.xlsx",
-            output.read(),
-            path="details",
-        )
-
-    def _gen_xls_interclassements_rcss(self, zipfile: ZipFile):
-        """Intègre le bilan des RCS (interclassé par promo) au zip"""
-        # Génère les interclassements (par promo et) par (nom d') aggrégat
-        pe_affichage.pe_print("*** Génère les interclassements par aggrégat")
-        self.interclassements_taggues = compute_interclassements(
-            self.etudiants, self.rcss, self.rcss_tags
-        )
-
-        # Intègre le bilan des aggrégats (interclassé par promo) au zip final
-        output = io.BytesIO()
-        with pd.ExcelWriter(  # pylint: disable=abstract-class-instantiated
-            output, engine="openpyxl"
-        ) as writer:
-            for interclass_tag in self.interclassements_taggues.values():
-                if interclass_tag.significatif:  # Avec des notes
-                    onglet = interclass_tag.get_repr()
-                    df = interclass_tag.df_moyennes_et_classements()
-                    # écriture dans l'onglet
-                    df.to_excel(writer, onglet, index=True, header=True)
-        output.seek(0)
-
-        self.add_file_to_zip(
-            zipfile,
-            f"interclassements_taggues_{self.diplome}.xlsx",
-            output.read(),
-            path="details",
-        )
-
-    def _gen_xls_synthese_jury_par_tag(self, zipfile: ZipFile):
-        """Synthèse des éléments du jury PE tag par tag"""
-        # Synthèse des éléments du jury PE
-        self.synthese = self.synthetise_jury_par_tags()
-
-        # Export des données => mode 1 seule feuille -> supprimé
-        pe_affichage.pe_print("*** Export du jury de synthese par tags")
-        output = io.BytesIO()
-        with pd.ExcelWriter(  # pylint: disable=abstract-class-instantiated
-            output, engine="openpyxl"
-        ) as writer:
-            for onglet, df in self.synthese.items():
-                # écriture dans l'onglet:
-                df.to_excel(writer, onglet, index=True, header=True)
-        output.seek(0)
-
-        self.add_file_to_zip(
-            zipfile, f"synthese_jury_{self.diplome}_par_tag.xlsx", output.read()
-        )
-
-    def _gen_xls_synthese_par_etudiant(self, zipfile: ZipFile):
-        """Synthèse des éléments du jury PE, étudiant par étudiant"""
-        # Synthèse des éléments du jury PE
-        synthese = self.synthetise_jury_par_etudiants()
-
-        # Export des données => mode 1 seule feuille -> supprimé
-        pe_affichage.pe_print("*** Export du jury de synthese par étudiants")
-        output = io.BytesIO()
-        with pd.ExcelWriter(  # pylint: disable=abstract-class-instantiated
-            output, engine="openpyxl"
-        ) as writer:
-            for onglet, df in synthese.items():
-                # écriture dans l'onglet:
-                df.to_excel(writer, onglet, index=True, header=True)
-        output.seek(0)
-
-        self.add_file_to_zip(
-            zipfile, f"synthese_jury_{self.diplome}_par_etudiant.xlsx", output.read()
-        )
-
-    def _add_log_to_zip(self, zipfile):
-        """Add a text file with the log messages"""
-        log_data = pe_affichage.pe_get_log()
-        self.add_file_to_zip(zipfile, "pe_log.txt", log_data)
-
-    def add_file_to_zip(self, zipfile: ZipFile, filename: str, data, path=""):
-        """Add a file to given zip
-        All files under NOM_EXPORT_ZIP/
-        path may specify a subdirectory
-
-        Args:
-             zipfile: ZipFile
-             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,
-        zipfile.writestr(path_in_zip, data)
-
-    def get_zipped_data(self) -> io.BytesIO | None:
-        """returns file-like data with a zip of all generated (CSV) files.
-        Warning: reset stream to the begining.
-        """
-        self.zipdata.seek(0)
-        return self.zipdata
-
-    def do_tags_list(self, interclassements: dict[str, RCSInterclasseTag]):
-        """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_jury_par_tags(self) -> dict[pd.DataFrame]:
-        """Synthétise tous les résultats du jury PE dans des dataframes,
-        dont les onglets sont les tags"""
-
-        pe_affichage.pe_print("*** Synthèse finale des moyennes par tag***")
-
-        synthese = {}
-        pe_affichage.pe_print("  -> Synthèse des données administratives")
-        synthese["administratif"] = self.etudiants.df_administratif(self.diplomes_ids)
-
-        tags = self.do_tags_list(self.interclassements_taggues)
-        for tag in tags:
-            pe_affichage.pe_print(f"  -> Synthèse du tag {tag}")
-            synthese[tag] = self.df_tag(tag)
-        return synthese
-
-    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)
-
-        # Les données des étudiants
-        donnees_etudiants = {}
-        for etudid in etudids:
-            etudiant = self.etudiants.identites[etudid]
-            donnees_etudiants[etudid] = {
-                ("Identité", "", "Civilite"): etudiant.civilite_str,
-                ("Identité", "", "Nom"): etudiant.nom,
-                ("Identité", "", "Prenom"): etudiant.prenom,
-            }
-        df_synthese = pd.DataFrame.from_dict(donnees_etudiants, orient="index")
-
-        # Ajout des aggrégats
-        for aggregat in TOUS_LES_RCS:
-            descr = TYPES_RCS[aggregat]["descr"]
-
-            # Les trajectoires (tagguées) suivies par les étudiants pour l'aggrégat et le tag
-            # considéré
-            trajectoires_tagguees = []
-            for etudid in etudids:
-                trajectoire = self.rcss.suivi[etudid][aggregat]
-                if trajectoire:
-                    tid = trajectoire.rcs_id
-                    trajectoire_tagguee = self.rcss_tags[tid]
-                    if (
-                        tag in trajectoire_tagguee.moyennes_tags
-                        and trajectoire_tagguee not in trajectoires_tagguees
-                    ):
-                        trajectoires_tagguees.append(trajectoire_tagguee)
-
-            # Combien de notes vont être injectées ?
-            nbre_notes_injectees = 0
-            for traj in trajectoires_tagguees:
-                moy_traj = traj.moyennes_tags[tag]
-                inscrits_traj = moy_traj.inscrits_ids
-                etudids_communs = set(etudids) & set(inscrits_traj)
-                nbre_notes_injectees += len(etudids_communs)
-
-            # Si l'aggrégat est significatif (aka il y a des notes)
-            if nbre_notes_injectees > 0:
-                # Ajout des données classements & statistiques
-                nom_stat_promo = f"{NOM_STAT_PROMO} {self.diplome}"
-                donnees = pd.DataFrame(
-                    index=etudids,
-                    columns=[
-                        [descr] * (1 + 4 * 2),
-                        [""] + [NOM_STAT_GROUPE] * 4 + [nom_stat_promo] * 4,
-                        ["note"] + ["class.", "min", "moy", "max"] * 2,
-                    ],
-                )
-
-                for traj in trajectoires_tagguees:
-                    # Les données des trajectoires_tagguees
-                    moy_traj = traj.moyennes_tags[tag]
-
-                    # Les étudiants communs entre tableur de synthèse et trajectoires
-                    inscrits_traj = moy_traj.inscrits_ids
-                    etudids_communs = list(set(etudids) & set(inscrits_traj))
-
-                    # Les notes
-                    champ = (descr, "", "note")
-                    notes_traj = moy_traj.get_notes()
-                    donnees.loc[etudids_communs, champ] = notes_traj.loc[
-                        etudids_communs
-                    ]
-
-                    # Les rangs
-                    champ = (descr, NOM_STAT_GROUPE, "class.")
-                    rangs = moy_traj.get_rangs_inscrits()
-                    donnees.loc[etudids_communs, champ] = rangs.loc[etudids_communs]
-
-                    # Les mins
-                    champ = (descr, NOM_STAT_GROUPE, "min")
-                    mins = moy_traj.get_min()
-                    donnees.loc[etudids_communs, champ] = mins.loc[etudids_communs]
-
-                    # Les max
-                    champ = (descr, NOM_STAT_GROUPE, "max")
-                    maxs = moy_traj.get_max()
-                    donnees.loc[etudids_communs, champ] = maxs.loc[etudids_communs]
-
-                    # Les moys
-                    champ = (descr, NOM_STAT_GROUPE, "moy")
-                    moys = moy_traj.get_moy()
-                    donnees.loc[etudids_communs, champ] = moys.loc[etudids_communs]
-
-                # Ajoute les données d'interclassement
-                interclass = self.interclassements_taggues[aggregat]
-                moy_interclass = interclass.moyennes_tags[tag]
-
-                # Les étudiants communs entre tableur de synthèse et l'interclassement
-                inscrits_interclass = moy_interclass.inscrits_ids
-                etudids_communs = list(set(etudids) & set(inscrits_interclass))
-
-                # Les classements d'interclassement
-                champ = (descr, nom_stat_promo, "class.")
-                rangs = moy_interclass.get_rangs_inscrits()
-                donnees.loc[etudids_communs, champ] = rangs.loc[etudids_communs]
-
-                # Les mins
-                champ = (descr, nom_stat_promo, "min")
-                mins = moy_interclass.get_min()
-                donnees.loc[etudids_communs, champ] = mins.loc[etudids_communs]
-
-                # Les max
-                champ = (descr, nom_stat_promo, "max")
-                maxs = moy_interclass.get_max()
-                donnees.loc[etudids_communs, champ] = maxs.loc[etudids_communs]
-
-                # Les moys
-                champ = (descr, nom_stat_promo, "moy")
-                moys = moy_interclass.get_moy()
-                donnees.loc[etudids_communs, champ] = moys.loc[etudids_communs]
-
-                df_synthese = df_synthese.join(donnees)
-            # Fin de l'aggrégat
-
-        # Tri par nom/prénom
-        df_synthese.sort_values(
-            by=[("Identité", "", "Nom"), ("Identité", "", "Prenom")], inplace=True
-        )
-        return df_synthese
-
-    def synthetise_jury_par_etudiants(self) -> dict[pd.DataFrame]:
-        """Synthétise tous les résultats du jury PE dans des dataframes,
-        dont les onglets sont les étudiants"""
-        pe_affichage.pe_print("*** Synthèse finale des moyennes par étudiants***")
-
-        synthese = {}
-        pe_affichage.pe_print("  -> Synthèse des données administratives")
-        synthese["administratif"] = self.etudiants.df_administratif(self.diplomes_ids)
-
-        etudids = list(self.diplomes_ids)
-
-        for etudid in etudids:
-            etudiant = self.etudiants.identites[etudid]
-            nom = etudiant.nom
-            prenom = etudiant.prenom[0]  # initial du prénom
-
-            onglet = f"{nom} {prenom}. ({etudid})"
-            if len(onglet) > 32:  # limite sur la taille des onglets
-                fin_onglet = f"{prenom}. ({etudid})"
-                onglet = f"{nom[:32-len(fin_onglet)-2]}." + fin_onglet
-
-            pe_affichage.pe_print(f"  -> Synthèse de l'étudiant {etudid}")
-            synthese[onglet] = self.df_synthese_etudiant(etudid)
-        return synthese
-
-    def df_synthese_etudiant(self, etudid: int) -> pd.DataFrame:
-        """Créé un DataFrame pour un étudiant donné par son etudid, retraçant
-        toutes ses moyennes aux différents tag et aggrégats"""
-        tags = self.do_tags_list(self.interclassements_taggues)
-
-        donnees = {}
-
-        for tag in tags:
-            # Une ligne pour le tag
-            donnees[tag] = {("", "", "tag"): tag}
-
-            for aggregat in TOUS_LES_RCS:
-                # Le dictionnaire par défaut des moyennes
-                donnees[tag] |= get_defaut_dict_synthese_aggregat(
-                    aggregat, self.diplome
-                )
-
-                # La trajectoire de l'étudiant sur l'aggrégat
-                trajectoire = self.rcss.suivi[etudid][aggregat]
-                if trajectoire:
-                    trajectoire_tagguee = self.rcss_tags[trajectoire.rcs_id]
-                    if tag in trajectoire_tagguee.moyennes_tags:
-                        # L'interclassement
-                        interclass = self.interclassements_taggues[aggregat]
-
-                        # Injection des données dans un dictionnaire
-                        donnees[tag] |= get_dict_synthese_aggregat(
-                            aggregat,
-                            trajectoire_tagguee,
-                            interclass,
-                            etudid,
-                            tag,
-                            self.diplome,
-                        )
-
-            # 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=[("", "", "tag")], inplace=True)
-        return df
-
-
-def get_formsemestres_etudiants(etudiants: EtudiantsJuryPE) -> dict:
-    """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.
-
-    Args:
-        etudiants: Les étudiants du jury PE
-
-    Returns:
-        Un dictionnaire de la forme `{fid: FormSemestre(fid)}`
-
-    """
-    semestres = {}
-    for etudid in etudiants.etudiants_ids:
-        for cle in etudiants.cursus[etudid]:
-            if cle.startswith("S"):
-                semestres = semestres | etudiants.cursus[etudid][cle]
-    return semestres
-
-
-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_affichage.pe_print("*** Création des semestres taggués")
-
-    formsemestres = get_formsemestres_etudiants(etudiants)
-
-    semestres_tags = {}
-    for frmsem_id, formsemestre in formsemestres.items():
-        # Crée le semestre_tag et exécute les calculs de moyennes
-        formsemestretag = SemestreTag(frmsem_id)
-        pe_affichage.pe_print(
-            f"  --> Semestre taggué {formsemestretag.nom} sur la base de {formsemestre}"
-        )
-        # Stocke le semestre taggué
-        semestres_tags[frmsem_id] = formsemestretag
-
-    return semestres_tags
-
-
-def compute_trajectoires_tag(
-    trajectoires: RCSsJuryPE,
-    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)} }``
-    """
-    trajectoires_tagguees = {}
-
-    for trajectoire_id, trajectoire in trajectoires.rcss.items():
-        nom = trajectoire.get_repr()
-        pe_affichage.pe_print(f"  --> Aggrégat {nom}")
-        # Trajectoire_tagguee associée
-        trajectoire_tagguee = RCSTag(trajectoire, semestres_taggues)
-        # Mémorise le résultat
-        trajectoires_tagguees[trajectoire_id] = trajectoire_tagguee
-
-    return trajectoires_tagguees
-
-
-def compute_interclassements(
-    etudiants: EtudiantsJuryPE,
-    trajectoires_jury_pe: RCSsJuryPE,
-    trajectoires_tagguees: dict[tuple, RCS],
-):
-    """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.
-    """
-    aggregats_interclasses_taggues = {}
-    for nom_aggregat in TOUS_LES_RCS:
-        pe_affichage.pe_print(f"   --> Interclassement {nom_aggregat}")
-        interclass = RCSInterclasseTag(
-            nom_aggregat, etudiants, trajectoires_jury_pe, trajectoires_tagguees
-        )
-        aggregats_interclasses_taggues[nom_aggregat] = interclass
-    return aggregats_interclasses_taggues
-
-
-def get_defaut_dict_synthese_aggregat(nom_rcs: str, diplome: int) -> dict:
-    """Renvoie le dictionnaire de synthèse (à intégrer dans
-    un tableur excel) pour décrire les résultats d'un aggrégat
-
-    Args:
-        nom_rcs : Le nom du RCS visé
-        diplôme : l'année du diplôme
-    """
-    # L'affichage de l'aggrégat dans le tableur excel
-    descr = get_descr_rcs(nom_rcs)
-
-    nom_stat_promo = f"{NOM_STAT_PROMO} {diplome}"
-    donnees = {
-        (descr, "", "note"): SANS_NOTE,
-        # Les stat du groupe
-        (descr, NOM_STAT_GROUPE, "class."): SANS_NOTE,
-        (descr, NOM_STAT_GROUPE, "min"): SANS_NOTE,
-        (descr, NOM_STAT_GROUPE, "moy"): SANS_NOTE,
-        (descr, NOM_STAT_GROUPE, "max"): SANS_NOTE,
-        # Les stats de l'interclassement dans la promo
-        (descr, nom_stat_promo, "class."): SANS_NOTE,
-        (
-            descr,
-            nom_stat_promo,
-            "min",
-        ): SANS_NOTE,
-        (
-            descr,
-            nom_stat_promo,
-            "moy",
-        ): SANS_NOTE,
-        (
-            descr,
-            nom_stat_promo,
-            "max",
-        ): SANS_NOTE,
-    }
-    return donnees
-
-
-def get_dict_synthese_aggregat(
-    aggregat: str,
-    trajectoire_tagguee: RCSTag,
-    interclassement_taggue: RCSInterclasseTag,
-    etudid: int,
-    tag: str,
-    diplome: int,
-):
-    """Renvoie le dictionnaire (à intégrer au tableur excel de synthese)
-    traduisant les résultats (moy/class) d'un étudiant à une trajectoire tagguée associée
-    à l'aggrégat donné et pour un tag donné"""
-    donnees = {}
-    # L'affichage de l'aggrégat dans le tableur excel
-    descr = get_descr_rcs(aggregat)
-
-    # La note de l'étudiant (chargement à venir)
-    note = np.nan
-
-    # Les données de la trajectoire tagguée pour le tag considéré
-    moy_tag = trajectoire_tagguee.moyennes_tags[tag]
-
-    # Les données de l'étudiant
-    note = moy_tag.get_note_for_df(etudid)
-
-    classement = moy_tag.get_class_for_df(etudid)
-    nmin = moy_tag.get_min_for_df()
-    nmax = moy_tag.get_max_for_df()
-    nmoy = moy_tag.get_moy_for_df()
-
-    # Statistiques sur le groupe
-    if not pd.isna(note) and note != np.nan:
-        # Les moyennes de cette trajectoire
-        donnees |= {
-            (descr, "", "note"): note,
-            (descr, NOM_STAT_GROUPE, "class."): classement,
-            (descr, NOM_STAT_GROUPE, "min"): nmin,
-            (descr, NOM_STAT_GROUPE, "moy"): nmoy,
-            (descr, NOM_STAT_GROUPE, "max"): nmax,
-        }
-
-    # L'interclassement
-    moy_tag = interclassement_taggue.moyennes_tags[tag]
-
-    classement = moy_tag.get_class_for_df(etudid)
-    nmin = moy_tag.get_min_for_df()
-    nmax = moy_tag.get_max_for_df()
-    nmoy = moy_tag.get_moy_for_df()
-
-    if not pd.isna(note) and note != np.nan:
-        nom_stat_promo = f"{NOM_STAT_PROMO} {diplome}"
-
-        donnees |= {
-            (descr, nom_stat_promo, "class."): classement,
-            (descr, nom_stat_promo, "min"): nmin,
-            (descr, nom_stat_promo, "moy"): nmoy,
-            (descr, nom_stat_promo, "max"): nmax,
-        }
-
-    return donnees

app/pe/pe_rcs.py

@@ -1,269 +0,0 @@
-##############################################################################
-#  Module "Avis de poursuite d'étude"
-#  conçu et développé par Cléo Baras (IUT de Grenoble)
-##############################################################################
-
-"""
-Created on 01-2024
-
-@author: barasc
-"""
-
-import app.pe.pe_comp as pe_comp
-
-from app.models import FormSemestre
-from app.pe.pe_etudiant import EtudiantsJuryPE, get_dernier_semestre_en_date
-
-
-TYPES_RCS = {
-    "S1": {
-        "aggregat": ["S1"],
-        "descr": "Semestre 1 (S1)",
-    },
-    "S2": {
-        "aggregat": ["S2"],
-        "descr": "Semestre 2 (S2)",
-    },
-    "1A": {
-        "aggregat": ["S1", "S2"],
-        "descr": "BUT1 (S1+S2)",
-    },
-    "S3": {
-        "aggregat": ["S3"],
-        "descr": "Semestre 3 (S3)",
-    },
-    "S4": {
-        "aggregat": ["S4"],
-        "descr": "Semestre 4 (S4)",
-    },
-    "2A": {
-        "aggregat": ["S3", "S4"],
-        "descr": "BUT2 (S3+S4)",
-    },
-    "3S": {
-        "aggregat": ["S1", "S2", "S3"],
-        "descr": "Moyenne du semestre 1 au semestre 3 (S1+S2+S3)",
-    },
-    "4S": {
-        "aggregat": ["S1", "S2", "S3", "S4"],
-        "descr": "Moyenne du semestre 1 au semestre 4 (S1+S2+S3+S4)",
-    },
-    "S5": {
-        "aggregat": ["S5"],
-        "descr": "Semestre 5 (S5)",
-    },
-    "S6": {
-        "aggregat": ["S6"],
-        "descr": "Semestre 6 (S6)",
-    },
-    "3A": {
-        "aggregat": ["S5", "S6"],
-        "descr": "3ème année (S5+S6)",
-    },
-    "5S": {
-        "aggregat": ["S1", "S2", "S3", "S4", "S5"],
-        "descr": "Moyenne du semestre 1 au semestre 5 (S1+S2+S3+S4+S5)",
-    },
-    "6S": {
-        "aggregat": ["S1", "S2", "S3", "S4", "S5", "S6"],
-        "descr": "Moyenne globale (S1+S2+S3+S4+S5+S6)",
-    },
-}
-"""Dictionnaire détaillant les différents regroupements cohérents
-de semestres (RCS), en leur attribuant un nom et en détaillant
-le nom des semestres qu'ils regroupent et l'affichage qui en sera fait
-dans les tableurs de synthèse.
-"""
-
-TOUS_LES_RCS_AVEC_PLUSIEURS_SEM = [cle for cle in TYPES_RCS if not cle.startswith("S")]
-TOUS_LES_RCS = list(TYPES_RCS.keys())
-TOUS_LES_SEMESTRES = [cle for cle in TYPES_RCS if cle.startswith("S")]
-
-
-class RCS:
-    """Modélise un ensemble de semestres d'étudiants
-    associé à un type de regroupement cohérent de semestres
-    donné (par ex: 'S2', '3S', '2A').
-
-    Si le RCS est un semestre de type Si, stocke le (ou les)
-    formsemestres de numéro i qu'ont suivi 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 le RCS 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, ...
-
-    Args:
-        nom_rcs: Un nom du RCS (par ex: '5S')
-        semestre_final: Le semestre final du RCS
-    """
-
-    def __init__(self, nom_rcs: str, semestre_final: FormSemestre):
-        self.nom = nom_rcs
-        """Nom du RCS"""
-
-        self.formsemestre_final = semestre_final
-        """FormSemestre terminal du RCS"""
-
-        self.rcs_id = (nom_rcs, semestre_final.formsemestre_id)
-        """Identifiant du RCS sous forme (nom_rcs, id du semestre_terminal)"""
-
-        self.semestres_aggreges = {}
-        """Semestres regroupés dans le RCS"""
-
-    def add_semestres_a_aggreger(self, semestres: dict[int:FormSemestre]):
-        """Ajout de semestres aux semestres à regrouper
-
-        Args:
-            semestres: Dictionnaire ``{fid: FormSemestre(fid)}`` à ajouter
-        """
-        self.semestres_aggreges = self.semestres_aggreges | semestres
-
-    def get_repr(self, verbose=True) -> str:
-        """Représentation textuelle d'un RCS
-        basé 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)
-        title = f"""{self.nom} ({
-            self.formsemestre_final.formsemestre_id}) {self.formsemestre_final.date_fin.year}"""
-        if verbose and noms:
-            title += " - " + "+".join(noms)
-        return title
-
-
-class RCSsJuryPE:
-    """Classe centralisant toutes les regroupements cohérents de
-    semestres (RCS) des étudiants à prendre en compte dans un jury PE
-
-    Args:
-        annee_diplome: L'année de diplomation
-    """
-
-    def __init__(self, annee_diplome: int):
-        self.annee_diplome = annee_diplome
-        """Année de diplômation"""
-
-        self.rcss: dict[tuple:RCS] = {}
-        """Ensemble des RCS recensés : {(nom_RCS, fid_terminal): RCS}"""
-
-        self.suivi: dict[int:str] = {}
-        """Dictionnaire associant, pour chaque étudiant et pour chaque type de RCS,
-            son RCS : {etudid: {nom_RCS: RCS}}"""
-
-    def cree_rcss(self, etudiants: EtudiantsJuryPE):
-        """Créé tous les RCS, au regard du cursus des étudiants
-        analysés + les mémorise dans les données de l'étudiant
-
-        Args:
-            etudiants: Les étudiants à prendre en compte dans le Jury PE
-        """
-
-        for nom_rcs in pe_comp.TOUS_LES_SEMESTRES + TOUS_LES_RCS_AVEC_PLUSIEURS_SEM:
-            # 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 = TYPES_RCS[nom_rcs]["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_comp.TOUS_LES_SEMESTRES
-                        + TOUS_LES_RCS_AVEC_PLUSIEURS_SEM
-                    }
-
-                # 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_rcs, formsemestre_final.formsemestre_id)
-                    if trajectoire_id not in self.rcss:
-                        trajectoire = RCS(nom_rcs, formsemestre_final)
-                        self.rcss[trajectoire_id] = trajectoire
-                    else:
-                        trajectoire = self.rcss[trajectoire_id]
-
-                    # La liste des semestres de l'étudiant à prendre en compte
-                    # pour cette trajectoire
-                    semestres_a_aggreger = get_rcs_etudiant(
-                        etudiants.cursus[etudid], formsemestre_final, nom_rcs
-                    )
-
-                    # 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_rcs] = trajectoire
-
-
-def get_rcs_etudiant(
-    semestres: dict[int:FormSemestre], formsemestre_final: FormSemestre, nom_rcs: str
-) -> dict[int, FormSemestre]:
-    """Ensemble des semestres parcourus par un étudiant, connaissant
-    les semestres de son cursus,
-    dans le cadre du RCS visé et ayant pour semestre terminal `formsemestre_final`.
-
-    Si le RCS est de type "Si", limite les semestres à ceux de numéro i.
-    Par ex: si formsemestre_terminal est un S3 et nom_agrregat "S3", ne prend en compte que les
-    semestres 3.
-
-    Si le RCS est de type "iA" ou "iS" (incluant plusieurs numéros de semestres), prend en
-    compte les dit numéros de semestres.
-
-    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:
-        cursus: Dictionnaire {fid: FormSemestre(fid)} donnant l'ensemble des semestres
-                dans lesquels l'étudiant a été inscrit
-        formsemestre_final: le semestre final visé
-        nom_rcs: Nom du RCS visé
-    """
-    numero_semestre_terminal = formsemestre_final.semestre_id
-    # semestres_significatifs = self.get_semestres_significatifs(etudid)
-    semestres_significatifs = {}
-    for i in range(1, pe_comp.NBRE_SEMESTRES_DIPLOMANT + 1):
-        semestres_significatifs = semestres_significatifs | semestres[f"S{i}"]
-
-    if nom_rcs.startswith("S"):  # les semestres
-        numero_semestres_possibles = [numero_semestre_terminal]
-    elif nom_rcs.endswith("A"):  # les années
-        numero_semestres_possibles = [
-            int(sem[-1]) for sem in TYPES_RCS[nom_rcs]["aggregat"]
-        ]
-        assert numero_semestre_terminal in numero_semestres_possibles
-    else:  # les xS = tous les semestres jusqu'à Sx (eg S1, S2, S3 pour un S3 terminal)
-        numero_semestres_possibles = list(range(1, numero_semestre_terminal + 1))
-
-    semestres_aggreges = {}
-    for fid, semestre in semestres_significatifs.items():
-        # Semestres parmi ceux de n° possibles & qui lui sont antérieurs
-        if (
-            semestre.semestre_id in numero_semestres_possibles
-            and semestre.date_fin <= formsemestre_final.date_fin
-        ):
-            semestres_aggreges[fid] = semestre
-    return semestres_aggreges
-
-
-def get_descr_rcs(nom_rcs: str) -> str:
-    """Renvoie la description pour les tableurs de synthèse
-    Excel d'un nom de RCS"""
-    return TYPES_RCS[nom_rcs]["descr"]

app/pe/pe_rcstag.py

@@ -1,217 +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.comp.res_sem import load_formsemestre_results
-from app.pe.pe_semtag import SemestreTag
-import pandas as pd
-import numpy as np
-from app.pe.pe_rcs import RCS
-
-from app.pe.pe_tabletags import TableTag, MoyenneTag
-
-
-class RCSTag(TableTag):
-    def __init__(
-        self, rcs: RCS, semestres_taggues: dict[int, SemestreTag]
-    ):
-        """Calcule les moyennes par tag d'une combinaison de semestres
-        (RCS), 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.
-
-
-        Args:
-            rcs: Un RCS (identifié par un nom et l'id de son semestre terminal)
-            semestres_taggues: Les données sur les semestres taggués
-        """
-        TableTag.__init__(self)
-
-
-        self.rcs_id = rcs.rcs_id
-        """Identifiant du RCS taggué (identique au RCS sur lequel il s'appuie)"""
-
-        self.rcs = rcs
-        """RCS associé au RCS taggué"""
-
-        self.nom = self.get_repr()
-        """Représentation textuelle du RCS taggué"""
-
-        self.formsemestre_terminal = rcs.formsemestre_final
-        """Le formsemestre terminal"""
-
-        # Les résultats du formsemestre terminal
-        nt = load_formsemestre_results(self.formsemestre_terminal)
-
-        self.semestres_aggreges = rcs.semestres_aggreges
-        """Les semestres aggrégés"""
-
-        self.semestres_tags_aggreges = {}
-        """Les semestres tags associés aux semestres aggrégés"""
-        for frmsem_id in self.semestres_aggreges:
-            try:
-                self.semestres_tags_aggreges[frmsem_id] = semestres_taggues[frmsem_id]
-            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}
-
-        self.tags_sorted = self.do_taglist()
-        """Tags extraits de tous les semestres"""
-
-        self.notes_cube = self.compute_notes_cube()
-        """Cube de notes"""
-
-        etudids = list(self.etudiants.keys())
-        self.notes = compute_tag_moy(self.notes_cube, etudids, self.tags_sorted)
-        """Calcul les moyennes par tag sous forme d'un dataframe"""
-
-        self.moyennes_tags: dict[str, MoyenneTag] = {}
-        """Synthétise les moyennes/classements par tag (qu'ils soient personnalisé ou de compétences)"""
-        for tag in self.tags_sorted:
-            moy_gen_tag = self.notes[tag]
-            self.moyennes_tags[tag] = MoyenneTag(tag, moy_gen_tag)
-
-    def __eq__(self, other):
-        """Egalité de 2 RCS taggués sur la base de leur identifiant"""
-        return self.rcs_id == other.rcs_id
-
-    def get_repr(self, verbose=False) -> str:
-        """Renvoie une représentation textuelle (celle de la trajectoire sur laquelle elle
-        est basée)"""
-        return self.rcs.get_repr(verbose=verbose)
-
-    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
-            ]
-
-            # Supprime tout ce qui n'est pas numérique
-            for col in df.columns:
-                df[col] = pd.to_numeric(df[col], errors="coerce")
-
-            # 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
-    )
-
-    etud_moy_tag_df.fillna(np.nan)
-
-    return etud_moy_tag_df

app/pe/pe_semestretag.py

@@ -0,0 +1,511 @@
+# -*- mode: python -*-
+# -*- coding: utf-8 -*-
+
+##############################################################################
+#
+# Gestion scolarite IUT
+#
+# Copyright (c) 1999 - 2023 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 import db, log
+from app.comp import res_sem
+from app.comp.res_compat import NotesTableCompat
+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
+
+
+class SemestreTag(pe_tagtable.TableTag):
+    """Un SemestreTag représente un tableau de notes (basé sur notesTable)
+    modélisant les résultats des étudiants sous forme de moyennes par tag.
+
+    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
+        """Instantiation d'un objet SemestreTag à partir d'un tableau de note
+        et des informations sur le semestre pour le dater
+        """
+        pe_tagtable.TableTag.__init__(
+            self,
+            nom="S%d %s %s-%s"
+            % (
+                sem["semestre_id"],
+                "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
+        self.nt = notetable
+
+        # Les attributs hérités : la liste des étudiants
+        self.inscrlist = [
+            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
+        self.modimpls = [
+            modimpl
+            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
+            ]
+        )
+
+    # -----------------------------------------------------------------------------
+    def comp_data_semtag(self):
+        """Calcule tous les données numériques associées au semtag"""
+        # Attributs relatifs aux tag pour les modules pris en compte
+        self.tagdict = (
+            self.do_tagdict()
+        )  # 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"
+        for tag in self.tagdict:
+            self.add_moyennesTag(tag, self.comp_MoyennesTag(tag, force=True))
+        self.add_moyennesTag("dut", self.get_moyennes_DUT())
+        self.taglist = sorted(
+            list(self.tagdict.keys()) + ["dut"]
+        )  # actualise la liste des tags
+
+    # -----------------------------------------------------------------------------
+    def get_etudids(self):
+        """Renvoie la liste des etud_id des étudiants inscrits au semestre"""
+        return [etud["etudid"] for etud in self.inscrlist]
+
+    # -----------------------------------------------------------------------------
+    def do_tagdict(self):
+        """Parcourt les modimpl du semestre (instance des modules d'un programme) et synthétise leurs données sous la
+        forme d'un dictionnaire reliant les tags saisis dans le programme aux
+        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
+        correspond à la majorité des calculs de moyennes pour les étudiants
+        (seuls ceux qui ont capitalisé des ue auront un régime de calcul différent).
+        """
+        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
+
+    # -----------------------------------------------------------------------------
+    def get_moyennes_DUT(self):
+        """Lit les moyennes DUT du semestre pour tous les étudiants
+        et les renvoie au même format que comp_MoyennesTag"""
+        return [
+            (self.nt.etud_moy_gen[etudid], 1.0, etudid) for etudid in self.get_etudids()
+        ]
+
+    # -----------------------------------------------------------------------------
+    def get_noteEtCoeff_modimpl(self, modimpl_id, etudid, profondeur=2):
+        """Renvoie un couple donnant la note et le coeff normalisé d'un étudiant à un module d'id modimpl_id.
+        La note et le coeff sont extraits :
+        1) soit des données du semestre en normalisant le coefficient par rapport à la somme des coefficients des modules du semestre,
+        2) soit des données des UE précédemment capitalisées, en recherchant un module de même CODE que le modimpl_id proposé,
+        le coefficient normalisé l'étant alors par rapport au total des coefficients du semestre auquel appartient l'ue capitalisée
+        """
+        (note, coeff_norm) = (None, None)
+
+        modimpl = get_moduleimpl(modimpl_id)  # Le module considéré
+        if modimpl == None or profondeur < 0:
+            return (None, None)
+
+        # Y-a-t-il eu capitalisation d'UE ?
+        ue_capitalisees = self.get_ue_capitalisees(
+            etudid
+        )  # les ue capitalisées des étudiants
+        ue_capitalisees_id = {
+            ue_cap["ue_id"] for ue_cap in ue_capitalisees
+        }  # les id des ue capitalisées
+
+        # Si le module ne fait pas partie des UE capitalisées
+        if modimpl.module.ue.id not in ue_capitalisees_id:
+            note = self.nt.get_etud_mod_moy(modimpl_id, etudid)  # lecture de la note
+            coeff = modimpl.module.coefficient or 0.0  # le coeff (! non compatible BUT)
+            coeff_norm = (
+                coeff / self.somme_coeffs if self.somme_coeffs != 0 else 0
+            )  # le coeff normalisé
+
+        # Si le module fait partie d'une UE capitalisée
+        elif len(ue_capitalisees) > 0:
+            moy_ue_actuelle = get_moy_ue_from_nt(
+                self.nt, etudid, modimpl_id
+            )  # la moyenne actuelle
+            # A quel semestre correspond l'ue capitalisée et quelles sont ses notes ?
+            fids_prec = [
+                ue_cap["formsemestre_id"]
+                for ue_cap in ue_capitalisees
+                if ue_cap["ue_code"] == modimpl.module.ue.ue_code
+            ]  # and ue['semestre_id'] == semestre_id]
+            if len(fids_prec) > 0:
+                # => le formsemestre_id du semestre dont vient la capitalisation
+                fid_prec = fids_prec[0]
+                # Lecture des notes de ce semestre
+                # le tableau de note du semestre considéré:
+                formsemestre_prec = FormSemestre.get_formsemestre(fid_prec)
+                nt_prec: NotesTableCompat = res_sem.load_formsemestre_results(
+                    formsemestre_prec
+                )
+
+                # Y-a-t-il un module équivalent c'est à dire correspondant au même code (le module_id n'étant pas significatif en cas de changement de PPN)
+
+                modimpl_prec = [
+                    modi
+                    for modi in nt_prec.formsemestre.modimpls_sorted
+                    if modi.module.code == modimpl.module.code
+                ]
+                if len(modimpl_prec) > 0:  # si une correspondance est trouvée
+                    modprec_id = modimpl_prec[0].id
+                    moy_ue_capitalisee = get_moy_ue_from_nt(nt_prec, etudid, modprec_id)
+                    if (
+                        moy_ue_capitalisee is None
+                    ) or moy_ue_actuelle >= moy_ue_capitalisee:  # on prend la meilleure ue
+                        note = self.nt.get_etud_mod_moy(
+                            modimpl_id, etudid
+                        )  # lecture de la note
+                        coeff = modimpl.module.coefficient  # le coeff
+                        # nota: self.somme_coeffs peut être None
+                        coeff_norm = (
+                            coeff / self.somme_coeffs if self.somme_coeffs else 0
+                        )  # le coeff normalisé
+                    else:
+                        semtag_prec = SemestreTag(nt_prec, nt_prec.sem)
+                        (note, coeff_norm) = semtag_prec.get_noteEtCoeff_modimpl(
+                            modprec_id, etudid, profondeur=profondeur - 1
+                        )  # lecture de la note via le semtag associé au modimpl capitalisé
+
+                # Sinon - pas de notes à prendre en compte
+        return (note, coeff_norm)
+
+    # -----------------------------------------------------------------------------
+    def get_ue_capitalisees(self, etudid) -> list[dict]:
+        """Renvoie la liste des capitalisation effectivement capitalisées par un étudiant"""
+        if etudid in self.nt.validations.ue_capitalisees.index:
+            return self.nt.validations.ue_capitalisees.loc[[etudid]].to_dict("records")
+        return []
+
+    # -----------------------------------------------------------------------------
+    def get_listesNotesEtCoeffsTagEtudiant(self, tag, etudid):
+        """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
+    # -----------------------------------------------------------------------------
+    def str_detail_resultat_d_un_tag(self, tag, etudid=None, delim=";"):
+        """Renvoie une chaine de caractère décrivant les résultats d'étudiants à un tag :
+        rappelle les notes obtenues dans les modules à prendre en compte, les moyennes et les rangs calculés.
+        Si etudid=None, tous les étudiants inscrits dans le semestre sont pris en compte. Sinon seuls les étudiants indiqués sont affichés.
+        """
+        # Entete
+        chaine = delim.join(["%15s" % "nom", "etudid"]) + delim
+        taglist = self.get_all_tags()
+        if tag in taglist:
+            for mod in self.tagdict[tag].values():
+                chaine += mod["module_code"] + delim
+                chaine += ("%1.1f" % mod["ponderation"]) + delim
+                chaine += "coeff" + delim
+            chaine += delim.join(
+                ["moyenne", "rang", "nbinscrit", "somme_coeff", "somme_coeff"]
+            )  # ligne 1
+        chaine += "\n"
+
+        # Différents cas de boucles sur les étudiants (de 1 à plusieurs)
+        if etudid == None:
+            lesEtuds = self.get_etudids()
+        elif isinstance(etudid, str) and etudid in self.get_etudids():
+            lesEtuds = [etudid]
+        elif isinstance(etudid, list):
+            lesEtuds = [eid for eid in self.get_etudids() if eid in etudid]
+        else:
+            lesEtuds = []
+
+        for etudid in lesEtuds:
+            descr = (
+                "%15s" % self.nt.get_nom_short(etudid)[:15]
+                + delim
+                + str(etudid)
+                + delim
+            )
+            if tag in taglist:
+                for modimpl_id in self.tagdict[tag]:
+                    (note, coeff) = self.get_noteEtCoeff_modimpl(modimpl_id, etudid)
+                    descr += (
+                        (
+                            "%2.2f" % note
+                            if note != None and isinstance(note, float)
+                            else str(note)
+                        )
+                        + delim
+                        + (
+                            "%1.5f" % coeff
+                            if coeff != None and isinstance(coeff, float)
+                            else str(coeff)
+                        )
+                        + delim
+                        + (
+                            "%1.5f" % (coeff * self.somme_coeffs)
+                            if coeff != None and isinstance(coeff, float)
+                            else "???"  # str(coeff * self._sum_coeff_semestre) # voir avec Cléo
+                        )
+                        + delim
+                    )
+                moy = self.get_moy_from_resultats(tag, etudid)
+                rang = self.get_rang_from_resultats(tag, etudid)
+                coeff = self.get_coeff_from_resultats(tag, etudid)
+                tot = (
+                    coeff * self.somme_coeffs
+                    if coeff != None
+                    and self.somme_coeffs != None
+                    and isinstance(coeff, float)
+                    else None
+                )
+                descr += (
+                    pe_tagtable.TableTag.str_moytag(
+                        moy, rang, len(self.get_etudids()), delim=delim
+                    )
+                    + delim
+                )
+                descr += (
+                    (
+                        "%1.5f" % coeff
+                        if coeff != None and isinstance(coeff, float)
+                        else str(coeff)
+                    )
+                    + delim
+                    + (
+                        "%.2f" % (tot)
+                        if tot != None
+                        else str(coeff) + "*" + str(self.somme_coeffs)
+                    )
+                )
+            chaine += descr
+            chaine += "\n"
+        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.
+        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()
+        for tag in taglist:
+            chaine += " > " + tag + ": "
+            for modid, mod in self.tagdict[tag].items():
+                chaine += (
+                    mod["module_code"]
+                    + " ("
+                    + str(mod["coeff"])
+                    + "*"
+                    + str(mod["ponderation"])
+                    + ") "
+                    + str(modid)
+                    + ", "
+                )
+            chaine += "\n"
+        return chaine
+
+
+# ************************************************************************
+# Fonctions diverses
+# ************************************************************************
+
+
+# *********************************************
+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))
+    ]
+
+
+# -----------------------------------------------------------------------------
+def get_moduleimpl(modimpl_id) -> dict:
+    """Renvoie l'objet modimpl dont l'id est modimpl_id"""
+    modimpl = db.session.get(ModuleImpl, modimpl_id)
+    if modimpl:
+        return modimpl
+    if SemestreTag.DEBUG:
+        log(
+            "SemestreTag.get_moduleimpl( %s ) : le modimpl recherche n'existe pas"
+            % (modimpl_id)
+        )
+    return None
+
+
+# **********************************************
+def get_moy_ue_from_nt(nt, etudid, modimpl_id) -> float:
+    """Renvoie la moyenne de l'UE d'un etudid dans laquelle se trouve
+    le module de modimpl_id
+    """
+    # ré-écrit
+    modimpl = get_moduleimpl(modimpl_id)  # le module
+    ue_status = nt.get_etud_ue_status(etudid, modimpl.module.ue.id)
+    if ue_status is None:
+        return None
+    return ue_status["moy"]

app/pe/pe_semtag.py

@@ -1,310 +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
-"""
-import pandas as pd
-
-import app.pe.pe_etudiant
-from app import db, ScoValueError
-from app import comp
-from app.comp.res_sem import load_formsemestre_results
-from app.models import FormSemestre
-from app.models.moduleimpls import ModuleImpl
-import app.pe.pe_affichage as pe_affichage
-from app.pe.pe_tabletags import TableTag, MoyenneTag
-from app.scodoc import sco_tag_module
-from app.scodoc.codes_cursus import UE_SPORT
-
-
-class SemestreTag(TableTag):
-    """
-    Un SemestreTag représente les résultats des étudiants à un semestre, en donnant
-    accès aux moyennes par tag.
-    Il s'appuie principalement sur FormSemestre et sur ResultatsSemestreBUT.
-    """
-
-    def __init__(self, formsemestre_id: int):
-        """
-        Args:
-            formsemestre_id: Identifiant du ``FormSemestre`` sur lequel il se base
-        """
-        TableTag.__init__(self)
-
-        # Le semestre
-        self.formsemestre_id = formsemestre_id
-        self.formsemestre = FormSemestre.get_formsemestre(formsemestre_id)
-
-        # Le nom du semestre taggué
-        self.nom = self.get_repr()
-
-        # Les résultats du semestre
-        self.nt = load_formsemestre_results(self.formsemestre)
-
-        # Les étudiants
-        self.etuds = self.nt.etuds
-        self.etudiants = {etud.etudid: etud.etat_civil for etud in self.etuds}
-
-        # Les notes, les modules implémentés triés, les étudiants, les coeffs,
-        # récupérés notamment de py:mod:`res_but`
-        self.sem_cube = self.nt.sem_cube
-        self.modimpls_sorted = self.nt.formsemestre.modimpls_sorted
-        self.modimpl_coefs_df = self.nt.modimpl_coefs_df
-
-        # Les inscriptions au module et les dispenses d'UE
-        self.modimpl_inscr_df = self.nt.modimpl_inscr_df
-        self.ues = self.nt.ues
-        self.ues_inscr_parcours_df = self.nt.load_ues_inscr_parcours()
-        self.dispense_ues = self.nt.dispense_ues
-
-        # Les tags :
-        ## Saisis par l'utilisateur
-        tags_personnalises = get_synthese_tags_personnalises_semestre(
-            self.nt.formsemestre
-        )
-        noms_tags_perso = list(set(tags_personnalises.keys()))
-
-        ## Déduit des compétences
-        dict_ues_competences = get_noms_competences_from_ues(self.nt.formsemestre)
-        noms_tags_comp = list(set(dict_ues_competences.values()))
-        noms_tags_auto = ["but"] + noms_tags_comp
-        self.tags = noms_tags_perso + noms_tags_auto
-        """Tags du semestre taggué"""
-
-        ## Vérifie l'unicité des tags
-        if len(set(self.tags)) != len(self.tags):
-            intersection = list(set(noms_tags_perso) & set(noms_tags_auto))
-            liste_intersection = "\n".join(
-                [f"<li><code>{tag}</code></li>" for tag in intersection]
-            )
-            s = "s" if len(intersection) > 0 else ""
-            message = f"""Erreur dans le module PE : Un des tags saisis dans votre
-            programme de formation fait parti des tags réservés. En particulier,
-            votre semestre <em>{self.formsemestre.titre_annee()}</em>
-            contient le{s} tag{s} réservé{s} suivant  :
-            <ul>
-            {liste_intersection}
-            </ul>
-            Modifiez votre programme de formation pour le{s} supprimer.
-            Il{s} ser{'ont' if s else 'a'} automatiquement à vos documents de poursuites d'études.
-            """
-            raise ScoValueError(message)
-
-        # Calcul des moyennes & les classements de chaque étudiant à chaque tag
-        self.moyennes_tags = {}
-
-        for tag in tags_personnalises:
-            # pe_affichage.pe_print(f"  -> Traitement du tag {tag}")
-            moy_gen_tag = self.compute_moyenne_tag(tag, tags_personnalises)
-            self.moyennes_tags[tag] = MoyenneTag(tag, moy_gen_tag)
-
-        # Ajoute les moyennes générales de BUT pour le semestre considéré
-        moy_gen_but = self.nt.etud_moy_gen
-        self.moyennes_tags["but"] = MoyenneTag("but", moy_gen_but)
-
-        # Ajoute les moyennes par compétence
-        for ue_id, competence in dict_ues_competences.items():
-            if competence not in self.moyennes_tags:
-                moy_ue = self.nt.etud_moy_ue[ue_id]
-                self.moyennes_tags[competence] = MoyenneTag(competence, moy_ue)
-
-        self.tags_sorted = self.get_all_tags()
-        """Tags (personnalisés+compétences) par ordre alphabétique"""
-
-        # Synthétise l'ensemble des moyennes dans un dataframe
-
-        self.notes = self.df_notes()
-        """Dataframe synthétique des notes par tag"""
-
-        pe_affichage.pe_print(
-            f"   => Traitement des tags {', '.join(self.tags_sorted)}"
-        )
-
-    def get_repr(self):
-        """Nom affiché pour le semestre taggué"""
-        return app.pe.pe_etudiant.nom_semestre_etape(self.formsemestre, avec_fid=True)
-
-    def compute_moyenne_tag(self, tag: str, tags_infos: dict) -> pd.Series:
-        """Calcule la moyenne des étudiants pour le tag indiqué,
-        pour ce SemestreTag, en ayant connaissance des informations sur
-        les tags (dictionnaire donnant les coeff de repondération)
-
-        Sont pris en compte les modules implémentés associés au tag,
-        avec leur éventuel coefficient de **repondération**, en utilisant les notes
-        chargées pour ce SemestreTag.
-
-        Force ou non le calcul de la moyenne lorsque des notes sont manquantes.
-
-        Returns:
-            La série des moyennes
-        """
-
-        # Adaptation du mask de calcul des moyennes au tag visé
-        modimpls_mask = [
-            modimpl.module.ue.type != UE_SPORT
-            for modimpl in self.formsemestre.modimpls_sorted
-        ]
-
-        # 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 tags_infos[tag]:
-                modimpls_mask[i] = False
-
-        # Applique la pondération des coefficients
-        modimpl_coefs_ponderes_df = self.modimpl_coefs_df.copy()
-        for modimpl_id in tags_infos[tag]:
-            ponderation = tags_infos[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 = comp.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 = comp.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_moduleimpl(modimpl_id) -> dict:
-    """Renvoie l'objet modimpl dont l'id est modimpl_id"""
-    modimpl = db.session.get(ModuleImpl, modimpl_id)
-    if modimpl:
-        return modimpl
-    return None
-
-
-def get_moy_ue_from_nt(nt, etudid, modimpl_id) -> float:
-    """Renvoie la moyenne de l'UE d'un etudid dans laquelle se trouve
-    le module de modimpl_id
-    """
-    # ré-écrit
-    modimpl = get_moduleimpl(modimpl_id)  # le module
-    ue_status = nt.get_etud_ue_status(etudid, modimpl.module.ue.id)
-    if ue_status is None:
-        return None
-    return ue_status["moy"]
-
-
-def get_synthese_tags_personnalises_semestre(formsemestre: FormSemestre):
-    """Etant données les implémentations des modules du semestre (modimpls),
-    synthétise les tags renseignés dans le programme pédagogique &
-    associés aux modules du semestre,
-    en les associant aux modimpls qui les concernent (modimpl_id) et
-    aucoeff et pondération fournie avec le tag (par défaut 1 si non indiquée)).
-
-
-    Args:
-        formsemestre: Le formsemestre à la base de la recherche des tags
-
-    Return:
-        Un dictionnaire de 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
-
-
-def get_noms_competences_from_ues(formsemestre: FormSemestre) -> dict[int, str]:
-    """Partant d'un formsemestre, extrait le nom des compétences associés
-    à (ou aux) parcours des étudiants du formsemestre.
-
-    Ignore les UEs non associées à un niveau de compétence.
-
-    Args:
-        formsemestre: Un FormSemestre
-
-    Returns:
-        Dictionnaire {ue_id: nom_competence} lisant tous les noms des compétences
-        en les raccrochant à leur ue
-    """
-    # Les résultats du semestre
-    nt = load_formsemestre_results(formsemestre)
-
-    noms_competences = {}
-    for ue in nt.ues:
-        if ue.niveau_competence and ue.type != UE_SPORT:
-            # ?? inutilisé  ordre = ue.niveau_competence.ordre
-            nom = ue.niveau_competence.competence.titre
-            noms_competences[ue.ue_id] = f"comp. {nom}"
-    return noms_competences

app/pe/pe_settag.py

@@ -0,0 +1,324 @@
+# -*- mode: python -*-
+# -*- coding: utf-8 -*-
+
+##############################################################################
+#
+# Gestion scolarite IUT
+#
+# Copyright (c) 1999 - 2023 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

@@ -1,263 +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 datetime
-import numpy as np
-
-from app import ScoValueError
-from app.comp.moy_sem import comp_ranks_series
-from app.pe import pe_affichage
-from app.pe.pe_affichage import SANS_NOTE
-from app.scodoc import sco_utils as scu
-import pandas as pd
-
-
-TAGS_RESERVES = ["but"]
-
-
-class MoyenneTag:
-    def __init__(self, tag: str, notes: pd.Series):
-        """Classe centralisant la synthèse des moyennes/classements d'une série
-        d'étudiants à un tag donné, en stockant un dictionnaire :
-
-        ``
-        {
-            "notes": la Serie pandas des notes (float),
-            "classements": la Serie pandas des classements (float),
-            "min": la note minimum,
-            "max": la note maximum,
-            "moy": la moyenne,
-            "nb_inscrits": le nombre d'étudiants ayant une note,
-        }
-        ``
-
-        Args:
-            tag: Un tag
-            note: Une série de notes (moyenne) sous forme d'un pd.Series()
-        """
-        self.tag = tag
-        """Le tag associé à la moyenne"""
-        self.etudids = list(notes.index)  # calcul à venir
-        """Les id des étudiants"""
-        self.inscrits_ids = notes[notes.notnull()].index.to_list()
-        """Les id des étudiants dont la moyenne est non nulle"""
-        self.df: pd.DataFrame = self.comp_moy_et_stat(notes)
-        """Le dataframe retraçant les moyennes/classements/statistiques"""
-        self.synthese = self.to_dict()
-        """La synthèse (dictionnaire) des notes/classements/statistiques"""
-
-    def __eq__(self, other):
-        """Egalité de deux MoyenneTag lorsque leur tag sont identiques"""
-        return self.tag == other.tag
-
-    def comp_moy_et_stat(self, notes: pd.Series) -> dict:
-        """Calcule et structure les données nécessaires au PE pour une série
-        de notes (souvent une moyenne par tag) dans un dictionnaire spécifique.
-
-        Partant des notes, sont calculés les classements (en ne tenant compte
-        que des notes non nulles).
-
-        Args:
-            notes: Une série de notes (avec des éventuels NaN)
-
-        Returns:
-            Un dictionnaire stockant les notes, les classements, le min,
-            le max, la moyenne, le nb de notes (donc d'inscrits)
-        """
-        df = pd.DataFrame(
-            np.nan,
-            index=self.etudids,
-            columns=[
-                "note",
-                "classement",
-                "rang",
-                "min",
-                "max",
-                "moy",
-                "nb_etuds",
-                "nb_inscrits",
-            ],
-        )
-
-        # Supprime d'éventuelles chaines de caractères dans les notes
-        notes = pd.to_numeric(notes, errors="coerce")
-        df["note"] = notes
-
-        # Les nb d'étudiants & nb d'inscrits
-        df["nb_etuds"] = len(self.etudids)
-        df.loc[self.inscrits_ids, "nb_inscrits"] = len(self.inscrits_ids)
-
-        # Le classement des inscrits
-        notes_non_nulles = notes[self.inscrits_ids]
-        (class_str, class_int) = comp_ranks_series(notes_non_nulles)
-        df.loc[self.inscrits_ids, "classement"] = class_int
-
-        # Le rang (classement/nb_inscrit)
-        df["rang"] = df["rang"].astype(str)
-        df.loc[self.inscrits_ids, "rang"] = (
-            df.loc[self.inscrits_ids, "classement"].astype(int).astype(str)
-            + "/"
-            + df.loc[self.inscrits_ids, "nb_inscrits"].astype(int).astype(str)
-        )
-
-        # Les stat (des inscrits)
-        df.loc[self.inscrits_ids, "min"] = notes.min()
-        df.loc[self.inscrits_ids, "max"] = notes.max()
-        df.loc[self.inscrits_ids, "moy"] = notes.mean()
-
-        return df
-
-    def to_dict(self) -> dict:
-        """Renvoie un dictionnaire de synthèse des moyennes/classements/statistiques"""
-        synthese = {
-            "notes": self.df["note"],
-            "classements": self.df["classement"],
-            "min": self.df["min"].mean(),
-            "max": self.df["max"].mean(),
-            "moy": self.df["moy"].mean(),
-            "nb_inscrits": self.df["nb_inscrits"].mean(),
-        }
-        return synthese
-
-    def get_notes(self):
-        """Série des notes, arrondies à 2 chiffres après la virgule"""
-        return self.df["note"].round(2)
-
-    def get_rangs_inscrits(self) -> pd.Series:
-        """Série des rangs classement/nbre_inscrit"""
-        return self.df["rang"]
-
-    def get_min(self) -> pd.Series:
-        """Série des min"""
-        return self.df["min"].round(2)
-
-    def get_max(self) -> pd.Series:
-        """Série des max"""
-        return self.df["max"].round(2)
-
-    def get_moy(self) -> pd.Series:
-        """Série des moy"""
-        return self.df["moy"].round(2)
-
-
-    def get_note_for_df(self, etudid: int):
-        """Note d'un étudiant donné par son etudid"""
-        return round(self.df["note"].loc[etudid], 2)
-
-    def get_min_for_df(self) -> float:
-        """Min renseigné pour affichage dans un df"""
-        return round(self.synthese["min"], 2)
-
-    def get_max_for_df(self) -> float:
-        """Max renseigné pour affichage dans un df"""
-        return round(self.synthese["max"], 2)
-
-    def get_moy_for_df(self) -> float:
-        """Moyenne renseignée pour affichage dans un df"""
-        return round(self.synthese["moy"], 2)
-
-    def get_class_for_df(self, etudid: int) -> str:
-        """Classement ramené au nombre d'inscrits,
-        pour un étudiant donné par son etudid"""
-        classement = self.df["rang"].loc[etudid]
-        if not pd.isna(classement):
-            return classement
-        else:
-            return pe_affichage.SANS_NOTE
-
-    def is_significatif(self) -> bool:
-        """Indique si la moyenne est significative (c'est-à-dire à des notes)"""
-        return self.synthese["nb_inscrits"] > 0
-
-
-class TableTag(object):
-    def __init__(self):
-        """Classe centralisant différentes méthodes communes aux
-        SemestreTag, TrajectoireTag, AggregatInterclassTag
-        """
-        pass
-
-    # -----------------------------------------------------------------------------------------------------------
-    def get_all_tags(self):
-        """Liste des tags de la table, triée par ordre alphabétique,
-        extraite des clés du dictionnaire ``moyennes_tags`` connues (tags en doublon
-        possible).
-
-        Returns:
-            Liste de tags triés par ordre alphabétique
-        """
-        return sorted(list(self.moyennes_tags.keys()))
-
-    def df_moyennes_et_classements(self) -> pd.DataFrame:
-        """Renvoie un dataframe listant toutes les moyennes,
-        et les classements des étudiants pour tous les tags.
-
-        Est utilisé pour afficher le détail d'un tableau taggué
-        (semestres, trajectoires ou aggrégat)
-
-        Returns:
-            Le dataframe des notes et des classements
-        """
-
-        etudiants = self.etudiants
-        df = pd.DataFrame.from_dict(etudiants, orient="index", columns=["nom"])
-
-        tags_tries = self.get_all_tags()
-        for tag in tags_tries:
-            moy_tag = self.moyennes_tags[tag]
-            df = df.join(moy_tag.synthese["notes"].rename(f"Moy {tag}"))
-            df = df.join(moy_tag.synthese["classements"].rename(f"Class {tag}"))
-
-        return df
-
-    def df_notes(self) -> pd.DataFrame | None:
-        """Renvoie un dataframe (etudid x tag) listant toutes les moyennes par tags
-
-        Returns:
-            Un dataframe etudids x tag (avec tag par ordre alphabétique)
-        """
-        tags_tries = self.get_all_tags()
-        if tags_tries:
-            dict_series = {}
-            for tag in tags_tries:
-                # Les moyennes associés au tag
-                moy_tag = self.moyennes_tags[tag]
-                dict_series[tag] = moy_tag.synthese["notes"]
-            df = pd.DataFrame(dict_series)
-            return df

app/pe/pe_tagtable.py

@@ -0,0 +1,348 @@
+# -*- mode: python -*-
+# -*- coding: utf-8 -*-
+
+##############################################################################
+#
+# Gestion scolarite IUT
+#
+# Copyright (c) 1999 - 2023 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 datetime
+import numpy as np
+
+from app.scodoc import sco_utils as scu
+
+
+class TableTag(object):
+    """
+    Classe mémorisant les moyennes des étudiants à différents tag et permettant de calculer les rangs et les statistiques :
+    - 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
+    - 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 :
+        { tag : {etudid: rang, ...} }
+    - 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 :
+        { tag : (moy, min, max), ...}
+
+    """
+
+    def __init__(self, nom=""):
+        self.nom = nom
+        self.inscrlist = []
+        self.identdict = {}
+        self.taglist = []
+
+        self.resultats = {}
+        self.rangs = {}
+        self.statistiques = {}
+
+    # *****************************************************************************************************************
+    # Accesseurs
+    # *****************************************************************************************************************
+
+    # -----------------------------------------------------------------------------------------------------------
+    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]
+            if tag in self.resultats and etudid in self.resultats[tag]
+            else None
+        )
+
+    # -----------------------------------------------------------------------------------------------------------
+    def get_rang_from_resultats(self, tag, etudid):
+        """Renvoie le rang à un tag d'un étudiant au regard du format de self.resultats"""
+        return (
+            self.rangs[tag][etudid]
+            if tag in self.resultats and etudid in self.resultats[tag]
+            else None
+        )
+
+    # -----------------------------------------------------------------------------------------------------------
+    def get_coeff_from_resultats(self, tag, etudid):
+        """Renvoie la somme des coeffs de pondération normalisée utilisés dans le calcul de la moyenne à un tag d'un étudiant
+        au regard du format de self.resultats.
+        """
+        return (
+            self.resultats[tag][etudid][1]
+            if tag in self.resultats and etudid in self.resultats[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):
+        """Renvoie le nombre d'inscrits"""
+        return len(self.inscrlist)
+
+    # -----------------------------------------------------------------------------------------------------------
+    def get_moy_from_stats(self, tag):
+        """Renvoie la moyenne des notes calculées pour d'un tag donné"""
+        return self.statistiques[tag][0] if tag in self.statistiques else None
+
+    def get_min_from_stats(self, tag):
+        """Renvoie la plus basse des notes calculées pour d'un tag donné"""
+        return self.statistiques[tag][1] if tag in self.statistiques else None
+
+    def get_max_from_stats(self, tag):
+        """Renvoie la plus haute des notes calculées pour d'un tag donné"""
+        return self.statistiques[tag][2] if tag in self.statistiques else None
+
+    # -----------------------------------------------------------------------------------------------------------
+    # La structure des données mémorisées pour chaque tag dans le dictionnaire de synthèse
+    # d'un jury PE
+    FORMAT_DONNEES_ETUDIANTS = (
+        "note",
+        "coeff",
+        "rang",
+        "nbinscrits",
+        "moy",
+        "max",
+        "min",
+    )
+
+    def get_resultatsEtud(self, tag, etudid):
+        """Renvoie un tuple (note, coeff, rang, nb_inscrit, moy, min, max) synthétisant les résultats d'un étudiant
+        à un tag donné. None sinon"""
+        return (
+            self.get_moy_from_resultats(tag, etudid),
+            self.get_coeff_from_resultats(tag, etudid),
+            self.get_rang_from_resultats(tag, etudid),
+            self.get_nbinscrits(),
+            self.get_moy_from_stats(tag),
+            self.get_min_from_stats(tag),
+            self.get_max_from_stats(tag),
+        )
+
+    #        return self.tag_stats[tag]
+    #    else :
+    #        return self.pe_stats
+
+    # *****************************************************************************************************************
+    # Ajout des notes
+    # *****************************************************************************************************************
+
+    # -----------------------------------------------------------------------------------------------------------
+    def add_moyennesTag(self, tag, listMoyEtCoeff) -> bool:
+        """
+        Mémorise les moyennes, les coeffs de pondération et les etudid dans resultats
+        avec calcul du rang
+        :param tag: Un tag
+        :param listMoyEtCoeff: Une liste donnant [ (moy, coeff, etudid) ]
+        """
+        # ajout des moyennes au dictionnaire résultat
+        if listMoyEtCoeff:
+            self.resultats[tag] = {
+                etudid: (moyenne, somme_coeffs)
+                for (moyenne, somme_coeffs, etudid) in listMoyEtCoeff
+            }
+
+            # Calcule les rangs
+            lesMoyennesTriees = sorted(
+                listMoyEtCoeff,
+                reverse=True,
+                key=lambda col: col[0]
+                if isinstance(col[0], float)
+                else 0,  # remplace les None et autres chaines par des zéros
+            )  # triées
+            self.rangs[tag] = scu.comp_ranks(lesMoyennesTriees)  # les rangs
+
+            # calcul des stats
+            self.comp_stats_d_un_tag(tag)
+            return True
+        return False
+
+    # *****************************************************************************************************************
+    # Méthodes dévolues aux calculs de statistiques (min, max, moy) sur chaque moyenne taguée
+    # *****************************************************************************************************************
+
+    def comp_stats_d_un_tag(self, tag):
+        """
+        Calcule la moyenne generale, le min, le max pour un tag donné,
+        en ne prenant en compte que les moyennes significatives. Mémorise le resultat dans
+        self.statistiques
+        """
+        stats = ("-NA-", "-", "-")
+        if tag not in self.resultats:
+            return stats
+
+        notes = [
+            self.get_moy_from_resultats(tag, etudid) for etudid in self.resultats[tag]
+        ]  # les notes du tag
+        notes_valides = [
+            note for note in notes if isinstance(note, float) and note != None
+        ]
+        nb_notes_valides = len(notes_valides)
+        if nb_notes_valides > 0:
+            (moy, _) = moyenne_ponderee_terme_a_terme(notes_valides, force=True)
+            self.statistiques[tag] = (moy, max(notes_valides), min(notes_valides))
+
+    # ************************************************************************
+    # Méthodes dévolues aux affichages -> a revoir
+    # ************************************************************************
+    def str_resTag_d_un_etudiant(self, tag, etudid, delim=";"):
+        """Renvoie une chaine de caractères (valable pour un csv)
+        décrivant la moyenne et le rang d'un étudiant, pour un tag donné ;
+        """
+        if tag not in self.get_all_tags() or etudid not in self.resultats[tag]:
+            return ""
+
+        moystr = TableTag.str_moytag(
+            self.get_moy_from_resultats(tag, etudid),
+            self.get_rang_from_resultats(tag, etudid),
+            self.get_nbinscrits(),
+            delim=delim,
+        )
+        return moystr
+
+    def str_res_d_un_etudiant(self, etudid, delim=";"):
+        """Renvoie sur une ligne les résultats d'un étudiant à tous les tags (par ordre alphabétique)."""
+        return delim.join(
+            [self.str_resTag_d_un_etudiant(tag, etudid) for tag in self.get_all_tags()]
+        )
+
+    # -----------------------------------------------------------------------
+    def str_moytag(cls, moyenne, rang, nbinscrit, delim=";"):
+        """Renvoie une chaine de caractères représentant une moyenne (float ou string) et un rang
+        pour différents formats d'affichage : HTML, debug ligne de commande, csv"""
+        moystr = (
+            "%2.2f%s%s%s%d" % (moyenne, delim, rang, delim, nbinscrit)
+            if isinstance(moyenne, float)
+            else str(moyenne) + delim + str(rang) + delim + str(nbinscrit)
+        )
+        return moystr
+
+    str_moytag = classmethod(str_moytag)
+    # -----------------------------------------------------------------------
+
+    def str_tagtable(self, delim=";", decimal_sep=","):
+        """Renvoie une chaine de caractère listant toutes les moyennes, les rangs des étudiants pour tous les tags."""
+        entete = ["etudid", "nom", "prenom"]
+        for tag in self.get_all_tags():
+            entete += [titre + "_" + tag for titre in ["note", "rang", "nb_inscrit"]]
+        chaine = delim.join(entete) + "\n"
+
+        for etudid in self.identdict:
+            descr = delim.join(
+                [
+                    etudid,
+                    self.identdict[etudid]["nom"],
+                    self.identdict[etudid]["prenom"],
+                ]
+            )
+            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
+
+
+# ************************************************************************
+# Fonctions diverses
+# ************************************************************************
+
+
+# *********************************************
+def moyenne_ponderee_terme_a_terme(notes, coefs=None, force=False):
+    """
+    Calcule la moyenne pondérée d'une liste de notes avec d'éventuels coeffs de pondération.
+    Renvoie le résultat sous forme d'un tuple (moy, somme_coeff)
+
+    La liste de notes contient soit :
+    1) des valeurs numériques
+    2) des strings "-NA-" (pas de notes) ou "-NI-" (pas inscrit) ou "-c-" ue capitalisée,
+    3) None.
+
+    Le paramètre force indique si le calcul de la moyenne doit être forcée ou non, c'est à
+    dire s'il y a ou non omission des notes non numériques (auquel cas la moyenne est
+    calculée sur les notes disponibles) ; sinon renvoie (None, None).
+    """
+    # Vérification des paramètres d'entrée
+    if not isinstance(notes, list) or (
+        coefs != None and not isinstance(coefs, list) and len(coefs) != len(notes)
+    ):
+        raise ValueError("Erreur de paramètres dans moyenne_ponderee_terme_a_terme")
+
+    # Récupération des valeurs des paramètres d'entrée
+    coefs = [1] * len(notes) if coefs is None else coefs
+
+    # S'il n'y a pas de notes
+    if not notes:  # Si notes = []
+        return (None, None)
+
+    # Liste indiquant les notes valides
+    notes_valides = [
+        (isinstance(note, float) and not np.isnan(note)) or isinstance(note, int)
+        for note in notes
+    ]
+    # Si on force le calcul de la moyenne ou qu'on ne le force pas
+    #    et qu'on a le bon nombre de notes
+    if force or sum(notes_valides) == len(notes):
+        moyenne, ponderation = 0.0, 0.0
+        for i in range(len(notes)):
+            if notes_valides[i]:
+                moyenne += coefs[i] * notes[i]
+                ponderation += coefs[i]
+        return (
+            (moyenne / (ponderation * 1.0), ponderation)
+            if ponderation != 0
+            else (None, 0)
+        )
+    # Si on ne force pas le calcul de la moyenne
+    return (None, None)
+
+
+# -------------------------------------------------------------------------------------------
+def conversionDate_StrToDate(date_fin):
+    """Conversion d'une date fournie sous la forme d'une chaine de caractère de
+    type 'jj/mm/aaaa' en un objet date du package datetime.
+    Fonction servant au tri des semestres par date
+    """
+    (d, m, y) = [int(x) for x in date_fin.split("/")]
+    date_fin_dst = datetime.date(y, m, d)
+    return date_fin_dst

app/pe/pe_tools.py

@@ -0,0 +1,959 @@
+# -*- mode: python -*-
+# -*- coding: utf-8 -*-
+
+##############################################################################
+#
+# Gestion scolarite IUT
+#
+# Copyright (c) 1999 - 2023 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_view.py

@@ -5,7 +5,7 @@
 #
 # Gestion scolarite IUT
 #
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 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
@@ -35,70 +35,148 @@
 
 """
 
-from flask import flash, g, redirect, render_template, request, send_file, url_for
-
-from app.decorators import permission_required, scodoc
-from app.models import FormSemestre
-from app.pe import pe_comp
-from app.pe import pe_jury
-from app.views import ScoData
+from flask import send_file, request
 from app.scodoc.sco_exceptions import ScoValueError
-from app.scodoc.sco_permissions import Permission
+
 import app.scodoc.sco_utils as scu
+from app.scodoc import sco_formsemestre
+from app.scodoc import html_sco_header
+from app.scodoc import sco_preferences
 
-from app.views import notes_bp as bp
+from app.pe import pe_tools
+from app.pe import pe_jurype
+from app.pe import pe_avislatex
 
 
-@bp.route("/pe_view_sem_recap/<int:formsemestre_id>", methods=("GET", "POST"))
-@scodoc
-@permission_required(Permission.ScoView)
-def pe_view_sem_recap(formsemestre_id: int):
+def _pe_view_sem_recap_form(formsemestre_id):
+    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.
+        <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">
+        <div class="pe_template_up">
+            Les templates sont généralement installés sur le serveur ou dans le
+            paramétrage de ScoDoc.
+            <br>
+            Au besoin, vous pouvez spécifier ici votre propre fichier de template
+            (<tt>un_avis.tex</tt>):
+            <div class="pe_template_upb">Template:
+                <input type="file" size="30" name="avis_tmpl_file"/>
+            </div>
+            <div class="pe_template_upb">Pied de page:
+                <input type="file" size="30" name="footer_tmpl_file"/>
+            </div>
+        </div>
+        <input type="submit" value="Générer les documents"/>
+        <input type="hidden" name="formsemestre_id" value="{formsemestre_id}">
+        </form>
+        """,
+    ]
+    return "\n".join(H) + html_sco_header.sco_footer()
+
+
+# called from the web, POST or GET
+def pe_view_sem_recap(
+    formsemestre_id,
+    avis_tmpl_file=None,
+    footer_tmpl_file=None,
+):
     """Génération des avis de poursuite d'étude"""
-
-    formsemestre = FormSemestre.get_formsemestre(formsemestre_id)
-    if not formsemestre.formation.is_apc():
-        raise ScoValueError(
-            """Le module de Poursuites d'Etudes
-            n'est disponible que pour des formations BUT"""
-        )
-
-    if formsemestre.formation.get_cursus().NB_SEM < 6:
-        raise ScoValueError(
-            """Le module de Poursuites d'Etudes n'est pas prévu
-            pour une formation de moins de 6 semestres"""
-        )
-    # L'année du diplome
-    annee_diplome = pe_comp.get_annee_diplome_semestre(formsemestre)
-
-    # Cosemestres diplomants
-    cosemestres = pe_comp.get_cosemestres_diplomants(annee_diplome)
-
     if request.method == "GET":
-        return render_template(
-            "pe/pe_view_sem_recap.j2",
-            annee_diplome=annee_diplome,
-            formsemestre=formsemestre,
-            sco=ScoData(formsemestre=formsemestre),
-            cosemestres=cosemestres,
+        return _pe_view_sem_recap_form(formsemestre_id)
+    prefs = sco_preferences.SemPreferences(formsemestre_id=formsemestre_id)
+
+    semBase = sco_formsemestre.get_formsemestre(formsemestre_id)
+
+    jury = pe_jurype.JuryPE(semBase)
+    # Ajout avis LaTeX au même zip:
+    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 avis_tmpl_file:
+        try:
+            template_latex = avis_tmpl_file.read().decode("utf-8")
+        except UnicodeDecodeError as e:
+            raise ScoValueError(
+                "Données (template) invalides (caractères non UTF8 ?)"
+            ) from e
+    else:
+        # template indiqué dans préférences ScoDoc ?
+        template_latex = pe_avislatex.get_code_latex_from_scodoc_preference(
+            formsemestre_id, champ="pe_avis_latex_tmpl"
         )
 
-    # request.method == "POST"
-    jury = pe_jury.JuryPE(annee_diplome)
-    if not jury.diplomes_ids:
-        flash("aucun étudiant à considérer !")
-        return redirect(
-            url_for(
-                "notes.pe_view_sem_recap",
-                scodoc_dept=g.scodoc_dept,
-                formsemestre_id=formsemestre_id,
+    template_latex = template_latex.strip()
+    if not template_latex:
+        # pas de preference pour le template: utilise fichier du serveur
+        template_latex = pe_avislatex.get_templates_from_distrib("avis")
+
+    # Footer:
+    footer_latex = ""
+    # template fourni via le formulaire Web
+    if footer_tmpl_file:
+        footer_latex = footer_tmpl_file.read().decode("utf-8")
+    else:
+        footer_latex = pe_avislatex.get_code_latex_from_scodoc_preference(
+            formsemestre_id, champ="pe_avis_latex_footer"
         )
+    footer_latex = footer_latex.strip()
+    if not footer_latex:
+        # pas de preference pour le footer: utilise fichier du serveur
+        footer_latex = pe_avislatex.get_templates_from_distrib(
+            "footer"
+        )  # fallback: footer vides
+
+    tag_annotation_pe = pe_avislatex.get_code_latex_from_scodoc_preference(
+        formsemestre_id, champ="pe_tag_annotation_avis_latex"
     )
 
+    # Ajout des annotations PE dans un fichier excel
+    sT = pe_avislatex.table_syntheseAnnotationPE(jury.syntheseJury, tag_annotation_pe)
+    if sT:
+        jury.add_file_to_zip(
+            jury.NOM_EXPORT_ZIP + "_annotationsPE" + scu.XLSX_SUFFIX, sT.excel()
+        )
+
+    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(
+            jury,
+            etudid,
+            template_latex,
+            tag_annotation_pe,
+            footer_latex,
+            prefs,
+        )
+        jury.add_file_to_zip("avis/" + nom_fichier + ".tex", contenu_latex)
+        latex_pages[nom_fichier] = contenu_latex  # Sauvegarde dans un dico
+
+    # Nouvelle version : 1 fichier par étudiant avec 1 fichier appelant créée ci-dessous
+    doc_latex = "\n% -----\n".join(
+        ["\\include{" + nom + "}" for nom in sorted(latex_pages.keys())]
+    )
+    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)
     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/TrivialFormulator.py

@@ -396,7 +396,7 @@ class TF(object):
                         self.values[field] = int(self.values[field])
                     except ValueError:
                         msg.append(
-                            f"valeur invalide ({self.values[field]}) pour le champ {field}"
+                            f"valeur invalide ({self.values[field]}) pour le champs {field}"
                         )
                         ok = False
                 elif typ == "float" or typ == "real":
@@ -404,7 +404,7 @@ class TF(object):
                         self.values[field] = float(self.values[field].replace(",", "."))
                     except ValueError:
                         msg.append(
-                            f"valeur invalide ({self.values[field]}) pour le champ {field}"
+                            f"valeur invalide ({self.values[field]}) pour le champs {field}"
                         )
                         ok = False
         if ok:
@@ -685,11 +685,6 @@ class TF(object):
                     '<input type="text" name="%s" size="10" value="%s" class="datepicker">'
                     % (field, values[field])
                 )
-            elif input_type == "time":  # JavaScript widget for date input
-                lem.append(
-                    f"""<input type="text" name="{field}" maxlength="5" size="5" value="{
-                        values[field]}" class="timepicker">"""
-                )
             elif input_type == "text_suggest":
                 lem.append(
                     '<input type="text" name="%s" id="%s" size="%d" %s'

app/scodoc/__init__.py

@@ -5,7 +5,7 @@
 #
 # Gestion scolarite IUT
 #
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 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

app/scodoc/codes_cursus.py

@@ -5,7 +5,7 @@
 #
 # Gestion scolarite IUT
 #
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 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

app/scodoc/gen_tables.py

@@ -5,7 +5,7 @@
 #
 # Gestion scolarite IUT
 #
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 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

app/scodoc/html_sco_header.py

@@ -5,7 +5,7 @@
 #
 # Gestion scolarite IUT
 #
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 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
@@ -145,9 +145,7 @@ def sco_header(
     etudid=None,
     formsemestre_id=None,
 ):
-    """Main HTML page header for ScoDoc
-    Utilisé dans les anciennes pages. Les nouvelles pages utilisent le template Jinja.
-    """
+    "Main HTML page header for ScoDoc"
     from app.scodoc.sco_formsemestre_status import formsemestre_page_title
 
     if etudid is not None:
@@ -191,12 +189,7 @@ def sco_header(
     # jQuery UI
     # can modify loaded theme here
     H.append(
-        f"""
-        <link type="text/css" rel="stylesheet"
-            href="{scu.STATIC_DIR}/libjs/jquery-ui-1.10.4.custom/css/smoothness/jquery-ui-1.10.4.custom.min.css" />
-        <link type="text/css" rel="stylesheet"
-            href="{scu.STATIC_DIR}/libjs/timepicker-1.3.5/jquery.timepicker.min.css" />
-        """
+        f'<link type="text/css" rel="stylesheet" href="{scu.STATIC_DIR}/libjs/jquery-ui-1.10.4.custom/css/smoothness/jquery-ui-1.10.4.custom.min.css" />\n'
     )
     if init_google_maps:
         # It may be necessary to add an API key:
@@ -226,26 +219,19 @@ def sco_header(
 
     # jQuery
     H.append(
-        f"""
-    <script src="{scu.STATIC_DIR}/jQuery/jquery.js"></script>
-    <script src="{scu.STATIC_DIR}/libjs/jquery.field.min.js"></script>
-    """
+        f"""<script src="{scu.STATIC_DIR}/jQuery/jquery.js"></script>
+    <script src="{scu.STATIC_DIR}/libjs/jquery.field.min.js"></script>"""
     )
     # qTip
     if init_qtip:
         H.append(
             f"""<script src="{scu.STATIC_DIR}/libjs/qtip/jquery.qtip-3.0.3.min.js"></script>
-        <link type="text/css" rel="stylesheet"
-            href="{scu.STATIC_DIR}/libjs/qtip/jquery.qtip-3.0.3.min.css" />
-        """
+        <link type="text/css" rel="stylesheet" href="{scu.STATIC_DIR}/libjs/qtip/jquery.qtip-3.0.3.min.css" />"""
         )
 
     H.append(
-        f"""<script
-        src="{scu.STATIC_DIR}/libjs/jquery-ui-1.10.4.custom/js/jquery-ui-1.10.4.custom.min.js"></script>
-        <script src="{scu.STATIC_DIR}/libjs/timepicker-1.3.5/jquery.timepicker.min.js"></script>
-        <script src="{scu.STATIC_DIR}/js/scodoc.js"></script>
-        """
+        f"""<script src="{scu.STATIC_DIR}/libjs/jquery-ui-1.10.4.custom/js/jquery-ui-1.10.4.custom.min.js"></script>
+        <script src="{scu.STATIC_DIR}/js/scodoc.js"></script>"""
     )
     if init_google_maps:
         H.append(

app/scodoc/html_sidebar.py

@@ -5,7 +5,7 @@
 #
 # Gestion scolarite IUT
 #
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 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
@@ -32,68 +32,12 @@ from flask import render_template, url_for
 from flask import g, request
 from flask_login import current_user
 
-from app import db
-from app.models import Evaluation, GroupDescr, Identite, ModuleImpl, Partition
 import app.scodoc.sco_utils as scu
 from app.scodoc import sco_preferences
 from app.scodoc.sco_permissions import Permission
 from sco_version import SCOVERSION
 
 
-def retreive_formsemestre_from_request() -> int:
-    """Cherche si on a de quoi déduire le semestre affiché à partir des
-    arguments de la requête:
-    formsemestre_id ou moduleimpl ou evaluation ou group_id ou partition_id
-    Returns None si pas défini.
-    """
-    if request.method == "GET":
-        args = request.args
-    elif request.method == "POST":
-        args = request.form
-    else:
-        return None
-    formsemestre_id = None
-    # Search formsemestre
-    group_ids = args.get("group_ids", [])
-    if "formsemestre_id" in args:
-        formsemestre_id = args["formsemestre_id"]
-    elif "moduleimpl_id" in args and args["moduleimpl_id"]:
-        modimpl = db.session.get(ModuleImpl, args["moduleimpl_id"])
-        if not modimpl:
-            return None  # suppressed ?
-        formsemestre_id = modimpl.formsemestre_id
-    elif "evaluation_id" in args:
-        evaluation = db.session.get(Evaluation, args["evaluation_id"])
-        if not evaluation:
-            return None  # evaluation suppressed ?
-        formsemestre_id = evaluation.moduleimpl.formsemestre_id
-    elif "group_id" in args:
-        group = db.session.get(GroupDescr, args["group_id"])
-        if not group:
-            return None
-        formsemestre_id = group.partition.formsemestre_id
-    elif group_ids:
-        if isinstance(group_ids, str):
-            group_ids = group_ids.split(",")
-        group_id = group_ids[0]
-        group = db.session.get(GroupDescr, group_id)
-        if not group:
-            return None
-        formsemestre_id = group.partition.formsemestre_id
-    elif "partition_id" in args:
-        partition = db.session.get(Partition, args["partition_id"])
-        if not partition:
-            return None
-        formsemestre_id = partition.formsemestre_id
-
-    if formsemestre_id is None:
-        return None  # no current formsemestre
-    try:
-        return int(formsemestre_id)
-    except ValueError:
-        return None  # no current formsemestre
-
-
 def sidebar_common():
     "partie commune à toutes les sidebar"
     home_link = url_for("scodoc.index", scodoc_dept=g.scodoc_dept)
@@ -160,56 +104,44 @@ def sidebar(etudid: int = None):
             etudid = request.form.get("etudid", None)
 
     if etudid is not None:
-        etud = Identite.get_etud(etudid)
+        etud = sco_etud.get_etud_info(filled=True, etudid=etudid)[0]
+        params.update(etud)
+        params["fiche_url"] = url_for(
+            "scolar.ficheEtud", scodoc_dept=g.scodoc_dept, etudid=etudid
+        )
         # compte les absences du semestre en cours
         H.append(
-            f"""<h2 id="insidebar-etud"><a href="{
-                url_for(
-                    "scolar.fiche_etud", scodoc_dept=g.scodoc_dept, etudid=etudid
-                )
-                }" class="sidebar">
-            <font color="#FF0000">{etud.civilite_str} {etud.nom_disp()}</font></a>
+            """<h2 id="insidebar-etud"><a href="%(fiche_url)s" class="sidebar">
+    <font color="#FF0000">%(civilite_str)s %(nom_disp)s</font></a>
     </h2>
     <b>Absences</b>"""
+            % params
         )
-        inscription = etud.inscription_courante()
-        if inscription:
-            formsemestre = inscription.formsemestre
-            nbabs, nbabsjust = sco_assiduites.formsemestre_get_assiduites_count(
-                etudid, formsemestre
-            )
+        if etud["cursem"]:
+            cur_sem = etud["cursem"]
+            nbabs, nbabsjust = sco_assiduites.get_assiduites_count(etudid, cur_sem)
             nbabsnj = nbabs - nbabsjust
             H.append(
-                f"""<span title="absences du {
-                    formsemestre.date_debut.strftime("%d/%m/%Y")
-                } au {
-                    formsemestre.date_fin.strftime("%d/%m/%Y")
-                }">({
+                f"""<span title="absences du { cur_sem["date_debut"] } au {
+                    cur_sem["date_fin"] }">({
                         sco_preferences.get_preference("assi_metrique", None)})
                 <br>{ nbabsjust } J., { nbabsnj } N.J.</span>"""
             )
         H.append("<ul>")
         if current_user.has_permission(Permission.AbsChange):
-            # essaie de conserver le semestre actuellement en vue
-            cur_formsemestre_id = retreive_formsemestre_from_request()
             H.append(
                 f"""
-                <li><a href="{
-                    url_for('assiduites.ajout_assiduite_etud',
+                <li><a href="{ url_for('assiduites.ajout_assiduite_etud',
                                        scodoc_dept=g.scodoc_dept, etudid=etudid)
                                 }">Ajouter</a></li>
-                <li><a href="{
-                    url_for('assiduites.ajout_justificatif_etud',
-                            scodoc_dept=g.scodoc_dept, etudid=etudid,
-                            formsemestre_id=cur_formsemestre_id,
-                            )
+                <li><a href="{ url_for('assiduites.ajout_justificatif_etud',
+                                    scodoc_dept=g.scodoc_dept, etudid=etudid)
                                 }">Justifier</a></li>
                 """
             )
             if sco_preferences.get_preference("handle_billets_abs"):
                 H.append(
-                    f"""<li><a href="{
-                    url_for('absences.billets_etud',
+                    f"""<li><a href="{ url_for('absences.billets_etud',
                                     scodoc_dept=g.scodoc_dept, etudid=etudid)
                                 }">Billets</a></li>"""
                 )

app/scodoc/htmlutils.py

@@ -5,7 +5,7 @@
 #
 # Gestion scolarite IUT
 #
-# Copyright (c) 1999 - 2024 Emmanuel Viennet.  All rights reserved.
+# Copyright (c) 1999 - 2023 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