WIP: calcul moyennes UE BUT

app/comp/moy_mod.py

@@ -88,7 +88,7 @@ def df_load_modimpl_notes(moduleimpl_id: int) -> pd.DataFrame:
 
     Résultat: (evals_notes, liste de évaluations du moduleimpl)
 
-    L'ensemble des étudiants est celui des inscrits au module.
+    L'ensemble des étudiants est celui des inscrits au SEMESTRE.
 
     Les notes renvoyées sont "brutes" (séries de floats) et peuvent prendre les valeurs:
         note : float (valeur enregistrée brute, non normalisée sur 20)
@@ -99,7 +99,10 @@ def df_load_modimpl_notes(moduleimpl_id: int) -> pd.DataFrame:
 
     N'utilise pas de cache ScoDoc.
     """
-    etudids = [e.etudid for e in ModuleImpl.query.get(moduleimpl_id).inscriptions]
+    # L'index du dataframe est la liste des étudiants inscrits au semestre:
+    etudids = [
+        e.etudid for e in ModuleImpl.query.get(moduleimpl_id).formsemestre.inscriptions
+    ]
     evaluations = Evaluation.query.filter_by(moduleimpl_id=moduleimpl_id)
     evals_notes = pd.DataFrame(index=etudids, dtype=float)  # empty df with all students
 
@@ -165,10 +168,10 @@ def compute_module_moy(
     # Calcule la moyenne pondérée sur les notes disponibles
     evals_notes_stacked = np.stack([evals_notes] * nb_ues, axis=2)
     with np.errstate(invalid="ignore"):  # ignore les 0/0 (-> NaN)
-        etud_moy_module = np.sum(
+        etuds_moy_module = np.sum(
             evals_poids_etuds * evals_notes_stacked, axis=1
         ) / np.sum(evals_poids_etuds, axis=1)
-    etud_moy_module_df = pd.DataFrame(
+    etuds_moy_module_df = pd.DataFrame(
-        etud_moy_module, index=evals_notes_df.index, columns=evals_poids_df.columns
+        etuds_moy_module, index=evals_notes_df.index, columns=evals_poids_df.columns
     )
-    return etud_moy_module_df
+    return etuds_moy_module_df

app/comp/moy_ue.py

@@ -32,28 +32,148 @@ import pandas as pd
 
 from app import db
 from app import models
+from app.models import UniteEns, Module, ModuleImpl, ModuleUECoef
+from app.comp import moy_mod
+from app.models.formsemestre import FormSemestre
+from app.scodoc import sco_codes_parcours
 
 
-def df_load_ue_coefs(formation_id: int, semestre_idx: int) -> pd.DataFrame:
+def df_load_module_coefs(formation_id: int, semestre_idx: int) -> pd.DataFrame:
-    """Load coefs of all modules in formation and returns a DataFrame
+    """Charge les coefs des modules de la formation pour le semestre indiqué.
-    rows = UEs, columns = modules, value = coef.
+
-    On considère toutes les UE et modules du semestre.
+    Ces coefs lient les modules à chaque UE.
-    Unspecified coefs (not defined in db) are set to zero.
+
+    Résultat: (module_coefs_df, ues, modules)
+        DataFrame rows = UEs, columns = modules, value = coef.
+
+    Considère toutes les UE (sauf sport) et modules du semestre.
+    Les coefs non définis (pas en base) sont mis à zéro.
+
     Si semestre_idx None, prend toutes les UE de la formation.
     """
-    ues = models.UniteEns.query.filter_by(formation_id=formation_id)
+    ues = UniteEns.query.filter_by(formation_id=formation_id).filter(
-    modules = models.Module.query.filter_by(formation_id=formation_id)
+        UniteEns.type != sco_codes_parcours.UE_SPORT
+    )
+    modules = Module.query.filter_by(formation_id=formation_id)
     if semestre_idx is not None:
         ues = ues.filter_by(semestre_idx=semestre_idx)
         modules = modules.filter_by(semestre_id=semestre_idx)
+    ues = ues.all()
+    modules = modules.all()
     ue_ids = [ue.id for ue in ues]
     module_ids = [module.id for module in modules]
-    df = pd.DataFrame(columns=module_ids, index=ue_ids, dtype=float)
+    module_coefs_df = pd.DataFrame(columns=module_ids, index=ue_ids, dtype=float)
     for mod_coef in (
-        db.session.query(models.ModuleUECoef)
+        db.session.query(ModuleUECoef)
-        .filter(models.UniteEns.formation_id == formation_id)
+        .filter(UniteEns.formation_id == formation_id)
-        .filter(models.ModuleUECoef.ue_id == models.UniteEns.id)
+        .filter(ModuleUECoef.ue_id == UniteEns.id)
     ):
-        df[mod_coef.module_id][mod_coef.ue_id] = mod_coef.coef
+        module_coefs_df[mod_coef.module_id][mod_coef.ue_id] = mod_coef.coef
-    df.fillna(value=0, inplace=True)
+    module_coefs_df.fillna(value=0, inplace=True)
-    return df, ues, modules
+    return module_coefs_df, ues, modules
+
+
+def df_load_modimpl_coefs(formsemestre: models.FormSemestre) -> pd.DataFrame:
+    """Charge les coefs des modules du formsemestre indiqué.
+
+    Comme df_load_module_coefs mais prend seulement les UE
+    et modules du formsemestre.
+
+    Résultat: (module_coefs_df, ues, modules)
+        DataFrame rows = UEs, columns = modimpl, value = coef.
+    """
+    ues = formsemestre.query_ues().all()
+    ue_ids = [x.id for x in ues]
+    modimpls = formsemestre.modimpls.all()
+    modimpl_ids = [x.id for x in modimpls]
+    mod2impl = {m.module.id: m.id for m in modimpls}
+    modimpl_coefs_df = pd.DataFrame(columns=modimpl_ids, index=ue_ids, dtype=float)
+    mod_coefs = (
+        db.session.query(ModuleUECoef)
+        .filter(ModuleUECoef.module_id == ModuleImpl.module_id)
+        .filter(ModuleImpl.formsemestre_id == formsemestre.id)
+    )
+
+    for mod_coef in mod_coefs:
+        modimpl_coefs_df[mod2impl[mod_coef.module_id]][mod_coef.ue_id] = mod_coef.coef
+    modimpl_coefs_df.fillna(value=0, inplace=True)
+    return modimpl_coefs_df, ues, modimpls
+
+
+def notes_sem_assemble_cube(modimpls_notes: list[pd.DataFrame]) -> np.ndarray:
+    """Réuni les notes moyennes des modules du semestre en un "cube"
+
+    modimpls_notes : liste des moyennes de module
+                     (DataFrames rendus par compute_module_moy, (etud x UE))
+    Resultat: ndarray (etud x module x UE)
+    """
+    modimpls_notes_arr = [df.values for df in modimpls_notes]
+    modimpls_notes = np.stack(modimpls_notes_arr)
+    # passe de (mod x etud x ue) à (etud x mod x UE)
+    return modimpls_notes.swapaxes(0, 1)
+
+
+def notes_sem_load_cube(formsemestre_id):
+    """Calcule le cube des notes du semestre
+    (charge toutes les notes, calcule les moyenne des modules
+    et assemble le cube)
+    Resultat: ndarray (etuds x modimpls x UEs)
+    """
+    formsemestre = FormSemestre.query.get(formsemestre_id)
+    modimpls_notes = []
+    for modimpl in formsemestre.modimpls:
+        evals_notes, evaluations = moy_mod.df_load_modimpl_notes(modimpl.id)
+        evals_poids, ues = moy_mod.df_load_evaluations_poids(modimpl.id)
+        etuds_moy_module = moy_mod.compute_module_moy(
+            evals_notes, evals_poids, evaluations
+        )
+        modimpls_notes.append(etuds_moy_module)
+    return notes_sem_assemble_cube(modimpls_notes)
+
+
+def compute_ue_moys(
+    sem_cube: np.array,
+    etuds: list,
+    modimpls: list,
+    ues: list,
+    module_inscr_df: pd.DataFrame,
+    module_coefs_df: pd.DataFrame,
+) -> pd.DataFrame:
+    """Calcul de la moyenne d'UE
+    La moyenne d'UE est un nombre (note/20), ou NI ou NA ou ERR
+    NI non inscrit à (au moins un) module de cette UE
+    NA pas de notes disponibles
+    ERR erreur dans une formule utilisateur. [XXX pas encore gérées ici]
+
+    sem_cube: notes moyennes aux modules
+                ndarray (etuds x modimpls x UEs)
+                (floats avec des NaN)
+    etuds : lites des étudiants (dim. 0 du cube)
+    modimpls : liste des modules à considérer (dim. 1 du cube)
+    ues : liste des UE (dim. 2 du cube)
+    module_inscr_df: matrice d'inscription du semestre (etud x modimpl)
+    module_coefs_df: matrice coefficients (UE x modimpl)
+
+    Resultat: DataFrame columns UE, rows etudid
+    """
+    nb_etuds, nb_modules, nb_ues = sem_cube.shape
+    assert len(etuds) == nb_etuds
+    assert len(modimpls) == nb_modules
+    assert len(ues) == nb_ues
+    assert module_inscr_df.shape[0] == nb_etuds
+    assert module_inscr_df.shape[1] == nb_modules
+    assert module_coefs_df.shape[0] == nb_ues
+    assert module_coefs_df.shape[1] == nb_modules
+    module_inscr = module_inscr_df.values
+    modules_coefs = module_coefs_df.values
+    #
+    # version non vectorisée sur les etuds:
+    etud_moy_ue = np.zeros((nb_etuds, nb_ues))
+    for i in range(nb_etuds):
+        coefs = module_inscr[i] * modules_coefs
+        etud_moy_ue[i] = (sem_cube[i].transpose() * coefs).sum(axis=1) / coefs.sum(
+            axis=1
+        )
+    return pd.DataFrame(
+        etud_moy_ue, index=module_inscr_df.index, columns=module_coefs_df.index
+    )

app/models/formsemestre.py

@@ -83,6 +83,12 @@ class FormSemestre(db.Model):
         "FormsemestreEtape", cascade="all,delete", backref="formsemestre"
     )
     modimpls = db.relationship("ModuleImpl", backref="formsemestre", lazy="dynamic")
+    etuds = db.relationship(
+        "Identite",
+        secondary="notes_formsemestre_inscription",
+        viewonly=True,
+        lazy="dynamic",
+    )
 
     # Ancien id ScoDoc7 pour les migrations de bases anciennes
     # ne pas utiliser après migrate_scodoc7_dept_archives

app/scodoc/sco_liste_notes.py

@@ -232,6 +232,8 @@ def _make_table_notes(
     is_apc = module.formation.get_parcours().APC_SAE
     if is_apc:
         evals_poids, ues = moy_mod.df_load_evaluations_poids(moduleimpl_id)
+        if not ues:
+            is_apc = False
     else:
         evals_poids, ues = None, None
     sem = sco_formsemestre.get_formsemestre(modimpl["formsemestre_id"])
@@ -772,11 +774,11 @@ def _add_apc_columns(
     # on va y ajouter une clé par UE du semestre
 
     evals_notes, evaluations = moy_mod.df_load_modimpl_notes(moduleimpl_id)
-    etud_moy_module = moy_mod.compute_module_moy(evals_notes, evals_poids, evaluations)
+    etuds_moy_module = moy_mod.compute_module_moy(evals_notes, evals_poids, evaluations)
 
     for row in rows:
         for ue in ues:
-            moy_ue = etud_moy_module[ue.id].get(row["etudid"], "?")
+            moy_ue = etuds_moy_module[ue.id].get(row["etudid"], "?")
             row[f"moy_ue_{ue.id}"] = scu.fmt_note(moy_ue, keep_numeric=keep_numeric)
             row[f"_moy_ue_{ue.id}_class"] = "moy_ue"
     for ue in ues:

app/views/pn_modules.py

@@ -76,7 +76,7 @@ def table_modules_ue_coefs(formation_id, semestre_idx=None):
     _ = models.Formation.query.get_or_404(formation_id)  # check
     if semestre_idx == "":
         semestre_idx = None
-    df, ues, modules = moy_ue.df_load_ue_coefs(formation_id, semestre_idx)
+    df, ues, modules = moy_ue.df_load_module_coefs(formation_id, semestre_idx)
     # Titre des modules, en ligne
     col_titres_mods = [
         {

tests/unit/test_but_modules.py

@@ -1,17 +1,17 @@
 """
 Test modèles évaluations avec poids BUT
+et calcul moyennes modules
 """
 import numpy as np
 import pandas as pd
-from app.models.etudiants import Identite
 
-from tests.unit import sco_fake_gen
+from tests.unit import setup
 from app import db
 from app import models
 from app.comp import moy_mod
 from app.comp import moy_ue
 from app.models import Evaluation
-from app.scodoc import sco_codes_parcours, sco_saisie_notes
+from app.scodoc import sco_saisie_notes
 from app.scodoc.sco_utils import NOTES_ATTENTE, NOTES_NEUTRALISE
 
 """
@@ -23,43 +23,9 @@ login_user(admin_user)
 """
 
 
-def setup_formation_test():
-    G = sco_fake_gen.ScoFake(verbose=False)
-    _f = G.create_formation(
-        acronyme="F3",
-        titre="Formation 2",
-        titre_officiel="Titre officiel 2",
-        type_parcours=sco_codes_parcours.ParcoursBUT.TYPE_PARCOURS,
-    )
-    _ue1 = G.create_ue(
-        formation_id=_f["formation_id"], acronyme="UE1", titre="ue 1", semestre_idx=2
-    )
-    _ue2 = G.create_ue(
-        formation_id=_f["formation_id"], acronyme="UE2", titre="ue 2", semestre_idx=2
-    )
-    _ue3 = G.create_ue(
-        formation_id=_f["formation_id"], acronyme="UE3", titre="ue 3", semestre_idx=2
-    )
-    # une 4eme UE en dehors du semestre 2
-    _ = G.create_ue(
-        formation_id=_f["formation_id"], acronyme="UE41", titre="ue 41", semestre_idx=4
-    )
-    _mat = G.create_matiere(ue_id=_ue1["ue_id"], titre="matière test")
-    _mod = G.create_module(
-        matiere_id=_mat["matiere_id"],
-        code="TSM1",
-        coefficient=1.0,
-        titre="module test",
-        ue_id=_ue1["ue_id"],
-        formation_id=_f["formation_id"],
-        semestre_id=2,
-    )
-    return G, _f["id"], _ue1["id"], _ue2["id"], _ue3["id"], _mod["id"]
-
-
 def test_evaluation_poids(test_client):
     """Association de poids vers les UE"""
-    G, formation_id, ue1_id, ue2_id, ue3_id, module_id = setup_formation_test()
+    G, formation_id, ue1_id, ue2_id, ue3_id, module_ids = setup.build_formation_test()
     sem = G.create_formsemestre(
         formation_id=formation_id,
         semestre_id=1,
@@ -67,7 +33,7 @@ def test_evaluation_poids(test_client):
         date_fin="30/06/2021",
     )  # formsemestre_id=716
     mi = G.create_moduleimpl(
-        module_id=module_id,
+        module_id=module_ids[0],
         formsemestre_id=sem["formsemestre_id"],
     )
     moduleimpl_id = mi["id"]
@@ -114,10 +80,10 @@ def test_evaluation_poids(test_client):
 
 def test_modules_coefs(test_client):
     """Coefs vers les UE (BUT)"""
-    G, formation_id, ue1_id, ue2_id, ue3_id, module_id = setup_formation_test()
+    G, formation_id, ue1_id, ue2_id, ue3_id, module_ids = setup.build_formation_test()
     ue1 = models.UniteEns.query.get(ue1_id)
     ue2 = models.UniteEns.query.get(ue2_id)
-    mod = models.Module.query.get(module_id)
+    mod = models.Module.query.get(module_ids[0])
     coef = 2.5
     mod.set_ue_coef(ue1, coef)
     db.session.commit()
@@ -135,64 +101,27 @@ def test_modules_coefs(test_client):
     assert len(mod.ue_coefs) == 0
 
 
-def _setup_module_evaluation(ue_coefs=(1.0, 2.0, 3.0)):
-    """Utilisé dans plusieurs tests:
-    - création formation 3 UE, 1 module
-    - 1 semestre, 1 moduleimpl, 1 eval
-    """
-    G, formation_id, ue1_id, ue2_id, ue3_id, module_id = setup_formation_test()
-    ue1 = models.UniteEns.query.get(ue1_id)
-    ue2 = models.UniteEns.query.get(ue2_id)
-    ue3 = models.UniteEns.query.get(ue3_id)
-    mod = models.Module.query.get(module_id)
-    nb_ues = 3  # 3 UEs dans ce test
-    nb_mods = 1  # 1 seul module
-    # Coef du module vers les UE
-    c1, c2, c3 = ue_coefs
-    coefs_mod = {ue1.id: c1, ue2.id: c2, ue3.id: c3}
-    mod.set_ue_coef_dict(coefs_mod)
-    assert mod.get_ue_coef_dict() == coefs_mod
-    # Mise en place:
-    sem = G.create_formsemestre(
-        formation_id=formation_id,
-        semestre_id=2,
-        date_debut="01/01/2021",
-        date_fin="30/06/2021",
-    )
-    mi = G.create_moduleimpl(
-        module_id=module_id,
-        formsemestre_id=sem["formsemestre_id"],
-    )
-    moduleimpl_id = mi["id"]
-    modimpl = models.ModuleImpl.query.get(moduleimpl_id)
-    assert modimpl.formsemestre.formation.get_parcours().APC_SAE  # BUT
-    # Check ModuleImpl
-    ues = modimpl.formsemestre.query_ues().all()
-    assert len(ues) == 3
-    #
-    _e1 = G.create_evaluation(
-        moduleimpl_id=moduleimpl_id,
-        jour="01/01/2021",
-        description="evaluation 1",
-        coefficient=0,
-    )
-    evaluation_id = _e1["evaluation_id"]
-    return G, formation_id, sem, evaluation_id, ue1, ue2, ue3
-
-
 def test_module_conformity(test_client):
     """Vérification coefficients module<->UE vs poids des évaluations"""
-    _, formation_id, _, evaluation_id, ue1, ue2, ue3 = _setup_module_evaluation()
+    (
+        _,
+        formation_id,
+        _,
+        evaluation_ids,
+        ue1,
+        ue2,
+        ue3,
+    ) = setup.build_modules_with_evaluations()
     semestre_idx = 2
     nb_ues = 3  # 3 UEs dans ce test
     nb_mods = 1  # 1 seul module
     nb_evals = 1  # 1 seule evaluation pour l'instant
     p1, p2, p3 = 1.0, 2.0, 0.0  # poids de l'éval vers les UE 1, 2 et 3
-    evaluation = models.Evaluation.query.get(evaluation_id)
+    evaluation = models.Evaluation.query.get(evaluation_ids[0])
     evaluation.set_ue_poids_dict({ue1.id: p1, ue2.id: p2, ue3.id: p3})
     assert evaluation.get_ue_poids_dict() == {ue1.id: p1, ue2.id: p2, ue3.id: p3}
     # On n'est pas conforme car p3 est nul alors que c3 est non nul
-    modules_coefficients, _ues, _modules = moy_ue.df_load_ue_coefs(
+    modules_coefficients, _ues, _modules = moy_ue.df_load_module_coefs(
         formation_id, semestre_idx
     )
     assert isinstance(modules_coefficients, pd.DataFrame)
@@ -247,11 +176,11 @@ def test_module_moy_elem(test_client):
         Evaluation(note_max=20.0, coefficient=1.0),
         Evaluation(note_max=20.0, coefficient=1.0),
     ]
-    etud_moy_module_df = moy_mod.compute_module_moy(
+    etuds_moy_module_df = moy_mod.compute_module_moy(
         evals_notes_df.fillna(0.0), evals_poids_df, evaluations
     )
     NAN = 666.0  # pour pouvoir comparer NaN et NaN (car NaN != NaN)
-    r = etud_moy_module_df.fillna(NAN)
+    r = etuds_moy_module_df.fillna(NAN)
     assert tuple(r.loc["etud1"]) == (14 + 1 / 3, 16.0, NAN)
     assert tuple(r.loc["etud2"]) == (11 + 1 / 3, 17.0, NAN)
     assert tuple(r.loc["etud3"]) == (13, NAN, NAN)
@@ -263,11 +192,19 @@ def test_module_moy_elem(test_client):
 def test_module_moy(test_client):
     """Test calcul moyenne module avec saisie des notes via ScoDoc"""
     coef_e1, coef_e2 = 7.0, 11.0  # coefficients des évaluations
-    G, formation_id, sem, evaluation1_id, ue1, ue2, ue3 = _setup_module_evaluation()
+    (
+        G,
+        formation_id,
+        sem,
+        evaluation1_ids,
+        ue1,
+        ue2,
+        ue3,
+    ) = setup.build_modules_with_evaluations()
     etud = G.create_etud(nom="test")
     G.inscrit_etudiant(sem, etud)
     etudid = etud["etudid"]
-    evaluation1 = models.Evaluation.query.get(evaluation1_id)
+    evaluation1 = models.Evaluation.query.get(evaluation1_ids[0])
     # Crée une deuxième évaluation dans le même moduleimpl:
     evaluation2_id = G.create_evaluation(
         moduleimpl_id=evaluation1.moduleimpl_id,
@@ -300,51 +237,53 @@ def test_module_moy(test_client):
         assert evals_poids.shape == (nb_evals, nb_ues)
         evals_notes, evaluations = moy_mod.df_load_modimpl_notes(moduleimpl_id)
         assert evals_notes[str(evaluations[0].id)].dtype == np.float64
-        etud_moy_module = moy_mod.compute_module_moy(
+        etuds_moy_module = moy_mod.compute_module_moy(
             evals_notes, evals_poids, evaluations
         )
-        return etud_moy_module
+        return etuds_moy_module
 
     # --- Notes ordinaires:
     note1, note2 = 11.0, 12.0
     sum_copo1 = e1p1 * coef_e1 + e2p1 * coef_e2  # coefs vers UE1
     sum_copo2 = e1p2 * coef_e1 + e2p2 * coef_e2  #
-    etud_moy_module = change_notes(note1, note2)
+    etuds_moy_module = change_notes(note1, note2)
-    moy_ue1 = etud_moy_module[ue1.id][etudid]
+    moy_ue1 = etuds_moy_module[ue1.id][etudid]
     assert moy_ue1 == ((note1 * e1p1 * coef_e1) + (note2 * e2p1 * coef_e2)) / sum_copo1
-    moy_ue2 = etud_moy_module[ue2.id][etudid]
+    moy_ue2 = etuds_moy_module[ue2.id][etudid]
     assert moy_ue2 == ((note1 * e1p2 * coef_e1) + (note2 * e2p2 * coef_e2)) / sum_copo2
-    moy_ue3 = etud_moy_module[ue3.id][etudid]
+    moy_ue3 = etuds_moy_module[ue3.id][etudid]
     assert np.isnan(moy_ue3)  # car les poids vers UE3 sont nuls
 
     # --- Une Note ABS (comptée comme zéro)
-    etud_moy_module = change_notes(None, note2)
+    etuds_moy_module = change_notes(None, note2)
-    assert etud_moy_module[ue1.id][etudid] == (note2 * e2p1 * coef_e2) / sum_copo1
+    assert etuds_moy_module[ue1.id][etudid] == (note2 * e2p1 * coef_e2) / sum_copo1
-    assert etud_moy_module[ue2.id][etudid] == (note2 * e2p2 * coef_e2) / sum_copo2
+    assert etuds_moy_module[ue2.id][etudid] == (note2 * e2p2 * coef_e2) / sum_copo2
-    assert np.isnan(etud_moy_module[ue3.id][etudid])
+    assert np.isnan(etuds_moy_module[ue3.id][etudid])
     # --- Deux notes ABS
-    etud_moy_module = change_notes(None, None)
+    etuds_moy_module = change_notes(None, None)
-    assert etud_moy_module[ue1.id][etudid] == 0.0
+    assert etuds_moy_module[ue1.id][etudid] == 0.0
-    assert etud_moy_module[ue2.id][etudid] == 0.0
+    assert etuds_moy_module[ue2.id][etudid] == 0.0
-    assert np.isnan(etud_moy_module[ue3.id][etudid])
+    assert np.isnan(etuds_moy_module[ue3.id][etudid])
     # --- Note EXC
-    etud_moy_module = change_notes(NOTES_ATTENTE, note2)
+    etuds_moy_module = change_notes(NOTES_ATTENTE, note2)
-    assert np.isnan(etud_moy_module[ue1.id][etudid])  # car l'eval 2 ne touche que l'UE2
+    assert np.isnan(
-    assert etud_moy_module[ue2.id][etudid] == note2
+        etuds_moy_module[ue1.id][etudid]
-    assert np.isnan(etud_moy_module[ue3.id][etudid])
+    )  # car l'eval 2 ne touche que l'UE2
+    assert etuds_moy_module[ue2.id][etudid] == note2
+    assert np.isnan(etuds_moy_module[ue3.id][etudid])
     # --- Toutes notes ATT (ATT se traite comme EXC)
-    etud_moy_module = change_notes(NOTES_NEUTRALISE, NOTES_NEUTRALISE)
+    etuds_moy_module = change_notes(NOTES_NEUTRALISE, NOTES_NEUTRALISE)
-    assert np.isnan(etud_moy_module[ue1.id][etudid])
+    assert np.isnan(etuds_moy_module[ue1.id][etudid])
-    assert np.isnan(etud_moy_module[ue2.id][etudid])
+    assert np.isnan(etuds_moy_module[ue2.id][etudid])
-    assert np.isnan(etud_moy_module[ue3.id][etudid])
+    assert np.isnan(etuds_moy_module[ue3.id][etudid])
     # --- Barème sur 37
     evaluation2.note_max = 37.0
     note1, note2 = 11.0, 12.0
     note_2_37 = note2 / 20 * 37
-    etud_moy_module = change_notes(note1, note_2_37)
+    etuds_moy_module = change_notes(note1, note_2_37)
-    moy_ue1 = etud_moy_module[ue1.id][etudid]
+    moy_ue1 = etuds_moy_module[ue1.id][etudid]
     assert moy_ue1 == ((note1 * e1p1 * coef_e1) + (note2 * e2p1 * coef_e2)) / sum_copo1
-    moy_ue2 = etud_moy_module[ue2.id][etudid]
+    moy_ue2 = etuds_moy_module[ue2.id][etudid]
     assert moy_ue2 == ((note1 * e1p2 * coef_e1) + (note2 * e2p2 * coef_e2)) / sum_copo2
-    moy_ue3 = etud_moy_module[ue3.id][etudid]
+    moy_ue3 = etuds_moy_module[ue3.id][etudid]
     assert np.isnan(moy_ue3)  # car les poids vers UE3 sont nuls