ScoDoc-PE/tests/unit/test_but_modules.py

"""
Test modèles évaluations avec poids BUT
"""
import numpy as np
import pandas as pd
from app.models.etudiants import Identite

from tests.unit import sco_fake_gen
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.sco_utils import NOTES_ATTENTE, NOTES_NEUTRALISE

"""
mapp.set_sco_dept("RT")
from app.auth.models import get_super_admin
admin_user = get_super_admin()
ctx.push()
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()
    sem = G.create_formsemestre(
        formation_id=formation_id,
        semestre_id=1,
        date_debut="01/01/2021",
        date_fin="30/06/2021",
    )  # formsemestre_id=716
    mi = G.create_moduleimpl(
        module_id=module_id,
        formsemestre_id=sem["formsemestre_id"],
    )
    moduleimpl_id = mi["id"]
    _e1 = G.create_evaluation(
        moduleimpl_id=moduleimpl_id,
        jour="01/01/2021",
        description="evaluation 1",
        coefficient=0,
    )
    evaluation_id = _e1["evaluation_id"]  # evaluation_id=25246
    # ue1_id=1684
    # formation_id=199
    #
    e1 = models.Evaluation.query.get(evaluation_id)
    ue1 = models.UniteEns.query.get(ue1_id)
    assert e1.ue_poids == []
    p1 = 3.14
    e1.set_ue_poids(ue1, p1)
    db.session.commit()
    assert e1.get_ue_poids_dict()[ue1_id] == p1
    ues = models.UniteEns.query.filter_by(
        formation_id=formation_id, semestre_idx=2
    ).all()
    poids = [1.0, 2.0, 3.0]
    for (ue, p) in zip(ues, poids):
        e1.set_ue_poids(ue, p)
    assert len(e1.ue_poids) == len(ues)
    assert e1.get_ue_poids_dict()[ues[1].id] == poids[1]
    e1.set_ue_poids(ue1, p1)
    db.session.commit()
    poids2 = [10, 20]
    e1.update_ue_poids_dict({ue.id: p for (ue, p) in zip(ues[:-1], poids2)})
    assert e1.get_ue_poids_dict()[ues[0].id] == poids2[0]
    assert e1.get_ue_poids_dict()[ues[1].id] == poids2[1]
    assert e1.get_ue_poids_dict()[ues[2].id] == poids[2]
    # Delete UE
    db.session.delete(ues[2])
    db.session.commit()
    # Delete eval
    db.session.delete(e1)
    db.session.commit()
    assert len(models.EvaluationUEPoids.query.all()) == 0


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()
    ue1 = models.UniteEns.query.get(ue1_id)
    ue2 = models.UniteEns.query.get(ue2_id)
    mod = models.Module.query.get(module_id)
    coef = 2.5
    mod.set_ue_coef(ue1, coef)
    db.session.commit()
    assert mod.ue_coefs[0].coef == coef
    mod.set_ue_coef(ue2, 2 * coef)
    db.session.commit()
    assert set(mod.get_ue_coef_dict().values()) == {coef, 2 * coef}
    assert set(mod.get_ue_coef_dict().keys()) == {ue1_id, ue2_id}
    mod.delete_ue_coef(ue1)
    db.session.commit()
    assert len(mod.ue_coefs) == 1
    # Gestion des coefs nuls:
    mod.set_ue_coef(ue2, 0.0)
    db.session.commit()
    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()
    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.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(
        formation_id, semestre_idx
    )
    assert isinstance(modules_coefficients, pd.DataFrame)
    assert modules_coefficients.shape == (nb_ues, nb_mods)
    evals_poids, ues = moy_mod.df_load_evaluations_poids(evaluation.moduleimpl_id)
    assert isinstance(evals_poids, pd.DataFrame)
    assert len(ues) == nb_ues
    assert all(evals_poids.dtypes == np.float64)
    assert evals_poids.shape == (nb_evals, nb_ues)
    assert not moy_mod.check_moduleimpl_conformity(
        evaluation.moduleimpl, evals_poids, modules_coefficients
    )


def test_module_moy_elem(test_client):
    """Vérification calcul moyenne d'un module
    (notes entrées dans un DataFrame sans passer par ScoDoc)
    """
    # Repris du notebook CalculNotesBUT.ipynb
    data = [  # Les notes de chaque étudiant dans les 2 evals:
        {
            "EVAL1": 11.0,
            "EVAL2": 16.0,
        },
        {
            "EVAL1": np.NaN,  # une absence (NaN)
            "EVAL2": 17.0,
        },
        {
            "EVAL1": 13.0,
            "EVAL2": NOTES_NEUTRALISE,  # une abs EXC
        },
        {
            "EVAL1": 14.0,
            "EVAL2": 19.0,
        },
        {
            "EVAL1": NOTES_ATTENTE,  # une ATT (traitée comme EXC)
            "EVAL2": np.NaN,  # et une ABS
        },
    ]
    evals_notes_df = pd.DataFrame(
        data, index=["etud1", "etud2", "etud3", "etud4", "etud5"]
    )
    # Poids des évaluations (1 ligne / évaluation)
    data = [
        {"UE1": 1, "UE2": 0, "UE3": 0},
        {"UE1": 2, "UE2": 5, "UE3": 0},
    ]
    evals_poids_df = pd.DataFrame(data, index=["EVAL1", "EVAL2"], dtype=float)
    evaluations = [
        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(
        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)
    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)
    assert tuple(r.loc["etud4"]) == (17 + 1 / 3, 19, NAN)
    assert tuple(r.loc["etud5"]) == (0.0, 0.0, NAN)
    # note: les notes UE3 sont toutes NAN car les poids vers l'UE3 sont nuls


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()
    etud = G.create_etud(nom="test")
    G.inscrit_etudiant(sem, etud)
    etudid = etud["etudid"]
    evaluation1 = models.Evaluation.query.get(evaluation1_id)
    # Crée une deuxième évaluation dans le même moduleimpl:
    evaluation2_id = G.create_evaluation(
        moduleimpl_id=evaluation1.moduleimpl_id,
        jour="02/01/2021",
        description="evaluation 2",
        coefficient=coef_e2,
    )["evaluation_id"]
    evaluation2 = models.Evaluation.query.get(evaluation2_id)
    # Coefficients de l'eval 1
    evaluation1.coefficient = coef_e1
    # Poids des évaluations:
    e1p1, e1p2, e1p3 = 1.0, 2.0, 0.0  # poids de l'éval 1 vers les UE 1, 2 et 3
    e2p1, e2p2, e2p3 = 0.0, 1.0, 0.0  # poids de l'éval 2 vers les UE
    evaluation1.set_ue_poids_dict({ue1.id: e1p1, ue2.id: e1p2, ue3.id: e1p3})
    evaluation2.set_ue_poids_dict({ue1.id: e2p1, ue2.id: e2p2, ue3.id: e2p3})
    # Vérifications
    moduleimpl_id = evaluation1.moduleimpl_id
    nb_evals = models.Evaluation.query.filter_by(moduleimpl_id=moduleimpl_id).count()
    assert nb_evals == 2
    nb_ues = 3

    # --- Change les notes et recalcule les moyennes du module
    # (rappel: on a deux évaluations: evaluation1, evaluation2, et un seul étudiant)
    def change_notes(n1, n2):
        # Saisie d'une note dans chaque éval
        _ = sco_saisie_notes.notes_add(G.default_user, evaluation1.id, [(etudid, n1)])
        _ = sco_saisie_notes.notes_add(G.default_user, evaluation2.id, [(etudid, n2)])
        # Calcul de la moyenne du module
        evals_poids, ues = moy_mod.df_load_evaluations_poids(moduleimpl_id)
        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(
            evals_notes, evals_poids, evaluations
        )
        return etud_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)
    moy_ue1 = etud_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]
    assert moy_ue2 == ((note1 * e1p2 * coef_e1) + (note2 * e2p2 * coef_e2)) / sum_copo2
    moy_ue3 = etud_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)
    assert etud_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 np.isnan(etud_moy_module[ue3.id][etudid])
    # --- Deux notes ABS
    etud_moy_module = change_notes(None, None)
    assert etud_moy_module[ue1.id][etudid] == 0.0
    assert etud_moy_module[ue2.id][etudid] == 0.0
    assert np.isnan(etud_moy_module[ue3.id][etudid])
    # --- Note EXC
    etud_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 etud_moy_module[ue2.id][etudid] == note2
    assert np.isnan(etud_moy_module[ue3.id][etudid])
    # --- Toutes notes ATT (ATT se traite comme EXC)
    etud_moy_module = change_notes(NOTES_NEUTRALISE, NOTES_NEUTRALISE)
    assert np.isnan(etud_moy_module[ue1.id][etudid])
    assert np.isnan(etud_moy_module[ue2.id][etudid])
    assert np.isnan(etud_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)
    moy_ue1 = etud_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]
    assert moy_ue2 == ((note1 * e1p2 * coef_e1) + (note2 * e2p2 * coef_e2)) / sum_copo2
    moy_ue3 = etud_moy_module[ue3.id][etudid]
    assert np.isnan(moy_ue3)  # car les poids vers UE3 sont nuls