refactoring (context)

app/scodoc/notes_table.py

@@ -107,17 +107,15 @@ def get_sem_ues_modimpls(context, formsemestre_id, modimpls=None):
     (utilisé quand on ne peut pas construire nt et faire nt.get_ues())
     """
     if modimpls is None:
-        modimpls = sco_moduleimpl.do_moduleimpl_list(
+        modimpls = sco_moduleimpl.do_moduleimpl_list(formsemestre_id=formsemestre_id)
-            context, formsemestre_id=formsemestre_id
-        )
     uedict = {}
     for modimpl in modimpls:
-        mod = sco_edit_module.do_module_list(
+        mod = sco_edit_module.do_module_list(args={"module_id": modimpl["module_id"]})[
-            context, args={"module_id": modimpl["module_id"]}
+            0
-        )[0]
+        ]
         modimpl["module"] = mod
         if not mod["ue_id"] in uedict:
-            ue = sco_edit_ue.do_ue_list(context, args={"ue_id": mod["ue_id"]})[0]
+            ue = sco_edit_ue.do_ue_list(args={"ue_id": mod["ue_id"]})[0]
             uedict[ue["ue_id"]] = ue
     ues = list(uedict.values())
     ues.sort(key=lambda u: u["numero"])
@@ -231,14 +229,14 @@ class NotesTable(object):
         for modimpl in self._modimpls:
             mod = modimpl["module"]  # has been added here by do_formsemestre_moyennes
             if not mod["ue_id"] in uedict:
-                ue = sco_edit_ue.do_ue_list(context, args={"ue_id": mod["ue_id"]})[0]
+                ue = sco_edit_ue.do_ue_list(args={"ue_id": mod["ue_id"]})[0]
                 uedict[ue["ue_id"]] = ue
             else:
                 ue = uedict[mod["ue_id"]]
             modimpl["ue"] = ue  # add ue dict to moduleimpl
             self._matmoys[mod["matiere_id"]] = {}
             mat = sco_edit_matiere.do_matiere_list(
-                context, args={"matiere_id": mod["matiere_id"]}
+                args={"matiere_id": mod["matiere_id"]}
             )[0]
             modimpl["mat"] = mat  # add matiere dict to moduleimpl
             # calcul moyennes du module et stocke dans le module

app/scodoc/sco_abs.py

@@ -1061,7 +1061,7 @@ def invalidate_abs_count_sem(sem):
     """Invalidate (clear) cached abs counts for all the students of this semestre"""
     inscriptions = (
         sco_formsemestre_inscriptions.do_formsemestre_inscription_listinscrits(
-            None, sem["formsemestre_id"]
+            sem["formsemestre_id"]
         )
     )
     for ins in inscriptions:

app/scodoc/sco_abs_views.py

@@ -122,7 +122,7 @@ def doSignaleAbsence(
         J = "NON "
     M = ""
     if moduleimpl_id and moduleimpl_id != "NULL":
-        mod = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=moduleimpl_id)[0]
+        mod = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=moduleimpl_id)[0]
         formsemestre_id = mod["formsemestre_id"]
         nt = sco_cache.NotesTableCache.get(formsemestre_id)
         ues = nt.get_ues(etudid=etudid)
@@ -967,7 +967,7 @@ def _TablesAbsEtud(
         ex = []
         for ev in a["evals"]:
             mod = sco_moduleimpl.do_moduleimpl_withmodule_list(
-                context, moduleimpl_id=ev["moduleimpl_id"]
+                moduleimpl_id=ev["moduleimpl_id"]
             )[0]
             if format == "html":
                 ex.append(
@@ -984,7 +984,7 @@ def _TablesAbsEtud(
         ex = []
         for ev in a.get("absent", []):
             mod = sco_moduleimpl.do_moduleimpl_withmodule_list(
-                context, moduleimpl_id=ev["moduleimpl_id"]
+                moduleimpl_id=ev["moduleimpl_id"]
             )[0]
             if format == "html":
                 ex.append(

app/scodoc/sco_bulletins_json.py

@@ -372,7 +372,7 @@ def formsemestre_bulletinetud_published_dict(
                 "decisions_ue"
             ]:  # and sco_preferences.get_preference( 'bul_show_uevalid', formsemestre_id): always publish (car utile pour export Apogee)
                 for ue_id in decision["decisions_ue"].keys():
-                    ue = sco_edit_ue.do_ue_list(context, {"ue_id": ue_id})[0]
+                    ue = sco_edit_ue.do_ue_list({"ue_id": ue_id})[0]
                     d["decision_ue"].append(
                         dict(
                             ue_id=ue["ue_id"],

app/scodoc/sco_bulletins_xml.py

@@ -390,7 +390,7 @@ def make_xml_formsemestre_bulletinetud(
                 "decisions_ue"
             ]:  # and sco_preferences.get_preference( 'bul_show_uevalid', formsemestre_id): always publish (car utile pour export Apogee)
                 for ue_id in decision["decisions_ue"].keys():
-                    ue = sco_edit_ue.do_ue_list(context, {"ue_id": ue_id})[0]
+                    ue = sco_edit_ue.do_ue_list({"ue_id": ue_id})[0]
                     doc.append(
                         Element(
                             "decision_ue",

app/scodoc/sco_cache.py

@@ -264,7 +264,7 @@ def invalidate_formsemestre(  # was inval_cache( context, formsemestre_id=None,
     else:
         formsemestre_ids = [
             formsemestre_id
-        ] + sco_parcours_dut.list_formsemestre_utilisateurs_uecap(None, formsemestre_id)
+        ] + sco_parcours_dut.list_formsemestre_utilisateurs_uecap(formsemestre_id)
         log(f"----- invalidate_formsemestre: clearing {formsemestre_ids} -----")
 
     if not pdfonly:

app/scodoc/sco_compute_moy.py

@@ -79,9 +79,7 @@ def formsemestre_expressions_use_abscounts(context, formsemestre_id):
         if expr and expr[0] != "#" and ab in expr:
             return True
     # 2- moyennes de modules
-    for mod in sco_moduleimpl.do_moduleimpl_list(
+    for mod in sco_moduleimpl.do_moduleimpl_list(formsemestre_id=formsemestre_id):
-        context, formsemestre_id=formsemestre_id
-    ):
         if moduleimpl_has_expression(context, mod) and ab in mod["computation_expr"]:
             return True
     return False
@@ -203,7 +201,7 @@ def do_moduleimpl_moyennes(context, nt, mod):
     is_malus = mod["module"]["module_type"] == scu.MODULE_MALUS
     sem = sco_formsemestre.get_formsemestre(mod["formsemestre_id"])
     etudids = sco_moduleimpl.do_moduleimpl_listeetuds(
-        context, moduleimpl_id
+        moduleimpl_id
     )  # tous, y compris demissions
     # Inscrits au semestre (pour traiter les demissions):
     inssem_set = set(
@@ -379,9 +377,7 @@ def do_formsemestre_moyennes(context, nt, formsemestre_id):
     #    args={"formsemestre_id": formsemestre_id}
     # )
     # etudids = [x["etudid"] for x in inscr]
-    modimpls = sco_moduleimpl.do_moduleimpl_list(
+    modimpls = sco_moduleimpl.do_moduleimpl_list(formsemestre_id=formsemestre_id)
-        context, formsemestre_id=formsemestre_id
-    )
     # recupere les moyennes des etudiants de tous les modules
     D = {}
     valid_evals = []
@@ -389,9 +385,9 @@ def do_formsemestre_moyennes(context, nt, formsemestre_id):
     mods_att = []
     expr_diags = []
     for modimpl in modimpls:
-        mod = sco_edit_module.do_module_list(
+        mod = sco_edit_module.do_module_list(args={"module_id": modimpl["module_id"]})[
-            context, args={"module_id": modimpl["module_id"]}
+            0
-        )[0]
+        ]
         modimpl["module"] = mod  # add module dict to moduleimpl (used by nt)
         moduleimpl_id = modimpl["moduleimpl_id"]
         assert moduleimpl_id not in D

app/scodoc/sco_cost_formation.py

@@ -60,7 +60,7 @@ def formsemestre_table_estim_cost(
     sem = sco_formsemestre.get_formsemestre(formsemestre_id)
     sco_formsemestre_status.fill_formsemestre(sem)
     Mlist = sco_moduleimpl.do_moduleimpl_withmodule_list(
-        context, formsemestre_id=formsemestre_id
+        formsemestre_id=formsemestre_id
     )
     T = []
     for M in Mlist:

app/scodoc/sco_debouche.py

@@ -64,7 +64,6 @@ def report_debouche_date(context, start_year=None, format="html", REQUEST=None):
     tab.caption = "Récapitulatif débouchés à partir du 1/1/%s." % start_year
     tab.base_url = "%s?start_year=%s" % (REQUEST.URL0, start_year)
     return tab.make_page(
-        context,
         title="""<h2 class="formsemestre">Débouchés étudiants </h2>""",
         init_qtip=True,
         javascripts=["js/etud_info.js"],

app/scodoc/sco_edit_formation.py

@@ -47,7 +47,7 @@ from app.scodoc import sco_formsemestre
 from app.scodoc import sco_news
 
 
-def formation_delete(context, formation_id=None, dialog_confirmed=False, REQUEST=None):
+def formation_delete(formation_id=None, dialog_confirmed=False, REQUEST=None):
     """Delete a formation"""
     F = sco_formations.formation_list(args={"formation_id": formation_id})
     if not F:
@@ -84,7 +84,7 @@ def formation_delete(context, formation_id=None, dialog_confirmed=False, REQUEST
                 parameters={"formation_id": formation_id},
             )
         else:
-            do_formation_delete(context, F["formation_id"])
+            do_formation_delete(F["formation_id"])
             H.append(
                 """<p>OK, formation supprimée.</p>
     <p><a class="stdlink" href="%s">continuer</a></p>"""
@@ -95,18 +95,18 @@ def formation_delete(context, formation_id=None, dialog_confirmed=False, REQUEST
     return "\n".join(H)
 
 
-def do_formation_delete(context, oid):
+def do_formation_delete(oid):
     """delete a formation (and all its UE, matieres, modules)
     XXX delete all ues, will break if there are validations ! USE WITH CARE !
     """
     F = sco_formations.formation_list(args={"formation_id": oid})[0]
-    if sco_formations.formation_has_locked_sems(context, oid):
+    if sco_formations.formation_has_locked_sems(oid):
         raise ScoLockedFormError()
     cnx = ndb.GetDBConnexion()
     # delete all UE in this formation
-    ues = sco_edit_ue.do_ue_list(context, {"formation_id": oid})
+    ues = sco_edit_ue.do_ue_list({"formation_id": oid})
     for ue in ues:
-        sco_edit_ue.do_ue_delete(context, ue["ue_id"], force=True)
+        sco_edit_ue.do_ue_delete(ue["ue_id"], force=True)
 
     sco_formations._formationEditor.delete(cnx, oid)
 
@@ -119,12 +119,12 @@ def do_formation_delete(context, oid):
     )
 
 
-def formation_create(context, REQUEST=None):
+def formation_create(REQUEST=None):
     """Creation d'une formation"""
-    return formation_edit(context, create=True, REQUEST=REQUEST)
+    return formation_edit(create=True, REQUEST=REQUEST)
 
 
-def formation_edit(context, formation_id=None, create=False, REQUEST=None):
+def formation_edit(formation_id=None, create=False, REQUEST=None):
     """Edit or create a formation"""
     if create:
         H = [
@@ -147,7 +147,7 @@ def formation_edit(context, formation_id=None, create=False, REQUEST=None):
         if not F:
             raise ScoValueError("formation inexistante !")
         initvalues = F[0]
-        is_locked = sco_formations.formation_has_locked_sems(context, formation_id)
+        is_locked = sco_formations.formation_has_locked_sems(formation_id)
         submitlabel = "Modifier les valeurs"
         H = [
             html_sco_header.sco_header(page_title="Modification d'une formation"),
@@ -247,9 +247,9 @@ def formation_edit(context, formation_id=None, create=False, REQUEST=None):
             )
         #
         if create:
-            formation_id = do_formation_create(context, tf[2])
+            formation_id = do_formation_create(tf[2])
         else:
-            do_formation_edit(context, tf[2])
+            do_formation_edit(tf[2])
         return flask.redirect(
             url_for(
                 "notes.ue_list", scodoc_dept=g.scodoc_dept, formation_id=formation_id
@@ -257,7 +257,7 @@ def formation_edit(context, formation_id=None, create=False, REQUEST=None):
         )
 
 
-def do_formation_create(context, args):
+def do_formation_create(args):
     "create a formation"
     cnx = ndb.GetDBConnexion()
     # check unique acronyme/titre/version
@@ -282,14 +282,14 @@ def do_formation_create(context, args):
     return r
 
 
-def do_formation_edit(context, args):
+def do_formation_edit(args):
     "edit a formation"
     # log('do_formation_edit( args=%s )'%args)
 
     # On autorise  la modif de la formation meme si elle est verrouillee
     # car cela ne change que du cosmetique, (sauf eventuellement le code formation ?)
     # mais si verrouillée on ne peut changer le type de parcours
-    if sco_formations.formation_has_locked_sems(context, args["formation_id"]):
+    if sco_formations.formation_has_locked_sems(args["formation_id"]):
         if "type_parcours" in args:
             del args["type_parcours"]
     # On ne peut jamais supprimer le code formation:
@@ -311,17 +311,15 @@ def invalidate_sems_in_formation(formation_id):
         )  # > formation modif.
 
 
-def module_move(context, module_id, after=0, REQUEST=None, redirect=1):
+def module_move(module_id, after=0, REQUEST=None, redirect=1):
     """Move before/after previous one (decrement/increment numero)"""
-    module = sco_edit_module.do_module_list(context, {"module_id": module_id})[0]
+    module = sco_edit_module.do_module_list({"module_id": module_id})[0]
     redirect = int(redirect)
     after = int(after)  # 0: deplace avant, 1 deplace apres
     if after not in (0, 1):
         raise ValueError('invalid value for "after"')
     formation_id = module["formation_id"]
-    others = sco_edit_module.do_module_list(
+    others = sco_edit_module.do_module_list({"matiere_id": module["matiere_id"]})
-        context, {"matiere_id": module["matiere_id"]}
-    )
     # log('others=%s' % others)
     if len(others) > 1:
         idx = [p["module_id"] for p in others].index(module_id)
@@ -350,16 +348,16 @@ def module_move(context, module_id, after=0, REQUEST=None, redirect=1):
         )
 
 
-def ue_move(context, ue_id, after=0, REQUEST=None, redirect=1):
+def ue_move(ue_id, after=0, REQUEST=None, redirect=1):
     """Move UE before/after previous one (decrement/increment numero)"""
-    o = sco_edit_ue.do_ue_list(context, {"ue_id": ue_id})[0]
+    o = sco_edit_ue.do_ue_list({"ue_id": ue_id})[0]
     # log('ue_move %s (#%s) after=%s' % (ue_id, o['numero'], after))
     redirect = int(redirect)
     after = int(after)  # 0: deplace avant, 1 deplace apres
     if after not in (0, 1):
         raise ValueError('invalid value for "after"')
     formation_id = o["formation_id"]
-    others = sco_edit_ue.do_ue_list(context, {"formation_id": formation_id})
+    others = sco_edit_ue.do_ue_list({"formation_id": formation_id})
     if len(others) > 1:
         idx = [p["ue_id"] for p in others].index(ue_id)
         neigh = None  # object to swap with

app/scodoc/sco_edit_matiere.py

@@ -47,31 +47,29 @@ _matiereEditor = ndb.EditableTable(
 )
 
 
-def do_matiere_list(context, *args, **kw):
+def do_matiere_list(*args, **kw):
     "list matieres"
     cnx = ndb.GetDBConnexion()
     return _matiereEditor.list(cnx, *args, **kw)
 
 
-def do_matiere_edit(context, *args, **kw):
+def do_matiere_edit(*args, **kw):
     "edit a matiere"
     from app.scodoc import sco_edit_ue
     from app.scodoc import sco_edit_formation
 
     cnx = ndb.GetDBConnexion()
     # check
-    mat = do_matiere_list(context, {"matiere_id": args[0]["matiere_id"]})[0]
+    mat = do_matiere_list({"matiere_id": args[0]["matiere_id"]})[0]
-    if matiere_is_locked(context, mat["matiere_id"]):
+    if matiere_is_locked(mat["matiere_id"]):
         raise ScoLockedFormError()
     # edit
     _matiereEditor.edit(cnx, *args, **kw)
-    formation_id = sco_edit_ue.do_ue_list(None, {"ue_id": mat["ue_id"]})[0][
+    formation_id = sco_edit_ue.do_ue_list({"ue_id": mat["ue_id"]})[0]["formation_id"]
-        "formation_id"
-    ]
     sco_edit_formation.invalidate_sems_in_formation(formation_id)
 
 
-def do_matiere_create(context, args):
+def do_matiere_create(args):
     "create a matiere"
     from app.scodoc import sco_edit_ue
     from app.scodoc import sco_formations
@@ -79,7 +77,7 @@ def do_matiere_create(context, args):
 
     cnx = ndb.GetDBConnexion()
     # check
-    ue = sco_edit_ue.do_ue_list(context, {"ue_id": args["ue_id"]})[0]
+    ue = sco_edit_ue.do_ue_list({"ue_id": args["ue_id"]})[0]
     # create matiere
     r = _matiereEditor.create(cnx, args)
 
@@ -94,11 +92,11 @@ def do_matiere_create(context, args):
     return r
 
 
-def matiere_create(context, ue_id=None, REQUEST=None):
+def matiere_create(ue_id=None, REQUEST=None):
     """Creation d'une matiere"""
     from app.scodoc import sco_edit_ue
 
-    UE = sco_edit_ue.do_ue_list(context, args={"ue_id": ue_id})[0]
+    UE = sco_edit_ue.do_ue_list(args={"ue_id": ue_id})[0]
     H = [
         html_sco_header.sco_header(page_title="Création d'une matière"),
         """<h2>Création d'une matière dans l'UE %(titre)s (%(acronyme)s)</h2>""" % UE,
@@ -145,7 +143,7 @@ associé.
         return flask.redirect(dest_url)
     else:
         # check unicity
-        mats = do_matiere_list(context, args={"ue_id": ue_id, "titre": tf[2]["titre"]})
+        mats = do_matiere_list(args={"ue_id": ue_id, "titre": tf[2]["titre"]})
         if mats:
             return (
                 "\n".join(H)
@@ -153,11 +151,11 @@ associé.
                 + tf[1]
                 + html_sco_header.sco_footer()
             )
-        _ = do_matiere_create(context, tf[2])
+        _ = do_matiere_create(tf[2])
         return flask.redirect(dest_url)
 
 
-def do_matiere_delete(context, oid):
+def do_matiere_delete(oid):
     "delete matiere and attached modules"
     from app.scodoc import sco_formations
     from app.scodoc import sco_edit_ue
@@ -166,9 +164,9 @@ def do_matiere_delete(context, oid):
 
     cnx = ndb.GetDBConnexion()
     # check
-    mat = do_matiere_list(context, {"matiere_id": oid})[0]
+    mat = do_matiere_list({"matiere_id": oid})[0]
-    ue = sco_edit_ue.do_ue_list(context, {"ue_id": mat["ue_id"]})[0]
+    ue = sco_edit_ue.do_ue_list({"ue_id": mat["ue_id"]})[0]
-    locked = matiere_is_locked(context, mat["matiere_id"])
+    locked = matiere_is_locked(mat["matiere_id"])
     if locked:
         log("do_matiere_delete: mat=%s" % mat)
         log("do_matiere_delete: ue=%s" % ue)
@@ -176,9 +174,9 @@ def do_matiere_delete(context, oid):
         raise ScoLockedFormError()
     log("do_matiere_delete: matiere_id=%s" % oid)
     # delete all modules in this matiere
-    mods = sco_edit_module.do_module_list(context, {"matiere_id": oid})
+    mods = sco_edit_module.do_module_list({"matiere_id": oid})
     for mod in mods:
-        sco_edit_module.do_module_delete(context, mod["module_id"])
+        sco_edit_module.do_module_delete(mod["module_id"])
     _matiereEditor.delete(cnx, oid)
 
     # news
@@ -191,12 +189,12 @@ def do_matiere_delete(context, oid):
     )
 
 
-def matiere_delete(context, matiere_id=None, REQUEST=None):
+def matiere_delete(matiere_id=None, REQUEST=None):
     """Delete an UE"""
     from app.scodoc import sco_edit_ue
 
-    M = do_matiere_list(context, args={"matiere_id": matiere_id})[0]
+    M = do_matiere_list(args={"matiere_id": matiere_id})[0]
-    UE = sco_edit_ue.do_ue_list(context, args={"ue_id": M["ue_id"]})[0]
+    UE = sco_edit_ue.do_ue_list(args={"ue_id": M["ue_id"]})[0]
     H = [
         html_sco_header.sco_header(page_title="Suppression d'une matière"),
         "<h2>Suppression de la matière %(titre)s" % M,
@@ -216,26 +214,26 @@ def matiere_delete(context, matiere_id=None, REQUEST=None):
     elif tf[0] == -1:
         return flask.redirect(dest_url)
     else:
-        do_matiere_delete(context, matiere_id)
+        do_matiere_delete(matiere_id)
         return flask.redirect(dest_url)
 
 
-def matiere_edit(context, matiere_id=None, REQUEST=None):
+def matiere_edit(matiere_id=None, REQUEST=None):
     """Edit matiere"""
     from app.scodoc import sco_formations
     from app.scodoc import sco_edit_ue
 
-    F = do_matiere_list(context, args={"matiere_id": matiere_id})
+    F = do_matiere_list(args={"matiere_id": matiere_id})
     if not F:
         raise ScoValueError("Matière inexistante !")
     F = F[0]
-    U = sco_edit_ue.do_ue_list(context, args={"ue_id": F["ue_id"]})
+    U = sco_edit_ue.do_ue_list(args={"ue_id": F["ue_id"]})
     if not F:
         raise ScoValueError("UE inexistante !")
     U = U[0]
     Fo = sco_formations.formation_list(args={"formation_id": U["formation_id"]})[0]
 
-    ues = sco_edit_ue.do_ue_list(context, args={"formation_id": U["formation_id"]})
+    ues = sco_edit_ue.do_ue_list(args={"formation_id": U["formation_id"]})
     ue_names = ["%(acronyme)s (%(titre)s)" % u for u in ues]
     ue_ids = [u["ue_id"] for u in ues]
     H = [
@@ -288,9 +286,7 @@ associé.
         return flask.redirect(dest_url)
     else:
         # check unicity
-        mats = do_matiere_list(
+        mats = do_matiere_list(args={"ue_id": tf[2]["ue_id"], "titre": tf[2]["titre"]})
-            context, args={"ue_id": tf[2]["ue_id"], "titre": tf[2]["titre"]}
-        )
         if len(mats) > 1 or (len(mats) == 1 and mats[0]["matiere_id"] != matiere_id):
             return (
                 "\n".join(H)
@@ -307,12 +303,12 @@ associé.
                 {"ue_id": tf[2]["ue_id"], "matiere_id": matiere_id},
             )
 
-        do_matiere_edit(context, tf[2])
+        do_matiere_edit(tf[2])
 
         return flask.redirect(dest_url)
 
 
-def matiere_is_locked(context, matiere_id):
+def matiere_is_locked(matiere_id):
     """True if matiere should not be modified
     (contains modules used in a locked formsemestre)
     """

app/scodoc/sco_edit_module.py

@@ -93,13 +93,13 @@ _moduleEditor = ndb.EditableTable(
 )
 
 
-def do_module_list(context, *args, **kw):
+def do_module_list(*args, **kw):
     "list modules"
     cnx = ndb.GetDBConnexion()
     return _moduleEditor.list(cnx, *args, **kw)
 
 
-def do_module_create(context, args) -> int:
+def do_module_create(args) -> int:
     "create a module"
     # create
     from app.scodoc import sco_formations
@@ -118,15 +118,15 @@ def do_module_create(context, args) -> int:
     return r
 
 
-def module_create(context, matiere_id=None, REQUEST=None):
+def module_create(matiere_id=None, REQUEST=None):
     """Creation d'un module"""
     from app.scodoc import sco_formations
     from app.scodoc import sco_edit_ue
 
     if matiere_id is None:
         raise ScoValueError("invalid matiere !")
-    M = sco_edit_matiere.do_matiere_list(context, args={"matiere_id": matiere_id})[0]
+    M = sco_edit_matiere.do_matiere_list(args={"matiere_id": matiere_id})[0]
-    UE = sco_edit_ue.do_ue_list(context, args={"ue_id": M["ue_id"]})[0]
+    UE = sco_edit_ue.do_ue_list(args={"ue_id": M["ue_id"]})[0]
     Fo = sco_formations.formation_list(args={"formation_id": UE["formation_id"]})[0]
     parcours = sco_codes_parcours.get_parcours_from_code(Fo["type_parcours"])
     semestres_indices = list(range(1, parcours.NB_SEM + 1))
@@ -137,7 +137,7 @@ def module_create(context, matiere_id=None, REQUEST=None):
         _MODULE_HELP,
     ]
     # cherche le numero adequat (pour placer le module en fin de liste)
-    Mods = do_module_list(context, args={"matiere_id": matiere_id})
+    Mods = do_module_list(args={"matiere_id": matiere_id})
     if Mods:
         default_num = max([m["numero"] for m in Mods]) + 10
     else:
@@ -154,7 +154,7 @@ def module_create(context, matiere_id=None, REQUEST=None):
                     "allow_null": False,
                     "validator": lambda val, field, formation_id=Fo[
                         "formation_id"
-                    ]: check_module_code_unicity(val, field, formation_id, context),
+                    ]: check_module_code_unicity(val, field, formation_id),
                 },
             ),
             ("titre", {"size": 30, "explanation": "nom du module"}),
@@ -237,7 +237,7 @@ def module_create(context, matiere_id=None, REQUEST=None):
     if tf[0] == 0:
         return "\n".join(H) + tf[1] + html_sco_header.sco_footer()
     else:
-        do_module_create(context, tf[2])
+        do_module_create(tf[2])
         return flask.redirect(
             url_for(
                 "notes.ue_list",
@@ -247,16 +247,16 @@ def module_create(context, matiere_id=None, REQUEST=None):
         )
 
 
-def do_module_delete(context, oid):
+def do_module_delete(oid):
     "delete module"
     from app.scodoc import sco_formations
 
-    mod = do_module_list(context, {"module_id": oid})[0]
+    mod = do_module_list({"module_id": oid})[0]
-    if module_is_locked(context, mod["module_id"]):
+    if module_is_locked(mod["module_id"]):
         raise ScoLockedFormError()
 
     # S'il y a des moduleimpls, on ne peut pas detruire le module !
-    mods = sco_moduleimpl.do_moduleimpl_list(context, module_id=oid)
+    mods = sco_moduleimpl.do_moduleimpl_list(module_id=oid)
     if mods:
         err_page = scu.confirm_dialog(
             message="""<h3>Destruction du module impossible car il est utilisé dans des semestres existants !</h3>""",
@@ -279,11 +279,11 @@ def do_module_delete(context, oid):
     )
 
 
-def module_delete(context, module_id=None, REQUEST=None):
+def module_delete(module_id=None, REQUEST=None):
     """Delete a module"""
     if not module_id:
         raise ScoValueError("invalid module !")
-    Mods = do_module_list(context, args={"module_id": module_id})
+    Mods = do_module_list(args={"module_id": module_id})
     if not Mods:
         raise ScoValueError("Module inexistant !")
     Mod = Mods[0]
@@ -306,17 +306,17 @@ def module_delete(context, module_id=None, REQUEST=None):
     elif tf[0] == -1:
         return flask.redirect(dest_url)
     else:
-        do_module_delete(context, module_id)
+        do_module_delete(module_id)
         return flask.redirect(dest_url)
 
 
-def do_module_edit(context, val):
+def do_module_edit(val):
     "edit a module"
     from app.scodoc import sco_edit_formation
 
     # check
-    mod = do_module_list(context, {"module_id": val["module_id"]})[0]
+    mod = do_module_list({"module_id": val["module_id"]})[0]
-    if module_is_locked(context, mod["module_id"]):
+    if module_is_locked(mod["module_id"]):
         # formation verrouillée: empeche de modifier certains champs:
         protected_fields = ("coefficient", "ue_id", "matiere_id", "semestre_id")
         for f in protected_fields:
@@ -328,27 +328,27 @@ def do_module_edit(context, val):
     sco_edit_formation.invalidate_sems_in_formation(mod["formation_id"])
 
 
-def check_module_code_unicity(code, field, formation_id, context, module_id=None):
+def check_module_code_unicity(code, field, formation_id, module_id=None):
     "true si code module unique dans la formation"
-    Mods = do_module_list(context, args={"code": code, "formation_id": formation_id})
+    Mods = do_module_list(args={"code": code, "formation_id": formation_id})
     if module_id:  # edition: supprime le module en cours
         Mods = [m for m in Mods if m["module_id"] != module_id]
 
     return len(Mods) == 0
 
 
-def module_edit(context, module_id=None, REQUEST=None):
+def module_edit(module_id=None, REQUEST=None):
     """Edit a module"""
     from app.scodoc import sco_formations
     from app.scodoc import sco_tag_module
 
     if not module_id:
         raise ScoValueError("invalid module !")
-    Mod = do_module_list(context, args={"module_id": module_id})
+    Mod = do_module_list(args={"module_id": module_id})
     if not Mod:
         raise ScoValueError("invalid module !")
     Mod = Mod[0]
-    unlocked = not module_is_locked(context, module_id)
+    unlocked = not module_is_locked(module_id)
     Fo = sco_formations.formation_list(args={"formation_id": Mod["formation_id"]})[0]
     parcours = sco_codes_parcours.get_parcours_from_code(Fo["type_parcours"])
     M = ndb.SimpleDictFetch(
@@ -400,7 +400,7 @@ def module_edit(context, module_id=None, REQUEST=None):
                     "validator": lambda val, field, formation_id=Mod[
                         "formation_id"
                     ]: check_module_code_unicity(
-                        val, field, formation_id, context, module_id=module_id
+                        val, field, formation_id, module_id=module_id
                     ),
                 },
             ),
@@ -493,7 +493,7 @@ def module_edit(context, module_id=None, REQUEST=None):
             ),
         ),
         html_foot_markup="""<div style="width: 90%;"><span class="sco_tag_edit"><textarea data-module_id="{}" class="module_tag_editor">{}</textarea></span></div>""".format(
-            module_id, ",".join(sco_tag_module.module_tag_list(context, module_id))
+            module_id, ",".join(sco_tag_module.module_tag_list(module_id))
         ),
         initvalues=Mod,
         submitlabel="Modifier ce module",
@@ -508,28 +508,28 @@ def module_edit(context, module_id=None, REQUEST=None):
         tf[2]["ue_id"], tf[2]["matiere_id"] = tf[2]["ue_matiere_id"].split("!")
         # Check unicité code module dans la formation
 
-        do_module_edit(context, tf[2])
+        do_module_edit(tf[2])
         return flask.redirect(dest_url)
 
 
 # Edition en ligne du code Apogee
-def edit_module_set_code_apogee(context, id=None, value=None, REQUEST=None):
+def edit_module_set_code_apogee(id=None, value=None, REQUEST=None):
     "Set UE code apogee"
     module_id = id
     value = value.strip("-_ \t")
     log("edit_module_set_code_apogee: module_id=%s code_apogee=%s" % (module_id, value))
 
-    modules = do_module_list(context, args={"module_id": module_id})
+    modules = do_module_list(args={"module_id": module_id})
     if not modules:
         return "module invalide"  # should not occur
 
-    do_module_edit(context, {"module_id": module_id, "code_apogee": value})
+    do_module_edit({"module_id": module_id, "code_apogee": value})
     if not value:
         value = scu.APO_MISSING_CODE_STR
     return value
 
 
-def module_list(context, formation_id, REQUEST=None):
+def module_list(formation_id, REQUEST=None):
     """Liste des modules de la formation
     (XXX inutile ou a revoir)
     """
@@ -546,7 +546,7 @@ def module_list(context, formation_id, REQUEST=None):
     ]
     editable = REQUEST.AUTHENTICATED_USER.has_permission(Permission.ScoChangeFormation)
 
-    for Mod in do_module_list(context, args={"formation_id": formation_id}):
+    for Mod in do_module_list(args={"formation_id": formation_id}):
         H.append('<li class="notes_module_list">%s' % Mod)
         if editable:
             H.append('<a href="module_edit?module_id=%(module_id)s">modifier</a>' % Mod)
@@ -559,7 +559,7 @@ def module_list(context, formation_id, REQUEST=None):
     return "\n".join(H)
 
 
-def module_is_locked(context, module_id):
+def module_is_locked(module_id):
     """True if module should not be modified
     (used in a locked formsemestre)
     """
@@ -576,39 +576,39 @@ def module_is_locked(context, module_id):
     return len(r) > 0
 
 
-def module_count_moduleimpls(context, module_id):
+def module_count_moduleimpls(module_id):
     "Number of moduleimpls using this module"
-    mods = sco_moduleimpl.do_moduleimpl_list(context, module_id=module_id)
+    mods = sco_moduleimpl.do_moduleimpl_list(module_id=module_id)
     return len(mods)
 
 
-def formation_add_malus_modules(context, formation_id, titre=None, REQUEST=None):
+def formation_add_malus_modules(formation_id, titre=None, REQUEST=None):
     """Création d'un module de "malus" dans chaque UE d'une formation"""
     from app.scodoc import sco_edit_ue
 
-    ue_list = sco_edit_ue.do_ue_list(context, args={"formation_id": formation_id})
+    ue_list = sco_edit_ue.do_ue_list(args={"formation_id": formation_id})
 
     for ue in ue_list:
         # Un seul module de malus par UE:
         nb_mod_malus = len(
             [
                 mod
-                for mod in do_module_list(context, args={"ue_id": ue["ue_id"]})
+                for mod in do_module_list(args={"ue_id": ue["ue_id"]})
                 if mod["module_type"] == scu.MODULE_MALUS
             ]
         )
         if nb_mod_malus == 0:
-            ue_add_malus_module(context, ue["ue_id"], titre=titre, REQUEST=REQUEST)
+            ue_add_malus_module(ue["ue_id"], titre=titre, REQUEST=REQUEST)
 
     if REQUEST:
         return flask.redirect("ue_list?formation_id=" + str(formation_id))
 
 
-def ue_add_malus_module(context, ue_id, titre=None, code=None, REQUEST=None):
+def ue_add_malus_module(ue_id, titre=None, code=None, REQUEST=None):
     """Add a malus module in this ue"""
     from app.scodoc import sco_edit_ue
 
-    ue = sco_edit_ue.do_ue_list(context, args={"ue_id": ue_id})[0]
+    ue = sco_edit_ue.do_ue_list(args={"ue_id": ue_id})[0]
 
     if titre is None:
         titre = ""
@@ -616,7 +616,7 @@ def ue_add_malus_module(context, ue_id, titre=None, code=None, REQUEST=None):
         code = "MALUS%d" % ue["numero"]
 
     # Tout module doit avoir un semestre_id (indice 1, 2, ...)
-    semestre_ids = sco_edit_ue.ue_list_semestre_ids(context, ue)
+    semestre_ids = sco_edit_ue.ue_list_semestre_ids(ue)
     if semestre_ids:
         semestre_id = semestre_ids[0]
     else:
@@ -627,14 +627,13 @@ def ue_add_malus_module(context, ue_id, titre=None, code=None, REQUEST=None):
         )
 
     # Matiere pour placer le module malus
-    Matlist = sco_edit_matiere.do_matiere_list(context, args={"ue_id": ue_id})
+    Matlist = sco_edit_matiere.do_matiere_list(args={"ue_id": ue_id})
     numero = max([mat["numero"] for mat in Matlist]) + 10
     matiere_id = sco_edit_matiere.do_matiere_create(
-        context, {"ue_id": ue_id, "titre": "Malus", "numero": numero}
+        {"ue_id": ue_id, "titre": "Malus", "numero": numero}
     )
 
     module_id = do_module_create(
-        context,
         {
             "titre": titre,
             "code": code,

app/scodoc/sco_edit_ue.py

@@ -84,20 +84,20 @@ _ueEditor = ndb.EditableTable(
 )
 
 
-def do_ue_list(context, *args, **kw):
+def do_ue_list(*args, **kw):
     "list UEs"
     cnx = ndb.GetDBConnexion()
     return _ueEditor.list(cnx, *args, **kw)
 
 
-def do_ue_create(context, args):
+def do_ue_create(args):
     "create an ue"
     from app.scodoc import sco_formations
 
     cnx = ndb.GetDBConnexion()
     # check duplicates
     ues = do_ue_list(
-        context, {"formation_id": args["formation_id"], "acronyme": args["acronyme"]}
+        {"formation_id": args["formation_id"], "acronyme": args["acronyme"]}
     )
     if ues:
         raise ScoValueError('Acronyme d\'UE "%s" déjà utilisé !' % args["acronyme"])
@@ -115,7 +115,7 @@ def do_ue_create(context, args):
     return r
 
 
-def do_ue_delete(context, ue_id, delete_validations=False, REQUEST=None, force=False):
+def do_ue_delete(ue_id, delete_validations=False, REQUEST=None, force=False):
     "delete UE and attached matieres (but not modules)"
     from app.scodoc import sco_formations
     from app.scodoc import sco_parcours_dut
@@ -123,11 +123,11 @@ def do_ue_delete(context, ue_id, delete_validations=False, REQUEST=None, force=F
     cnx = ndb.GetDBConnexion()
     log("do_ue_delete: ue_id=%s, delete_validations=%s" % (ue_id, delete_validations))
     # check
-    ue = do_ue_list(context, {"ue_id": ue_id})
+    ue = do_ue_list({"ue_id": ue_id})
     if not ue:
         raise ScoValueError("UE inexistante !")
     ue = ue[0]
-    if ue_is_locked(context, ue["ue_id"]):
+    if ue_is_locked(ue["ue_id"]):
         raise ScoLockedFormError()
     # Il y a-t-il des etudiants ayant validé cette UE ?
     # si oui, propose de supprimer les validations
@@ -151,9 +151,9 @@ def do_ue_delete(context, ue_id, delete_validations=False, REQUEST=None, force=F
         )
 
     # delete all matiere in this UE
-    mats = sco_edit_matiere.do_matiere_list(context, {"ue_id": ue_id})
+    mats = sco_edit_matiere.do_matiere_list({"ue_id": ue_id})
     for mat in mats:
-        sco_edit_matiere.do_matiere_delete(context, mat["matiere_id"])
+        sco_edit_matiere.do_matiere_delete(mat["matiere_id"])
     # delete uecoef and events
     ndb.SimpleQuery(
         "DELETE FROM notes_formsemestre_uecoef WHERE ue_id=%(ue_id)s",
@@ -185,18 +185,18 @@ def do_ue_delete(context, ue_id, delete_validations=False, REQUEST=None, force=F
         return None
 
 
-def ue_create(context, formation_id=None, REQUEST=None):
+def ue_create(formation_id=None, REQUEST=None):
     """Creation d'une UE"""
-    return ue_edit(context, create=True, formation_id=formation_id, REQUEST=REQUEST)
+    return ue_edit(create=True, formation_id=formation_id, REQUEST=REQUEST)
 
 
-def ue_edit(context, ue_id=None, create=False, formation_id=None, REQUEST=None):
+def ue_edit(ue_id=None, create=False, formation_id=None, REQUEST=None):
     """Modification ou creation d'une UE"""
     from app.scodoc import sco_formations
 
     create = int(create)
     if not create:
-        U = do_ue_list(context, args={"ue_id": ue_id})
+        U = do_ue_list(args={"ue_id": ue_id})
         if not U:
             raise ScoValueError("UE inexistante !")
         U = U[0]
@@ -341,19 +341,17 @@ def ue_edit(context, ue_id=None, create=False, formation_id=None, REQUEST=None):
                     tf[2]["semestre_id"] = 0
                 # numero regroupant par semestre ou année:
                 tf[2]["numero"] = next_ue_numero(
-                    context, formation_id, int(tf[2]["semestre_id"] or 0)
+                    formation_id, int(tf[2]["semestre_id"] or 0)
                 )
 
-            ue_id = do_ue_create(context, tf[2])
+            ue_id = do_ue_create(tf[2])
             if parcours.UE_IS_MODULE or tf[2]["create_matiere"]:
                 matiere_id = sco_edit_matiere.do_matiere_create(
-                    context,
                     {"ue_id": ue_id, "titre": tf[2]["titre"], "numero": 1},
                 )
             if parcours.UE_IS_MODULE:
                 # dans ce mode, crée un (unique) module dans l'UE:
                 _ = sco_edit_module.do_module_create(
-                    context,
                     {
                         "titre": tf[2]["titre"],
                         "code": tf[2]["acronyme"],
@@ -365,7 +363,7 @@ def ue_edit(context, ue_id=None, create=False, formation_id=None, REQUEST=None):
                     },
                 )
         else:
-            do_ue_edit(context, tf[2])
+            do_ue_edit(tf[2])
         return flask.redirect(
             url_for(
                 "notes.ue_list", scodoc_dept=g.scodoc_dept, formation_id=formation_id
@@ -373,31 +371,31 @@ def ue_edit(context, ue_id=None, create=False, formation_id=None, REQUEST=None):
         )
 
 
-def _add_ue_semestre_id(context, ue_list):
+def _add_ue_semestre_id(ue_list):
     """ajoute semestre_id dans les ue, en regardant le premier module de chacune.
     Les UE sans modules se voient attribuer le numero UE_SEM_DEFAULT (1000000),
     qui les place à la fin de la liste.
     """
     for ue in ue_list:
-        Modlist = sco_edit_module.do_module_list(context, args={"ue_id": ue["ue_id"]})
+        Modlist = sco_edit_module.do_module_list(args={"ue_id": ue["ue_id"]})
         if Modlist:
             ue["semestre_id"] = Modlist[0]["semestre_id"]
         else:
             ue["semestre_id"] = 1000000
 
 
-def next_ue_numero(context, formation_id, semestre_id=None):
+def next_ue_numero(formation_id, semestre_id=None):
     """Numero d'une nouvelle UE dans cette formation.
     Si le semestre est specifie, cherche les UE ayant des modules de ce semestre
     """
-    ue_list = do_ue_list(context, args={"formation_id": formation_id})
+    ue_list = do_ue_list(args={"formation_id": formation_id})
     if not ue_list:
         return 0
     if semestre_id is None:
         return ue_list[-1]["numero"] + 1000
     else:
         # Avec semestre: (prend le semestre du 1er module de l'UE)
-        _add_ue_semestre_id(context, ue_list)
+        _add_ue_semestre_id(ue_list)
         ue_list_semestre = [ue for ue in ue_list if ue["semestre_id"] == semestre_id]
         if ue_list_semestre:
             return ue_list_semestre[-1]["numero"] + 10
@@ -406,10 +404,10 @@ def next_ue_numero(context, formation_id, semestre_id=None):
 
 
 def ue_delete(
-    context, ue_id=None, delete_validations=False, dialog_confirmed=False, REQUEST=None
+    ue_id=None, delete_validations=False, dialog_confirmed=False, REQUEST=None
 ):
     """Delete an UE"""
-    ue = do_ue_list(context, args={"ue_id": ue_id})
+    ue = do_ue_list(args={"ue_id": ue_id})
     if not ue:
         raise ScoValueError("UE inexistante !")
     ue = ue[0]
@@ -422,12 +420,10 @@ def ue_delete(
             cancel_url="ue_list?formation_id=%s" % ue["formation_id"],
         )
 
-    return do_ue_delete(
+    return do_ue_delete(ue_id, delete_validations=delete_validations, REQUEST=REQUEST)
-        context, ue_id, delete_validations=delete_validations, REQUEST=REQUEST
-    )
 
 
-def ue_list(context, formation_id=None, msg="", REQUEST=None):
+def ue_list(formation_id=None, msg="", REQUEST=None):
     """Liste des matières et modules d'une formation, avec liens pour
     editer (si non verrouillée).
     """
@@ -439,11 +435,11 @@ def ue_list(context, formation_id=None, msg="", REQUEST=None):
         raise ScoValueError("invalid formation_id")
     F = F[0]
     parcours = sco_codes_parcours.get_parcours_from_code(F["type_parcours"])
-    locked = sco_formations.formation_has_locked_sems(context, formation_id)
+    locked = sco_formations.formation_has_locked_sems(formation_id)
 
-    ue_list = do_ue_list(context, args={"formation_id": formation_id})
+    ue_list = do_ue_list(args={"formation_id": formation_id})
     # tri par semestre et numero:
-    _add_ue_semestre_id(context, ue_list)
+    _add_ue_semestre_id(ue_list)
     ue_list.sort(key=lambda u: (u["semestre_id"], u["numero"]))
     has_duplicate_ue_codes = len(set([ue["ue_code"] for ue in ue_list])) != len(ue_list)
 
@@ -612,7 +608,7 @@ Si vous souhaitez modifier cette formation (par exemple pour y ajouter un module
                 '<span class="ue_type">%s</span>'
                 % sco_codes_parcours.UE_TYPE_NAME[UE["type"]]
             )
-        ue_editable = editable and not ue_is_locked(context, UE["ue_id"])
+        ue_editable = editable and not ue_is_locked(UE["ue_id"])
         if ue_editable:
             H.append(
                 '<a class="stdlink" href="ue_edit?ue_id=%(ue_id)s">modifier</a>' % UE
@@ -621,12 +617,12 @@ Si vous souhaitez modifier cette formation (par exemple pour y ajouter un module
             H.append('<span class="locked">[verrouillé]</span>')
         if not parcours.UE_IS_MODULE:
             H.append('<ul class="notes_matiere_list">')
-        Matlist = sco_edit_matiere.do_matiere_list(context, args={"ue_id": UE["ue_id"]})
+        Matlist = sco_edit_matiere.do_matiere_list(args={"ue_id": UE["ue_id"]})
         for Mat in Matlist:
             if not parcours.UE_IS_MODULE:
                 H.append('<li class="notes_matiere_list">')
                 if editable and not sco_edit_matiere.matiere_is_locked(
-                    context, Mat["matiere_id"]
+                    Mat["matiere_id"]
                 ):
                     H.append(
                         f"""<a class="stdlink" href="{
@@ -637,18 +633,18 @@ Si vous souhaitez modifier cette formation (par exemple pour y ajouter un module
                     )
                 H.append("%(titre)s" % Mat)
                 if editable and not sco_edit_matiere.matiere_is_locked(
-                    context, Mat["matiere_id"]
+                    Mat["matiere_id"]
                 ):
                     H.append("</a>")
 
             H.append('<ul class="notes_module_list">')
             Modlist = sco_edit_module.do_module_list(
-                context, args={"matiere_id": Mat["matiere_id"]}
+                args={"matiere_id": Mat["matiere_id"]}
             )
             im = 0
             for Mod in Modlist:
                 Mod["nb_moduleimpls"] = sco_edit_module.module_count_moduleimpls(
-                    context, Mod["module_id"]
+                    Mod["module_id"]
                 )
                 klass = "notes_module_list"
                 if Mod["module_type"] == scu.MODULE_MALUS:
@@ -680,7 +676,7 @@ Si vous souhaitez modifier cette formation (par exemple pour y ajouter un module
                     H.append(delete_disabled_icon)
                 H.append("</span>")
 
-                mod_editable = editable  # and not sco_edit_module.module_is_locked(context, Mod['module_id'])
+                mod_editable = editable  # and not sco_edit_module.module_is_locked( Mod['module_id'])
                 if mod_editable:
                     H.append(
                         '<a class="discretelink" title="Modifier le module numéro %(numero)s, utilisé par %(nb_moduleimpls)d sessions" href="module_edit?module_id=%(module_id)s">'
@@ -714,7 +710,7 @@ Si vous souhaitez modifier cette formation (par exemple pour y ajouter un module
                 tag_edit = tag_mk.format(
                     Mod["module_id"],
                     tag_cls,
-                    ",".join(sco_tag_module.module_tag_list(context, Mod["module_id"])),
+                    ",".join(sco_tag_module.module_tag_list(Mod["module_id"])),
                 )
                 H.append(
                     " %s %s" % (parcours.SESSION_NAME, Mod["semestre_id"])
@@ -825,14 +821,14 @@ Si vous souhaitez modifier cette formation (par exemple pour y ajouter un module
         )
     #   <li>(debug) <a class="stdlink" href="check_form_integrity?formation_id=%(formation_id)s">Vérifier cohérence</a></li>
 
-    warn, _ = sco_formsemestre_validation.check_formation_ues(context, formation_id)
+    warn, _ = sco_formsemestre_validation.check_formation_ues(formation_id)
     H.append(warn)
 
     H.append(html_sco_header.sco_footer())
     return "".join(H)
 
 
-def ue_sharing_code(context, ue_code=None, ue_id=None, hide_ue_id=None):
+def ue_sharing_code(ue_code=None, ue_id=None, hide_ue_id=None):
     """HTML list of UE sharing this code
     Either ue_code or ue_id may be specified.
     hide_ue_id spécifie un id à retirer de la liste.
@@ -840,13 +836,13 @@ def ue_sharing_code(context, ue_code=None, ue_id=None, hide_ue_id=None):
     from app.scodoc import sco_formations
 
     if ue_id:
-        ue = do_ue_list(context, args={"ue_id": ue_id})[0]
+        ue = do_ue_list(args={"ue_id": ue_id})[0]
         if not ue_code:
             ue_code = ue["ue_code"]
         F = sco_formations.formation_list(args={"formation_id": ue["formation_id"]})[0]
         formation_code = F["formation_code"]
 
-    ue_list_all = do_ue_list(context, args={"ue_code": ue_code})
+    ue_list_all = do_ue_list(args={"ue_code": ue_code})
     if ue_id:
         # retire les UE d'autres formations:
         # log('checking ucode %s formation %s' % (ue_code, formation_code))
@@ -891,19 +887,17 @@ def ue_sharing_code(context, ue_code=None, ue_id=None, hide_ue_id=None):
     return "\n".join(H)
 
 
-def do_ue_edit(context, args, bypass_lock=False, dont_invalidate_cache=False):
+def do_ue_edit(args, bypass_lock=False, dont_invalidate_cache=False):
     "edit an UE"
     # check
     ue_id = args["ue_id"]
-    ue = do_ue_list(context, {"ue_id": ue_id})[0]
+    ue = do_ue_list({"ue_id": ue_id})[0]
-    if (not bypass_lock) and ue_is_locked(context, ue["ue_id"]):
+    if (not bypass_lock) and ue_is_locked(ue["ue_id"]):
         raise ScoLockedFormError()
     # check: acronyme unique dans cette formation
     if "acronyme" in args:
         new_acro = args["acronyme"]
-        ues = do_ue_list(
+        ues = do_ue_list({"formation_id": ue["formation_id"], "acronyme": new_acro})
-            context, {"formation_id": ue["formation_id"], "acronyme": new_acro}
-        )
         if ues and ues[0]["ue_id"] != ue_id:
             raise ScoValueError('Acronyme d\'UE "%s" déjà utilisé !' % args["acronyme"])
 
@@ -920,18 +914,17 @@ def do_ue_edit(context, args, bypass_lock=False, dont_invalidate_cache=False):
 
 
 # essai edition en ligne:
-def edit_ue_set_code_apogee(context, id=None, value=None, REQUEST=None):
+def edit_ue_set_code_apogee(id=None, value=None, REQUEST=None):
     "set UE code apogee"
     ue_id = id
     value = value.strip("-_ \t")
     log("edit_ue_set_code_apogee: ue_id=%s code_apogee=%s" % (ue_id, value))
 
-    ues = do_ue_list(context, args={"ue_id": ue_id})
+    ues = do_ue_list(args={"ue_id": ue_id})
     if not ues:
         return "ue invalide"
 
     do_ue_edit(
-        context,
         {"ue_id": ue_id, "code_apogee": value},
         bypass_lock=True,
         dont_invalidate_cache=False,
@@ -941,7 +934,7 @@ def edit_ue_set_code_apogee(context, id=None, value=None, REQUEST=None):
     return value
 
 
-def ue_is_locked(context, ue_id):
+def ue_is_locked(ue_id):
     """True if UE should not be modified
     (contains modules used in a locked formsemestre)
     """
@@ -958,7 +951,7 @@ def ue_is_locked(context, ue_id):
 
 
 # ---- Table recap formation
-def formation_table_recap(context, formation_id, format="html", REQUEST=None):
+def formation_table_recap(formation_id, format="html", REQUEST=None):
     """Table recapitulant formation."""
     from app.scodoc import sco_formations
 
@@ -967,16 +960,16 @@ def formation_table_recap(context, formation_id, format="html", REQUEST=None):
         raise ScoValueError("invalid formation_id")
     F = F[0]
     T = []
-    ue_list = do_ue_list(context, args={"formation_id": formation_id})
+    ue_list = do_ue_list(args={"formation_id": formation_id})
     for UE in ue_list:
-        Matlist = sco_edit_matiere.do_matiere_list(context, args={"ue_id": UE["ue_id"]})
+        Matlist = sco_edit_matiere.do_matiere_list(args={"ue_id": UE["ue_id"]})
         for Mat in Matlist:
             Modlist = sco_edit_module.do_module_list(
-                context, args={"matiere_id": Mat["matiere_id"]}
+                args={"matiere_id": Mat["matiere_id"]}
             )
             for Mod in Modlist:
                 Mod["nb_moduleimpls"] = sco_edit_module.module_count_moduleimpls(
-                    context, Mod["module_id"]
+                    Mod["module_id"]
                 )
                 #
                 T.append(
@@ -1044,11 +1037,11 @@ def formation_table_recap(context, formation_id, format="html", REQUEST=None):
     return tab.make_page(format=format, REQUEST=REQUEST)
 
 
-def ue_list_semestre_ids(context, ue):
+def ue_list_semestre_ids(ue):
     """Liste triée des numeros de semestres des modules dans cette UE
     Il est recommandable que tous les modules d'une UE aient le même indice de semestre.
     Mais cela n'a pas toujours été le cas dans les programmes pédagogiques officiels,
     aussi ScoDoc laisse le choix.
     """
-    Modlist = sco_edit_module.do_module_list(context, args={"ue_id": ue["ue_id"]})
+    Modlist = sco_edit_module.do_module_list(args={"ue_id": ue["ue_id"]})
     return sorted(list(set([mod["semestre_id"] for mod in Modlist])))

app/scodoc/sco_evaluations.py

@@ -179,7 +179,7 @@ def do_evaluation_list(args, sortkey=None):
 def do_evaluation_list_in_formsemestre(formsemestre_id):
     "list evaluations in this formsemestre"
     context = None  # #context
-    mods = sco_moduleimpl.do_moduleimpl_list(context, formsemestre_id=formsemestre_id)
+    mods = sco_moduleimpl.do_moduleimpl_list(formsemestre_id=formsemestre_id)
     evals = []
     for mod in mods:
         evals += do_evaluation_list(args={"moduleimpl_id": mod["moduleimpl_id"]})
@@ -214,7 +214,7 @@ def _check_evaluation_args(args):
     jour = args.get("jour", None)
     args["jour"] = jour
     if jour:
-        M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=moduleimpl_id)[0]
+        M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=moduleimpl_id)[0]
         sem = sco_formsemestre.get_formsemestre(M["formsemestre_id"])
         d, m, y = [int(x) for x in sem["date_debut"].split("/")]
         date_debut = datetime.date(y, m, d)
@@ -304,8 +304,8 @@ def do_evaluation_create(
     r = _evaluationEditor.create(cnx, args)
 
     # news
-    M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=moduleimpl_id)[0]
+    M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=moduleimpl_id)[0]
-    mod = sco_edit_module.do_module_list(context, args={"module_id": M["module_id"]})[0]
+    mod = sco_edit_module.do_module_list(args={"module_id": M["module_id"]})[0]
     mod["moduleimpl_id"] = M["moduleimpl_id"]
     mod["url"] = "Notes/moduleimpl_status?moduleimpl_id=%(moduleimpl_id)s" % mod
     sco_news.add(
@@ -336,7 +336,7 @@ def do_evaluation_edit(args):
     cnx = ndb.GetDBConnexion()
     _evaluationEditor.edit(cnx, args)
     # inval cache pour ce semestre
-    M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=moduleimpl_id)[0]
+    M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=moduleimpl_id)[0]
     sco_cache.invalidate_formsemestre(formsemestre_id=M["formsemestre_id"])
 
 
@@ -362,10 +362,10 @@ def do_evaluation_delete(evaluation_id):
 
     _evaluationEditor.delete(cnx, evaluation_id)
     # inval cache pour ce semestre
-    M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=moduleimpl_id)[0]
+    M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=moduleimpl_id)[0]
     sco_cache.invalidate_formsemestre(formsemestre_id=M["formsemestre_id"])
     # news
-    mod = sco_edit_module.do_module_list(context, args={"module_id": M["module_id"]})[0]
+    mod = sco_edit_module.do_module_list(args={"module_id": M["module_id"]})[0]
     mod["moduleimpl_id"] = M["moduleimpl_id"]
     mod["url"] = (
         scu.NotesURL() + "/moduleimpl_status?moduleimpl_id=%(moduleimpl_id)s" % mod
@@ -418,8 +418,8 @@ def do_evaluation_etat(evaluation_id, partition_id=None, select_first_partition=
         last_modif = None
     # ---- Liste des groupes complets et incomplets
     E = do_evaluation_list(args={"evaluation_id": evaluation_id})[0]
-    M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=E["moduleimpl_id"])[0]
+    M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=E["moduleimpl_id"])[0]
-    Mod = sco_edit_module.do_module_list(context, args={"module_id": M["module_id"]})[0]
+    Mod = sco_edit_module.do_module_list(args={"module_id": M["module_id"]})[0]
     is_malus = Mod["module_type"] == scu.MODULE_MALUS  # True si module de malus
     formsemestre_id = M["formsemestre_id"]
     # Si partition_id is None, prend 'all' ou bien la premiere:
@@ -438,7 +438,7 @@ def do_evaluation_etat(evaluation_id, partition_id=None, select_first_partition=
         formsemestre_id
     )
     insmod = sco_moduleimpl.do_moduleimpl_inscription_list(
-        context, moduleimpl_id=E["moduleimpl_id"]
+        moduleimpl_id=E["moduleimpl_id"]
     )
     insmodset = set([x["etudid"] for x in insmod])
     # retire de insem ceux qui ne sont pas inscrits au module
@@ -743,7 +743,7 @@ def formsemestre_evaluations_cal(formsemestre_id, REQUEST=None):
             continue
         day = e["jour"].strftime("%Y-%m-%d")
         mod = sco_moduleimpl.do_moduleimpl_withmodule_list(
-            context, moduleimpl_id=e["moduleimpl_id"]
+            moduleimpl_id=e["moduleimpl_id"]
         )[0]
         txt = mod["module"]["code"] or mod["module"]["abbrev"] or "eval"
         if e["heure_debut"]:
@@ -821,10 +821,10 @@ def evaluation_date_first_completion(evaluation_id):
     # (pour avoir l'etat et le groupe) et aussi les inscriptions
     # au module (pour gerer les modules optionnels correctement)
     # E = do_evaluation_list(args={"evaluation_id": evaluation_id})[0]
-    # M = sco_moduleimpl.do_moduleimpl_list(context,moduleimpl_id=E["moduleimpl_id"])[0]
+    # M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=E["moduleimpl_id"])[0]
     # formsemestre_id = M["formsemestre_id"]
     # insem = sco_formsemestre_inscriptions.do_formsemestre_inscription_listinscrits( formsemestre_id)
-    # insmod = sco_moduleimpl.do_moduleimpl_inscription_list(context,moduleimpl_id=E["moduleimpl_id"])
+    # insmod = sco_moduleimpl.do_moduleimpl_inscription_list(moduleimpl_id=E["moduleimpl_id"])
     # insmodset = set([x["etudid"] for x in insmod])
     # retire de insem ceux qui ne sont pas inscrits au module
     # ins = [i for i in insem if i["etudid"] in insmodset]
@@ -866,12 +866,8 @@ def formsemestre_evaluations_delai_correction(
     evals = nt.get_sem_evaluation_etat_list()
     T = []
     for e in evals:
-        M = sco_moduleimpl.do_moduleimpl_list(
+        M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=e["moduleimpl_id"])[0]
-            context, moduleimpl_id=e["moduleimpl_id"]
+        Mod = sco_edit_module.do_module_list(args={"module_id": M["module_id"]})[0]
-        )[0]
-        Mod = sco_edit_module.do_module_list(
-            context, args={"module_id": M["module_id"]}
-        )[0]
         if (e["evaluation_type"] != scu.EVALUATION_NORMALE) or (
             Mod["module_type"] == scu.MODULE_MALUS
         ):
@@ -1050,8 +1046,8 @@ def evaluation_describe(evaluation_id="", edit_in_place=True, REQUEST=None):
 
     E = do_evaluation_list({"evaluation_id": evaluation_id})[0]
     moduleimpl_id = E["moduleimpl_id"]
-    M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=moduleimpl_id)[0]
+    M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=moduleimpl_id)[0]
-    Mod = sco_edit_module.do_module_list(context, args={"module_id": M["module_id"]})[0]
+    Mod = sco_edit_module.do_module_list(args={"module_id": M["module_id"]})[0]
     formsemestre_id = M["formsemestre_id"]
     u = sco_users.user_info(M["responsable_id"])
     resp = u["prenomnom"]
@@ -1080,7 +1076,7 @@ def evaluation_describe(evaluation_id="", edit_in_place=True, REQUEST=None):
     ]
     if Mod["module_type"] == scu.MODULE_MALUS:
         # Indique l'UE
-        ue = sco_edit_ue.do_ue_list(context, args={"ue_id": Mod["ue_id"]})[0]
+        ue = sco_edit_ue.do_ue_list(args={"ue_id": Mod["ue_id"]})[0]
         H.append("<p><b>UE : %(acronyme)s</b></p>" % ue)
         # store min/max values used by JS client-side checks:
         H.append(
@@ -1132,9 +1128,7 @@ def evaluation_create_form(
         the_eval = do_evaluation_list({"evaluation_id": evaluation_id})[0]
         moduleimpl_id = the_eval["moduleimpl_id"]
     #
-    M = sco_moduleimpl.do_moduleimpl_withmodule_list(
+    M = sco_moduleimpl.do_moduleimpl_withmodule_list(moduleimpl_id=moduleimpl_id)[0]
-        context, moduleimpl_id=moduleimpl_id
-    )[0]
     is_malus = M["module"]["module_type"] == scu.MODULE_MALUS  # True si module de malus
     formsemestre_id = M["formsemestre_id"]
     min_note_max = scu.NOTES_PRECISION  # le plus petit bareme possible
@@ -1193,7 +1187,7 @@ def evaluation_create_form(
     else:
         min_note_max_str = "0"
     #
-    Mod = sco_edit_module.do_module_list(context, args={"module_id": M["module_id"]})[0]
+    Mod = sco_edit_module.do_module_list(args={"module_id": M["module_id"]})[0]
     #
     help = """<div class="help"><p class="help">
     Le coefficient d'une évaluation n'est utilisé que pour pondérer les évaluations au sein d'un module.

app/scodoc/sco_export_results.py

@@ -245,7 +245,7 @@ def scodoc_table_results(
         )
         if format != "html":
             return tab.make_page(
-                context, format=format, with_html_headers=False, REQUEST=REQUEST
+                format=format, with_html_headers=False, REQUEST=REQUEST
             )
         tab_html = tab.html()
         nb_rows = tab.get_nb_rows()

app/scodoc/sco_find_etud.py

@@ -378,5 +378,5 @@ def search_inscr_etud_by_nip(context, code_nip, REQUEST=None, format="json"):
     tab = GenTable(columns_ids=columns_ids, rows=T)
 
     return tab.make_page(
-        context, format=format, with_html_headers=False, REQUEST=REQUEST, publish=True
+        format=format, with_html_headers=False, REQUEST=REQUEST, publish=True
     )

app/scodoc/sco_formations.py

@@ -84,7 +84,7 @@ def formation_list(formation_id=None, args={}):
     return r
 
 
-def formation_has_locked_sems(context, formation_id):
+def formation_has_locked_sems(formation_id):
     "True if there is a locked formsemestre in this formation"
     sems = sco_formsemestre.do_formsemestre_list(
         args={"formation_id": formation_id, "etat": False}
@@ -93,13 +93,13 @@ def formation_has_locked_sems(context, formation_id):
 
 
 def formation_export(
-    context, formation_id, export_ids=False, export_tags=True, format=None, REQUEST=None
+    formation_id, export_ids=False, export_tags=True, format=None, REQUEST=None
 ):
     """Get a formation, with UE, matieres, modules
     in desired format
     """
-    F = formation_list(context, args={"formation_id": formation_id})[0]
+    F = formation_list(args={"formation_id": formation_id})[0]
-    ues = sco_edit_ue.do_ue_list(context, {"formation_id": formation_id})
+    ues = sco_edit_ue.do_ue_list({"formation_id": formation_id})
     F["ue"] = ues
     for ue in ues:
         ue_id = ue["ue_id"]
@@ -108,21 +108,19 @@ def formation_export(
             del ue["formation_id"]
         if ue["ects"] is None:
             del ue["ects"]
-        mats = sco_edit_matiere.do_matiere_list(context, {"ue_id": ue_id})
+        mats = sco_edit_matiere.do_matiere_list({"ue_id": ue_id})
         ue["matiere"] = mats
         for mat in mats:
             matiere_id = mat["matiere_id"]
             if not export_ids:
                 del mat["matiere_id"]
                 del mat["ue_id"]
-            mods = sco_edit_module.do_module_list(context, {"matiere_id": matiere_id})
+            mods = sco_edit_module.do_module_list({"matiere_id": matiere_id})
             mat["module"] = mods
             for mod in mods:
                 if export_tags:
-                    # mod['tags'] = sco_tag_module.module_tag_list(context, module_id=mod['module_id'])
+                    # mod['tags'] = sco_tag_module.module_tag_list( module_id=mod['module_id'])
-                    tags = sco_tag_module.module_tag_list(
+                    tags = sco_tag_module.module_tag_list(module_id=mod["module_id"])
-                        context, module_id=mod["module_id"]
-                    )
                     if tags:
                         mod["tags"] = [{"name": x} for x in tags]
                 if not export_ids:
@@ -138,7 +136,7 @@ def formation_export(
     )
 
 
-def formation_import_xml(context, doc: str, import_tags=True):
+def formation_import_xml(doc: str, import_tags=True):
     """Create a formation from XML representation
     (format dumped by formation_export( format='xml' ))
     XML may contain object (UE, modules) ids: this function returns two
@@ -188,7 +186,7 @@ def formation_import_xml(context, doc: str, import_tags=True):
     # create formation
     # F_unquoted = F.copy()
     # unescape_html_dict(F_unquoted)
-    formation_id = sco_edit_formation.do_formation_create(context, F)
+    formation_id = sco_edit_formation.do_formation_create(F)
     log("formation %s created" % formation_id)
     ues_old2new = {}  # xml ue_id : new ue_id
     modules_old2new = {}  # xml module_id : new module_id
@@ -202,14 +200,14 @@ def formation_import_xml(context, doc: str, import_tags=True):
             del ue_info[1]["ue_id"]
         else:
             xml_ue_id = None
-        ue_id = sco_edit_ue.do_ue_create(context, ue_info[1])
+        ue_id = sco_edit_ue.do_ue_create(ue_info[1])
         if xml_ue_id:
             ues_old2new[xml_ue_id] = ue_id
         # -- create matieres
         for mat_info in ue_info[2]:
             assert mat_info[0] == "matiere"
             mat_info[1]["ue_id"] = ue_id
-            mat_id = sco_edit_matiere.do_matiere_create(context, mat_info[1])
+            mat_id = sco_edit_matiere.do_matiere_create(mat_info[1])
             # -- create modules
             for mod_info in mat_info[2]:
                 assert mod_info[0] == "module"
@@ -221,23 +219,23 @@ def formation_import_xml(context, doc: str, import_tags=True):
                 mod_info[1]["formation_id"] = formation_id
                 mod_info[1]["matiere_id"] = mat_id
                 mod_info[1]["ue_id"] = ue_id
-                mod_id = sco_edit_module.do_module_create(context, mod_info[1])
+                mod_id = sco_edit_module.do_module_create(mod_info[1])
                 if xml_module_id:
                     modules_old2new[int(xml_module_id)] = mod_id
                 if import_tags:
                     if len(mod_info) > 2:
                         tag_names = [t[1]["name"] for t in mod_info[2]]
-                        sco_tag_module.module_tag_set(context, mod_id, tag_names)
+                        sco_tag_module.module_tag_set(mod_id, tag_names)
 
     return formation_id, modules_old2new, ues_old2new
 
 
-def formation_list_table(context, formation_id=None, args={}, REQUEST=None):
+def formation_list_table(formation_id=None, args={}, REQUEST=None):
     """List formation, grouped by titre and sorted by versions
     and listing associated semestres
     returns a table
     """
-    formations = formation_list(context, formation_id=formation_id, args=args)
+    formations = formation_list(formation_id=formation_id, args=args)
     title = "Programmes pédagogiques"
     lockicon = scu.icontag(
         "lock32_img", title="Comporte des semestres verrouillés", border="0"
@@ -285,7 +283,7 @@ def formation_list_table(context, formation_id=None, args={}, REQUEST=None):
         else:
             f["date_fin_dernier_sem"] = ""
             f["annee_dernier_sem"] = ""
-        locked = formation_has_locked_sems(context, f["formation_id"])
+        locked = formation_has_locked_sems(f["formation_id"])
         #
         if locked:
             but_locked = lockicon
@@ -354,12 +352,12 @@ def formation_list_table(context, formation_id=None, args={}, REQUEST=None):
     )
 
 
-def formation_create_new_version(context, formation_id, redirect=True, REQUEST=None):
+def formation_create_new_version(formation_id, redirect=True, REQUEST=None):
     "duplicate formation, with new version number"
-    xml = formation_export(context, formation_id, export_ids=True, format="xml")
+    xml = formation_export(formation_id, export_ids=True, format="xml")
-    new_id, modules_old2new, ues_old2new = formation_import_xml(context, xml)
+    new_id, modules_old2new, ues_old2new = formation_import_xml(xml)
     # news
-    F = formation_list(context, args={"formation_id": new_id})[0]
+    F = formation_list(args={"formation_id": new_id})[0]
     sco_news.add(
         typ=sco_news.NEWS_FORM,
         object=new_id,

app/scodoc/sco_formsemestre_edit.py

@@ -122,7 +122,7 @@ def formsemestre_editwithmodules(context, REQUEST, formsemestre_id):
     return "\n".join(H) + html_sco_header.sco_footer()
 
 
-def can_edit_sem(context, REQUEST, formsemestre_id="", sem=None):
+def can_edit_sem(REQUEST, formsemestre_id="", sem=None):
     """Return sem if user can edit it, False otherwise"""
     sem = sem or sco_formsemestre.get_formsemestre(formsemestre_id)
     if not current_user.has_permission(Permission.ScoImplement):  # pas chef
@@ -168,9 +168,7 @@ def do_formsemestre_createwithmodules(context, REQUEST=None, edit=False):
         initvalues = sem
         semestre_id = initvalues["semestre_id"]
         # add associated modules to tf-checked:
-        ams = sco_moduleimpl.do_moduleimpl_list(
+        ams = sco_moduleimpl.do_moduleimpl_list(formsemestre_id=formsemestre_id)
-            context, formsemestre_id=formsemestre_id
-        )
         sem_module_ids = set([x["module_id"] for x in ams])
         initvalues["tf-checked"] = ["MI" + str(x["module_id"]) for x in ams]
         for x in ams:
@@ -203,13 +201,11 @@ def do_formsemestre_createwithmodules(context, REQUEST=None, edit=False):
     # on pourrait faire un simple module_list( )
     # mais si on veut l'ordre du PPN (groupe par UE et matieres) il faut:
     mods = []  # liste de dicts
-    uelist = sco_edit_ue.do_ue_list(context, {"formation_id": formation_id})
+    uelist = sco_edit_ue.do_ue_list({"formation_id": formation_id})
     for ue in uelist:
-        matlist = sco_edit_matiere.do_matiere_list(context, {"ue_id": ue["ue_id"]})
+        matlist = sco_edit_matiere.do_matiere_list({"ue_id": ue["ue_id"]})
         for mat in matlist:
-            modsmat = sco_edit_module.do_module_list(
+            modsmat = sco_edit_module.do_module_list({"matiere_id": mat["matiere_id"]})
-                context, {"matiere_id": mat["matiere_id"]}
-            )
             # XXX debug checks
             for m in modsmat:
                 if m["ue_id"] != ue["ue_id"]:
@@ -736,7 +732,7 @@ def do_formsemestre_createwithmodules(context, REQUEST=None, edit=False):
                     "formsemestre_id": formsemestre_id,
                     "responsable_id": tf[2][module_id],
                 }
-                _ = sco_moduleimpl.do_moduleimpl_create(context, modargs)
+                _ = sco_moduleimpl.do_moduleimpl_create(modargs)
             return flask.redirect(
                 "formsemestre_status?formsemestre_id=%s&head_message=Nouveau%%20semestre%%20créé"
                 % formsemestre_id
@@ -751,9 +747,7 @@ def do_formsemestre_createwithmodules(context, REQUEST=None, edit=False):
             # (retire le "MI" du début du nom de champs)
             checkedmods = [int(x[2:]) for x in tf[2]["tf-checked"]]
             sco_formsemestre.do_formsemestre_edit(tf[2])
-            ams = sco_moduleimpl.do_moduleimpl_list(
+            ams = sco_moduleimpl.do_moduleimpl_list(formsemestre_id=formsemestre_id)
-                context, formsemestre_id=formsemestre_id
-            )
             existingmods = [x["module_id"] for x in ams]
             mods_tocreate = [x for x in checkedmods if not x in existingmods]
             # modules a existants a modifier
@@ -768,10 +762,8 @@ def do_formsemestre_createwithmodules(context, REQUEST=None, edit=False):
                     "formsemestre_id": formsemestre_id,
                     "responsable_id": tf[2]["MI" + str(module_id)],
                 }
-                moduleimpl_id = sco_moduleimpl.do_moduleimpl_create(context, modargs)
+                moduleimpl_id = sco_moduleimpl.do_moduleimpl_create(modargs)
-                mod = sco_edit_module.do_module_list(context, {"module_id": module_id})[
+                mod = sco_edit_module.do_module_list({"module_id": module_id})[0]
-                    0
-                ]
                 msg += ["création de %s (%s)" % (mod["code"], mod["titre"])]
                 # INSCRIPTIONS DES ETUDIANTS
                 log(
@@ -788,7 +780,6 @@ def do_formsemestre_createwithmodules(context, REQUEST=None, edit=False):
                         % (module_id, moduleimpl_id, etudids)
                     )
                     sco_moduleimpl.do_moduleimpl_inscrit_etuds(
-                        context,
                         moduleimpl_id,
                         formsemestre_id,
                         etudids,
@@ -804,13 +795,11 @@ def do_formsemestre_createwithmodules(context, REQUEST=None, edit=False):
                         % (module_id, moduleimpl_id)
                     )
             #
-            ok, diag = formsemestre_delete_moduleimpls(
+            ok, diag = formsemestre_delete_moduleimpls(formsemestre_id, mods_todelete)
-                context, formsemestre_id, mods_todelete
-            )
             msg += diag
             for module_id in mods_toedit:
                 moduleimpl_id = sco_moduleimpl.do_moduleimpl_list(
-                    context, formsemestre_id=formsemestre_id, module_id=module_id
+                    formsemestre_id=formsemestre_id, module_id=module_id
                 )[0]["moduleimpl_id"]
                 modargs = {
                     "moduleimpl_id": moduleimpl_id,
@@ -819,11 +808,9 @@ def do_formsemestre_createwithmodules(context, REQUEST=None, edit=False):
                     "responsable_id": tf[2]["MI" + str(module_id)],
                 }
                 sco_moduleimpl.do_moduleimpl_edit(
-                    context, modargs, formsemestre_id=formsemestre_id
+                    modargs, formsemestre_id=formsemestre_id
                 )
-                mod = sco_edit_module.do_module_list(context, {"module_id": module_id})[
+                mod = sco_edit_module.do_module_list({"module_id": module_id})[0]
-                    0
-                ]
 
             if msg:
                 msg_html = (
@@ -847,7 +834,7 @@ def do_formsemestre_createwithmodules(context, REQUEST=None, edit=False):
                 )
 
 
-def formsemestre_delete_moduleimpls(context, formsemestre_id, module_ids_to_del):
+def formsemestre_delete_moduleimpls(formsemestre_id, module_ids_to_del):
     """Delete moduleimpls
     module_ids_to_del: list of module_id (warning: not moduleimpl)
     Moduleimpls must have no associated evaluations.
@@ -857,9 +844,9 @@ def formsemestre_delete_moduleimpls(context, formsemestre_id, module_ids_to_del)
     for module_id in module_ids_to_del:
         # get id
         moduleimpl_id = sco_moduleimpl.do_moduleimpl_list(
-            context, formsemestre_id=formsemestre_id, module_id=module_id
+            formsemestre_id=formsemestre_id, module_id=module_id
         )[0]["moduleimpl_id"]
-        mod = sco_edit_module.do_module_list(context, {"module_id": module_id})[0]
+        mod = sco_edit_module.do_module_list({"module_id": module_id})[0]
         # Evaluations dans ce module ?
         evals = sco_evaluations.do_evaluation_list({"moduleimpl_id": moduleimpl_id})
         if evals:
@@ -871,7 +858,7 @@ def formsemestre_delete_moduleimpls(context, formsemestre_id, module_ids_to_del)
         else:
             msg += ["suppression de %s (%s)" % (mod["code"], mod["titre"])]
             sco_moduleimpl.do_moduleimpl_delete(
-                context, moduleimpl_id, formsemestre_id=formsemestre_id
+                moduleimpl_id, formsemestre_id=formsemestre_id
             )
 
     return ok, msg
@@ -990,7 +977,6 @@ def formsemestre_clone(context, formsemestre_id, REQUEST=None):
         )
     else:
         new_formsemestre_id = do_formsemestre_clone(
-            context,
             formsemestre_id,
             User.get_user_id_from_nomplogin(tf[2]["responsable_id"]),
             tf[2]["date_debut"],
@@ -1006,7 +992,6 @@ def formsemestre_clone(context, formsemestre_id, REQUEST=None):
 
 
 def do_formsemestre_clone(
-    context,
     orig_formsemestre_id,
     responsable_id,  # new resp.
     date_debut,
@@ -1031,21 +1016,19 @@ def do_formsemestre_clone(
     formsemestre_id = sco_formsemestre.do_formsemestre_create(args)
     log("created formsemestre %s" % formsemestre_id)
     # 2- create moduleimpls
-    mods_orig = sco_moduleimpl.do_moduleimpl_list(
+    mods_orig = sco_moduleimpl.do_moduleimpl_list(formsemestre_id=orig_formsemestre_id)
-        context, formsemestre_id=orig_formsemestre_id
-    )
     for mod_orig in mods_orig:
         args = mod_orig.copy()
         args["formsemestre_id"] = formsemestre_id
-        mid = sco_moduleimpl.do_moduleimpl_create(context, args)
+        mid = sco_moduleimpl.do_moduleimpl_create(args)
         # copy notes_modules_enseignants
         ens = sco_moduleimpl.do_ens_list(
-            context, args={"moduleimpl_id": mod_orig["moduleimpl_id"]}
+            args={"moduleimpl_id": mod_orig["moduleimpl_id"]}
         )
         for e in ens:
             args = e.copy()
             args["moduleimpl_id"] = mid
-            sco_moduleimpl.do_ens_create(context, args)
+            sco_moduleimpl.do_ens_create(args)
         # optionally, copy evaluations
         if clone_evaluations:
             evals = sco_evaluations.do_evaluation_list(
@@ -1209,7 +1192,7 @@ def do_formsemestres_associate_new_version(context, formsemestre_ids, REQUEST=No
         modules_old2new,
         ues_old2new,
     ) = sco_formations.formation_create_new_version(
-        context, formation_id, redirect=False, REQUEST=REQUEST
+        formation_id, redirect=False, REQUEST=REQUEST
     )
 
     for formsemestre_id in formsemestre_ids:
@@ -1230,12 +1213,10 @@ def _reassociate_moduleimpls(
     et met à jour les décisions de jury (validations d'UE).
     """
     # re-associate moduleimpls to new modules:
-    modimpls = sco_moduleimpl.do_moduleimpl_list(
+    modimpls = sco_moduleimpl.do_moduleimpl_list(formsemestre_id=formsemestre_id)
-        context, formsemestre_id=formsemestre_id
-    )
     for mod in modimpls:
         mod["module_id"] = modules_old2new[mod["module_id"]]
-        sco_moduleimpl.do_moduleimpl_edit(context, mod, formsemestre_id=formsemestre_id)
+        sco_moduleimpl.do_moduleimpl_edit(mod, formsemestre_id=formsemestre_id)
     # update decisions:
     events = sco_etud.scolar_events_list(cnx, args={"formsemestre_id": formsemestre_id})
     for e in events:
@@ -1353,7 +1334,7 @@ def do_formsemestre_delete(context, formsemestre_id):
     sco_cache.EvaluationCache.invalidate_sem(formsemestre_id)
 
     # --- Destruction des modules de ce semestre
-    mods = sco_moduleimpl.do_moduleimpl_list(context, formsemestre_id=formsemestre_id)
+    mods = sco_moduleimpl.do_moduleimpl_list(formsemestre_id=formsemestre_id)
     for mod in mods:
         # evaluations
         evals = sco_evaluations.do_evaluation_list(
@@ -1374,7 +1355,7 @@ def do_formsemestre_delete(context, formsemestre_id):
             )
 
         sco_moduleimpl.do_moduleimpl_delete(
-            context, mod["moduleimpl_id"], formsemestre_id=formsemestre_id
+            mod["moduleimpl_id"], formsemestre_id=formsemestre_id
         )
     # --- Desinscription des etudiants
     cursor = cnx.cursor(cursor_factory=ndb.ScoDocCursor)

app/scodoc/sco_formsemestre_exterieurs.py

@@ -441,7 +441,7 @@ def _list_ue_with_coef_and_validations(context, sem, etudid):
     """
     cnx = ndb.GetDBConnexion()
     formsemestre_id = sem["formsemestre_id"]
-    ue_list = sco_edit_ue.do_ue_list(context, {"formation_id": sem["formation_id"]})
+    ue_list = sco_edit_ue.do_ue_list({"formation_id": sem["formation_id"]})
     for ue in ue_list:
         # add coefficient
         uecoef = sco_formsemestre.formsemestre_uecoef_list(

app/scodoc/sco_formsemestre_inscriptions.py

@@ -170,7 +170,7 @@ def do_formsemestre_desinscription(context, etudid, formsemestre_id, REQUEST=Non
     moduleimpl_inscription_ids = [x[0] for x in res]
     for moduleimpl_inscription_id in moduleimpl_inscription_ids:
         sco_moduleimpl.do_moduleimpl_inscription_delete(
-            context, moduleimpl_inscription_id, formsemestre_id=formsemestre_id
+            moduleimpl_inscription_id, formsemestre_id=formsemestre_id
         )
     # -- desincription du semestre
     do_formsemestre_inscription_delete(
@@ -235,12 +235,11 @@ def do_formsemestre_inscription_with_modules(
 
     # inscription a tous les modules de ce semestre
     modimpls = sco_moduleimpl.do_moduleimpl_withmodule_list(
-        context, formsemestre_id=formsemestre_id
+        formsemestre_id=formsemestre_id
     )
     for mod in modimpls:
         if mod["ue"]["type"] != UE_SPORT:
             sco_moduleimpl.do_moduleimpl_inscription_create(
-                context,
                 {"moduleimpl_id": mod["moduleimpl_id"], "etudid": etudid},
                 REQUEST=REQUEST,
                 formsemestre_id=formsemestre_id,
@@ -454,10 +453,8 @@ def formsemestre_inscription_option(context, etudid, formsemestre_id, REQUEST=No
     ]
 
     # Cherche les moduleimpls et les inscriptions
-    mods = sco_moduleimpl.do_moduleimpl_withmodule_list(
+    mods = sco_moduleimpl.do_moduleimpl_withmodule_list(formsemestre_id=formsemestre_id)
-        context, formsemestre_id=formsemestre_id
+    inscr = sco_moduleimpl.do_moduleimpl_inscription_list(etudid=etudid)
-    )
-    inscr = sco_moduleimpl.do_moduleimpl_inscription_list(context, etudid=etudid)
     # Formulaire
     modimpls_by_ue_ids = scu.DictDefault(defaultvalue=[])  # ue_id : [ moduleimpl_id ]
     modimpls_by_ue_names = scu.DictDefault(
@@ -680,14 +677,13 @@ def do_moduleimpl_incription_options(
     # inscriptions
     for moduleimpl_id in a_inscrire:
         # verifie que ce module existe bien
-        mods = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=moduleimpl_id)
+        mods = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=moduleimpl_id)
         if len(mods) != 1:
             raise ScoValueError(
                 "inscription: invalid moduleimpl_id: %s" % moduleimpl_id
             )
         mod = mods[0]
         sco_moduleimpl.do_moduleimpl_inscription_create(
-            context,
             {"moduleimpl_id": moduleimpl_id, "etudid": etudid},
             REQUEST=REQUEST,
             formsemestre_id=mod["formsemestre_id"],
@@ -695,14 +691,14 @@ def do_moduleimpl_incription_options(
     # desinscriptions
     for moduleimpl_id in a_desinscrire:
         # verifie que ce module existe bien
-        mods = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=moduleimpl_id)
+        mods = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=moduleimpl_id)
         if len(mods) != 1:
             raise ScoValueError(
                 "desinscription: invalid moduleimpl_id: %s" % moduleimpl_id
             )
         mod = mods[0]
         inscr = sco_moduleimpl.do_moduleimpl_inscription_list(
-            context, moduleimpl_id=moduleimpl_id, etudid=etudid
+            moduleimpl_id=moduleimpl_id, etudid=etudid
         )
         if not inscr:
             raise ScoValueError(
@@ -711,7 +707,7 @@ def do_moduleimpl_incription_options(
             )
         oid = inscr[0]["moduleimpl_inscription_id"]
         sco_moduleimpl.do_moduleimpl_inscription_delete(
-            context, oid, formsemestre_id=mod["formsemestre_id"]
+            oid, formsemestre_id=mod["formsemestre_id"]
         )
 
     if REQUEST:

app/scodoc/sco_formsemestre_status.py

@@ -464,9 +464,7 @@ def retreive_formsemestre_from_request():
     if "formsemestre_id" in args:
         formsemestre_id = args["formsemestre_id"]
     elif "moduleimpl_id" in args and args["moduleimpl_id"]:
-        modimpl = sco_moduleimpl.do_moduleimpl_list(
+        modimpl = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=args["moduleimpl_id"])
-            context, moduleimpl_id=args["moduleimpl_id"]
-        )
         if not modimpl:
             return None  # suppressed ?
         modimpl = modimpl[0]
@@ -476,9 +474,7 @@ def retreive_formsemestre_from_request():
         if not E:
             return None  # evaluation suppressed ?
         E = E[0]
-        modimpl = sco_moduleimpl.do_moduleimpl_list(
+        modimpl = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=E["moduleimpl_id"])[0]
-            context, moduleimpl_id=E["moduleimpl_id"]
-        )[0]
         formsemestre_id = modimpl["formsemestre_id"]
     elif "group_id" in args:
         group = sco_groups.get_group(args["group_id"])
@@ -596,7 +592,7 @@ def formsemestre_description_table(
     F = sco_formations.formation_list(args={"formation_id": sem["formation_id"]})[0]
     parcours = sco_codes_parcours.get_parcours_from_code(F["type_parcours"])
     Mlist = sco_moduleimpl.do_moduleimpl_withmodule_list(
-        context, formsemestre_id=formsemestre_id
+        formsemestre_id=formsemestre_id
     )
 
     R = []
@@ -625,7 +621,7 @@ def formsemestre_description_table(
             R.append(ue_info)
 
         ModInscrits = sco_moduleimpl.do_moduleimpl_inscription_list(
-            context, moduleimpl_id=M["moduleimpl_id"]
+            moduleimpl_id=M["moduleimpl_id"]
         )
         enseignants = ", ".join(
             [sco_users.user_info(m["ens_id"], REQUEST)["nomprenom"] for m in M["ens"]]
@@ -891,7 +887,7 @@ def html_expr_diagnostic(context, diagnostics):
     for diag in diagnostics:
         if "moduleimpl_id" in diag:
             mod = sco_moduleimpl.do_moduleimpl_withmodule_list(
-                context, moduleimpl_id=diag["moduleimpl_id"]
+                moduleimpl_id=diag["moduleimpl_id"]
             )[0]
             H.append(
                 '<li>module <a href="moduleimpl_status?moduleimpl_id=%s">%s</a>: %s</li>'
@@ -903,7 +899,7 @@ def html_expr_diagnostic(context, diagnostics):
             )
         else:
             if diag["ue_id"] != last_id or diag["msg"] != last_msg:
-                ue = sco_edit_ue.do_ue_list(context, {"ue_id": diag["ue_id"]})[0]
+                ue = sco_edit_ue.do_ue_list({"ue_id": diag["ue_id"]})[0]
                 H.append(
                     '<li>UE "%s": %s</li>'
                     % (ue["acronyme"] or ue["titre"] or "?", diag["msg"])
@@ -987,16 +983,14 @@ def formsemestre_status(context, formsemestre_id=None, REQUEST=None):
     cnx = ndb.GetDBConnexion()
     sem = sco_formsemestre.get_formsemestre(formsemestre_id)
     Mlist = sco_moduleimpl.do_moduleimpl_withmodule_list(
-        context, formsemestre_id=formsemestre_id
+        formsemestre_id=formsemestre_id
     )
     # inscrits = sco_formsemestre_inscriptions.do_formsemestre_inscription_list(
     #    args={"formsemestre_id": formsemestre_id}
     # )
     prev_ue_id = None
 
-    can_edit = sco_formsemestre_edit.can_edit_sem(
+    can_edit = sco_formsemestre_edit.can_edit_sem(REQUEST, formsemestre_id, sem=sem)
-        context, REQUEST, formsemestre_id, sem=sem
-    )
 
     H = [
         html_sco_header.sco_header(page_title="Semestre %s" % sem["titreannee"]),
@@ -1040,7 +1034,7 @@ def formsemestre_status(context, formsemestre_id=None, REQUEST=None):
                 [sco_users.user_info(e["ens_id"])["nomcomplet"] for e in M["ens"]]
             )
         ModInscrits = sco_moduleimpl.do_moduleimpl_inscription_list(
-            context, moduleimpl_id=M["moduleimpl_id"]
+            moduleimpl_id=M["moduleimpl_id"]
         )
         mails_enseignants.add(
             sco_users.user_info(M["responsable_id"], REQUEST)["email"]

app/scodoc/sco_formsemestre_validation.py

@@ -1018,7 +1018,7 @@ def formsemestre_validate_previous_ue(context, formsemestre_id, etudid, REQUEST=
     ]
 
     # Toutes les UE de cette formation sont présentées (même celles des autres semestres)
-    ues = sco_edit_ue.do_ue_list(context, {"formation_id": Fo["formation_id"]})
+    ues = sco_edit_ue.do_ue_list({"formation_id": Fo["formation_id"]})
     ue_names = ["Choisir..."] + ["%(acronyme)s %(titre)s" % ue for ue in ues]
     ue_ids = [""] + [ue["ue_id"] for ue in ues]
     tf = TrivialFormulator(
@@ -1076,7 +1076,7 @@ def formsemestre_validate_previous_ue(context, formsemestre_id, etudid, REQUEST=
            <div id="ue_list_etud_validations"><!-- filled by get_etud_ue_cap_html --></div>
            <div id="ue_list_code"><!-- filled by ue_sharing_code --></div>
         """
-        warn, ue_multiples = check_formation_ues(context, Fo["formation_id"])
+        warn, ue_multiples = check_formation_ues(Fo["formation_id"])
         return "\n".join(H) + tf[1] + X + warn + html_sco_header.sco_footer()
     elif tf[0] == -1:
         return flask.redirect(
@@ -1228,13 +1228,13 @@ def etud_ue_suppress_validation(context, etudid, formsemestre_id, ue_id, REQUEST
     )
 
 
-def check_formation_ues(context, formation_id):
+def check_formation_ues(formation_id):
     """Verifie que les UE d'une formation sont chacune utilisée dans un seul semestre_id
     Si ce n'est pas le cas, c'est probablement (mais pas forcément) une erreur de
     définition du programme: cette fonction retourne un bout de HTML
     à afficher pour prévenir l'utilisateur, ou '' si tout est ok.
     """
-    ues = sco_edit_ue.do_ue_list(context, {"formation_id": formation_id})
+    ues = sco_edit_ue.do_ue_list({"formation_id": formation_id})
     ue_multiples = {}  # { ue_id : [ liste des formsemestre ] }
     for ue in ues:
         # formsemestres utilisant cette ue ?

app/scodoc/sco_groups_view.py

@@ -319,9 +319,7 @@ class DisplayedGroupsInfos(object):
             else:
                 group_ids = []
         if not formsemestre_id and moduleimpl_id:
-            mods = sco_moduleimpl.do_moduleimpl_list(
+            mods = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=moduleimpl_id)
-                context, moduleimpl_id=moduleimpl_id
-            )
             if len(mods) != 1:
                 raise ValueError("invalid moduleimpl_id")
             formsemestre_id = mods[0]["formsemestre_id"]

app/scodoc/sco_liste_notes.py

@@ -234,8 +234,8 @@ def _make_table_notes(
         return "<p>Aucune évaluation !</p>"
     E = evals[0]
     moduleimpl_id = E["moduleimpl_id"]
-    M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=moduleimpl_id)[0]
+    M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=moduleimpl_id)[0]
-    Mod = sco_edit_module.do_module_list(context, args={"module_id": M["module_id"]})[0]
+    Mod = sco_edit_module.do_module_list(args={"module_id": M["module_id"]})[0]
     sem = sco_formsemestre.get_formsemestre(M["formsemestre_id"])
     # (debug) check that all evals are in same module:
     for e in evals:
@@ -888,7 +888,7 @@ def formsemestre_check_absences_html(context, formsemestre_id, REQUEST=None):
     ]
     # Modules, dans l'ordre
     Mlist = sco_moduleimpl.do_moduleimpl_withmodule_list(
-        context, formsemestre_id=formsemestre_id
+        formsemestre_id=formsemestre_id
     )
     for M in Mlist:
         evals = sco_evaluations.do_evaluation_list(

app/scodoc/sco_moduleimpl.py

@@ -63,7 +63,7 @@ _modules_enseignantsEditor = ndb.EditableTable(
 )
 
 
-def do_moduleimpl_create(context, args):
+def do_moduleimpl_create(args):
     "create a moduleimpl"
     cnx = ndb.GetDBConnexion()
     r = _moduleimplEditor.create(cnx, args)
@@ -73,7 +73,7 @@ def do_moduleimpl_create(context, args):
     return r
 
 
-def do_moduleimpl_delete(context, oid, formsemestre_id=None):
+def do_moduleimpl_delete(oid, formsemestre_id=None):
     "delete moduleimpl (desinscrit tous les etudiants)"
     cnx = ndb.GetDBConnexion()
     # --- desinscription des etudiants
@@ -100,7 +100,7 @@ def do_moduleimpl_delete(context, oid, formsemestre_id=None):
 
 
 def do_moduleimpl_list(
-    context, moduleimpl_id=None, formsemestre_id=None, module_id=None, REQUEST=None
+    moduleimpl_id=None, formsemestre_id=None, module_id=None, REQUEST=None
 ):
     "list moduleimpls"
     args = locals()
@@ -108,11 +108,11 @@ def do_moduleimpl_list(
     modimpls = _moduleimplEditor.list(cnx, args)
     # Ajoute la liste des enseignants
     for mo in modimpls:
-        mo["ens"] = do_ens_list(context, args={"moduleimpl_id": mo["moduleimpl_id"]})
+        mo["ens"] = do_ens_list(args={"moduleimpl_id": mo["moduleimpl_id"]})
     return scu.return_text_if_published(modimpls, REQUEST)
 
 
-def do_moduleimpl_edit(context, args, formsemestre_id=None, cnx=None):
+def do_moduleimpl_edit(args, formsemestre_id=None, cnx=None):
     "edit a moduleimpl"
     if not cnx:
         cnx = ndb.GetDBConnexion()
@@ -124,7 +124,7 @@ def do_moduleimpl_edit(context, args, formsemestre_id=None, cnx=None):
 
 
 def do_moduleimpl_withmodule_list(
-    context, moduleimpl_id=None, formsemestre_id=None, module_id=None, REQUEST=None
+    moduleimpl_id=None, formsemestre_id=None, module_id=None, REQUEST=None
 ):
     """Liste les moduleimpls et ajoute dans chacun le module correspondant
     Tri la liste par semestre/UE/numero_matiere/numero_module.
@@ -136,10 +136,8 @@ def do_moduleimpl_withmodule_list(
     from app.scodoc import sco_edit_module
 
     args = locals()
-    del args["context"]
     del args["REQUEST"]
     modimpls = do_moduleimpl_list(
-        context,
         **{
             "moduleimpl_id": moduleimpl_id,
             "formsemestre_id": formsemestre_id,
@@ -148,13 +146,11 @@ def do_moduleimpl_withmodule_list(
     )
     for mo in modimpls:
         mo["module"] = sco_edit_module.do_module_list(
-            context, args={"module_id": mo["module_id"]}
+            args={"module_id": mo["module_id"]}
-        )[0]
-        mo["ue"] = sco_edit_ue.do_ue_list(
-            context, args={"ue_id": mo["module"]["ue_id"]}
         )[0]
+        mo["ue"] = sco_edit_ue.do_ue_list(args={"ue_id": mo["module"]["ue_id"]})[0]
         mo["matiere"] = sco_edit_matiere.do_matiere_list(
-            context, args={"matiere_id": mo["module"]["matiere_id"]}
+            args={"matiere_id": mo["module"]["matiere_id"]}
         )[0]
 
     # tri par semestre/UE/numero_matiere/numero_module
@@ -172,9 +168,7 @@ def do_moduleimpl_withmodule_list(
     return scu.return_text_if_published(modimpls, REQUEST)
 
 
-def do_moduleimpl_inscription_list(
+def do_moduleimpl_inscription_list(moduleimpl_id=None, etudid=None, REQUEST=None):
-    context, moduleimpl_id=None, etudid=None, REQUEST=None
-):
     "list moduleimpl_inscriptions"
     args = locals()
     cnx = ndb.GetDBConnexion()
@@ -183,7 +177,7 @@ def do_moduleimpl_inscription_list(
     )
 
 
-def do_moduleimpl_listeetuds(context, moduleimpl_id):
+def do_moduleimpl_listeetuds(moduleimpl_id):
     "retourne liste des etudids inscrits a ce module"
     req = """SELECT DISTINCT Im.etudid 
     FROM notes_moduleimpl_inscription Im, 
@@ -200,7 +194,7 @@ def do_moduleimpl_listeetuds(context, moduleimpl_id):
     return [x[0] for x in res]
 
 
-def do_moduleimpl_inscrit_tout_semestre(context, moduleimpl_id, formsemestre_id):
+def do_moduleimpl_inscrit_tout_semestre(moduleimpl_id, formsemestre_id):
     "inscrit tous les etudiants inscrit au semestre a ce module"
     # UNUSED
     cnx = ndb.GetDBConnexion()
@@ -223,7 +217,7 @@ _moduleimpl_inscriptionEditor = ndb.EditableTable(
 )
 
 
-def do_moduleimpl_inscription_create(context, args, REQUEST=None, formsemestre_id=None):
+def do_moduleimpl_inscription_create(args, REQUEST=None, formsemestre_id=None):
     "create a moduleimpl_inscription"
     cnx = ndb.GetDBConnexion()
     log("do_moduleimpl_inscription_create: " + str(args))
@@ -242,7 +236,7 @@ def do_moduleimpl_inscription_create(context, args, REQUEST=None, formsemestre_i
     return r
 
 
-def do_moduleimpl_inscription_delete(context, oid, formsemestre_id=None):
+def do_moduleimpl_inscription_delete(oid, formsemestre_id=None):
     "delete moduleimpl_inscription"
     cnx = ndb.GetDBConnexion()
     _moduleimpl_inscriptionEditor.delete(cnx, oid)
@@ -252,7 +246,7 @@ def do_moduleimpl_inscription_delete(context, oid, formsemestre_id=None):
 
 
 def do_moduleimpl_inscrit_etuds(
-    context, moduleimpl_id, formsemestre_id, etudids, reset=False, REQUEST=None
+    moduleimpl_id, formsemestre_id, etudids, reset=False, REQUEST=None
 ):
     """Inscrit les etudiants (liste d'etudids) a ce module.
     Si reset, desinscrit tous les autres.
@@ -280,16 +274,13 @@ def do_moduleimpl_inscrit_etuds(
         [
             # hum ?
             x["etudid"]
-            for x in do_moduleimpl_inscription_list(
+            for x in do_moduleimpl_inscription_list(moduleimpl_id=moduleimpl_id)
-                context, moduleimpl_id=moduleimpl_id
-            )
         ]
     )
     for etudid in etudids:
         # deja inscrit ?
         if not etudid in inmod_set:
             do_moduleimpl_inscription_create(
-                context,
                 {"moduleimpl_id": moduleimpl_id, "etudid": etudid},
                 REQUEST=REQUEST,
                 formsemestre_id=formsemestre_id,
@@ -300,31 +291,31 @@ def do_moduleimpl_inscrit_etuds(
     )  # > moduleimpl_inscrit_etuds
 
 
-def do_ens_list(context, *args, **kw):
+def do_ens_list(*args, **kw):
     "liste les enseignants d'un moduleimpl (pas le responsable)"
     cnx = ndb.GetDBConnexion()
     ens = _modules_enseignantsEditor.list(cnx, *args, **kw)
     return ens
 
 
-def do_ens_edit(context, *args, **kw):
+def do_ens_edit(*args, **kw):
     "edit ens"
     cnx = ndb.GetDBConnexion()
     _modules_enseignantsEditor.edit(cnx, *args, **kw)
 
 
-def do_ens_create(context, args):
+def do_ens_create(args):
     "create ens"
     cnx = ndb.GetDBConnexion()
     r = _modules_enseignantsEditor.create(cnx, args)
     return r
 
 
-def can_change_module_resp(context, REQUEST, moduleimpl_id):
+def can_change_module_resp(REQUEST, moduleimpl_id):
     """Check if current user can modify module resp. (raise exception if not).
     = Admin, et dir des etud. (si option l'y autorise)
     """
-    M = do_moduleimpl_withmodule_list(context, moduleimpl_id=moduleimpl_id)[0]
+    M = do_moduleimpl_withmodule_list(moduleimpl_id=moduleimpl_id)[0]
     # -- check lock
     sem = sco_formsemestre.get_formsemestre(M["formsemestre_id"])
     if not sem["etat"]:
@@ -340,9 +331,9 @@ def can_change_module_resp(context, REQUEST, moduleimpl_id):
     return M, sem
 
 
-def can_change_ens(context, REQUEST, moduleimpl_id, raise_exc=True):
+def can_change_ens(REQUEST, moduleimpl_id, raise_exc=True):
     "check if current user can modify ens list (raise exception if not)"
-    M = do_moduleimpl_withmodule_list(context, moduleimpl_id=moduleimpl_id)[0]
+    M = do_moduleimpl_withmodule_list(moduleimpl_id=moduleimpl_id)[0]
     # -- check lock
     sem = sco_formsemestre.get_formsemestre(M["formsemestre_id"])
     if not sem["etat"]:

app/scodoc/sco_moduleimpl_inscriptions.py

@@ -64,9 +64,9 @@ def moduleimpl_inscriptions_edit(
 
      * Si pas les droits: idem en readonly
     """
-    M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=moduleimpl_id)[0]
+    M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=moduleimpl_id)[0]
     formsemestre_id = M["formsemestre_id"]
-    mod = sco_edit_module.do_module_list(context, args={"module_id": M["module_id"]})[0]
+    mod = sco_edit_module.do_module_list(args={"module_id": M["module_id"]})[0]
     sem = sco_formsemestre.get_formsemestre(formsemestre_id)
     # -- check lock
     if not sem["etat"]:
@@ -108,7 +108,7 @@ def moduleimpl_inscriptions_edit(
         ins["etud"] = etuds_info[0]
     inscrits.sort(key=lambda x: x["etud"]["nom"])
     in_m = sco_moduleimpl.do_moduleimpl_inscription_list(
-        context, moduleimpl_id=M["moduleimpl_id"]
+        moduleimpl_id=M["moduleimpl_id"]
     )
     in_module = set([x["etudid"] for x in in_m])
     #
@@ -199,7 +199,7 @@ def moduleimpl_inscriptions_edit(
     else:  # SUBMISSION
         # inscrit a ce module tous les etuds selectionnes
         sco_moduleimpl.do_moduleimpl_inscrit_etuds(
-            context, moduleimpl_id, formsemestre_id, etuds, reset=True, REQUEST=REQUEST
+            moduleimpl_id, formsemestre_id, etuds, reset=True, REQUEST=REQUEST
         )
         return flask.redirect("moduleimpl_status?moduleimpl_id=%s" % (moduleimpl_id))
     #
@@ -265,7 +265,7 @@ def moduleimpl_inscriptions_stats(context, formsemestre_id, REQUEST=None):
 
     # Liste des modules
     Mlist = sco_moduleimpl.do_moduleimpl_withmodule_list(
-        context, formsemestre_id=formsemestre_id
+        formsemestre_id=formsemestre_id
     )
     # Decrit les inscriptions aux modules:
     commons = []  # modules communs a tous les etuds du semestre
@@ -347,10 +347,7 @@ def moduleimpl_inscriptions_stats(context, formsemestre_id, REQUEST=None):
     UECaps = get_etuds_with_capitalized_ue(context, formsemestre_id)
     if UECaps:
         H.append('<h3>Etudiants avec UEs capitalisées:</h3><ul class="ue_inscr_list">')
-        ues = [
+        ues = [sco_edit_ue.do_ue_list({"ue_id": ue_id})[0] for ue_id in UECaps.keys()]
-            sco_edit_ue.do_ue_list(context, {"ue_id": ue_id})[0]
-            for ue_id in UECaps.keys()
-        ]
         ues.sort(key=lambda u: u["numero"])
         for ue in ues:
             H.append(
@@ -428,9 +425,7 @@ def descr_inscrs_module(
     context, sem, moduleimpl_id, set_all, partitions, partitions_etud_groups
 ):
     """returns tous_inscrits, nb_inscrits, descr"""
-    ins = sco_moduleimpl.do_moduleimpl_inscription_list(
+    ins = sco_moduleimpl.do_moduleimpl_inscription_list(moduleimpl_id=moduleimpl_id)
-        context, moduleimpl_id=moduleimpl_id
-    )
     set_m = set([x["etudid"] for x in ins])  # ens. des inscrits au module
     non_inscrits = set_all - set_m
     if len(non_inscrits) == 0:
@@ -589,7 +584,6 @@ def do_etud_inscrit_ue(context, etudid, formsemestre_id, ue_id, REQUEST=None):
     res = cursor.dictfetchall()
     for moduleimpl_id in [x["moduleimpl_id"] for x in res]:
         sco_moduleimpl.do_moduleimpl_inscription_create(
-            context,
             {"moduleimpl_id": moduleimpl_id, "etudid": etudid},
             REQUEST=REQUEST,
             formsemestre_id=formsemestre_id,

app/scodoc/sco_moduleimpl_status.py

@@ -57,9 +57,7 @@ from app.scodoc import sco_users
 def moduleimpl_evaluation_menu(context, evaluation_id, nbnotes=0, REQUEST=None):
     "Menu avec actions sur une evaluation"
     E = sco_evaluations.do_evaluation_list({"evaluation_id": evaluation_id})[0]
-    modimpl = sco_moduleimpl.do_moduleimpl_list(
+    modimpl = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=E["moduleimpl_id"])[0]
-        context, moduleimpl_id=E["moduleimpl_id"]
-    )[0]
 
     group_id = sco_groups.get_default_group(modimpl["formsemestre_id"])
 
@@ -158,13 +156,13 @@ def moduleimpl_evaluation_menu(context, evaluation_id, nbnotes=0, REQUEST=None):
 
 def moduleimpl_status(context, moduleimpl_id=None, partition_id=None, REQUEST=None):
     """Tableau de bord module (liste des evaluations etc)"""
-    M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=moduleimpl_id)[0]
+    M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=moduleimpl_id)[0]
     formsemestre_id = M["formsemestre_id"]
-    Mod = sco_edit_module.do_module_list(context, args={"module_id": M["module_id"]})[0]
+    Mod = sco_edit_module.do_module_list(args={"module_id": M["module_id"]})[0]
     sem = sco_formsemestre.get_formsemestre(formsemestre_id)
     F = sco_formations.formation_list(args={"formation_id": sem["formation_id"]})[0]
     ModInscrits = sco_moduleimpl.do_moduleimpl_inscription_list(
-        context, moduleimpl_id=M["moduleimpl_id"]
+        moduleimpl_id=M["moduleimpl_id"]
     )
 
     nt = sco_cache.NotesTableCache.get(formsemestre_id)
@@ -193,7 +191,7 @@ def moduleimpl_status(context, moduleimpl_id=None, partition_id=None, REQUEST=No
         """<span class="blacktt">(%(responsable_id)s)</span>""" % M,
     ]
     try:
-        sco_moduleimpl.can_change_module_resp(context, REQUEST, moduleimpl_id)
+        sco_moduleimpl.can_change_module_resp(REQUEST, moduleimpl_id)
         H.append(
             """<a class="stdlink" href="edit_moduleimpl_resp?moduleimpl_id=%s">modifier</a>"""
             % moduleimpl_id
@@ -206,7 +204,7 @@ def moduleimpl_status(context, moduleimpl_id=None, partition_id=None, REQUEST=No
     )
     H.append("""</td><td>""")
     try:
-        sco_moduleimpl.can_change_ens(context, REQUEST, moduleimpl_id)
+        sco_moduleimpl.can_change_ens(REQUEST, moduleimpl_id)
         H.append(
             """<a class="stdlink" href="edit_enseignants_form?moduleimpl_id=%s">modifier les enseignants</a>"""
             % moduleimpl_id
@@ -249,9 +247,7 @@ def moduleimpl_status(context, moduleimpl_id=None, partition_id=None, REQUEST=No
             '<tr><td class="fichetitre2" colspan="4">Règle de calcul: <span class="formula" title="mode de calcul de la moyenne du module">moyenne=<tt>%s</tt></span>'
             % M["computation_expr"]
         )
-        if sco_moduleimpl.can_change_ens(
+        if sco_moduleimpl.can_change_ens(REQUEST, moduleimpl_id, raise_exc=False):
-            context, REQUEST, moduleimpl_id, raise_exc=False
-        ):
             H.append(
                 '<span class="fl"><a class="stdlink"  href="edit_moduleimpl_expr?moduleimpl_id=%s">modifier</a></span>'
                 % moduleimpl_id
@@ -261,9 +257,7 @@ def moduleimpl_status(context, moduleimpl_id=None, partition_id=None, REQUEST=No
         H.append(
             '<tr><td colspan="4"><em title="mode de calcul de la moyenne du module">règle de calcul standard</em>'
         )
-        if sco_moduleimpl.can_change_ens(
+        if sco_moduleimpl.can_change_ens(REQUEST, moduleimpl_id, raise_exc=False):
-            context, REQUEST, moduleimpl_id, raise_exc=False
-        ):
             H.append(
                 ' (<a class="stdlink" href="edit_moduleimpl_expr?moduleimpl_id=%s">changer</a>)'
                 % moduleimpl_id

app/scodoc/sco_news.py

@@ -178,7 +178,7 @@ def _get_formsemestre_infos_from_news(context, n):
         formsemestre_id = n["object"]
     elif n["type"] == NEWS_NOTE:
         moduleimpl_id = n["object"]
-        mods = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=moduleimpl_id)
+        mods = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=moduleimpl_id)
         if not mods:
             return {}  # module does not exists anymore
         mod = mods[0]

app/scodoc/sco_parcours_dut.py

@@ -1093,7 +1093,7 @@ def formsemestre_get_etud_capitalisation(context, sem, etudid):
     return cursor.dictfetchall()
 
 
-def list_formsemestre_utilisateurs_uecap(context, formsemestre_id):
+def list_formsemestre_utilisateurs_uecap(formsemestre_id):
     """Liste des formsemestres pouvant utiliser une UE capitalisee de ce semestre
     (et qui doivent donc etre sortis du cache si l'on modifie ce
     semestre): meme code formation, meme semestre_id, date posterieure"""

app/scodoc/sco_permissions_check.py

@@ -26,7 +26,7 @@ def can_edit_notes(authuser, moduleimpl_id, allow_ens=True):
 
     context = None  # XXX #context
     uid = str(authuser)
-    M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=moduleimpl_id)[0]
+    M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=moduleimpl_id)[0]
     sem = sco_formsemestre.get_formsemestre(M["formsemestre_id"])
     if not sem["etat"]:
         return False  # semestre verrouillé
@@ -68,7 +68,7 @@ def can_edit_evaluation(moduleimpl_id=None):
     if moduleimpl_id is None:
         raise ValueError("no moduleimpl specified")  # bug
     uid = current_user.user_name
-    M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=moduleimpl_id)[0]
+    M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=moduleimpl_id)[0]
     sem = sco_formsemestre.get_formsemestre(M["formsemestre_id"])
 
     if (

app/scodoc/sco_placement.py

@@ -65,7 +65,7 @@ def do_placement_selectetuds(REQUEST):
     if not E:
         raise ScoValueError("invalid evaluation_id")
     E = E[0]
-    # M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=E["moduleimpl_id"])[0]
+    # M = sco_moduleimpl.do_moduleimpl_list( moduleimpl_id=E["moduleimpl_id"])[0]
     # groupes
     groups = sco_groups.do_evaluation_listegroupes(evaluation_id, include_default=True)
     grlabs = [g["group_name"] or "tous" for g in groups]  # legendes des boutons
@@ -283,8 +283,8 @@ def do_placement(context, REQUEST):
     if not etudids:
         return "<p>Aucun groupe sélectionné !</p>"
 
-    M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=E["moduleimpl_id"])[0]
+    M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=E["moduleimpl_id"])[0]
-    Mod = sco_edit_module.do_module_list(context, args={"module_id": M["module_id"]})[0]
+    Mod = sco_edit_module.do_module_list(args={"module_id": M["module_id"]})[0]
     sem = sco_formsemestre.get_formsemestre(M["formsemestre_id"])
     evalname = "%s-%s" % (Mod["code"], ndb.DateDMYtoISO(E["jour"]))
     if E["description"]:
@@ -395,9 +395,7 @@ def do_placement(context, REQUEST):
             preferences=sco_preferences.SemPreferences(M["formsemestre_id"]),
             # html_generate_cells=False # la derniere ligne (moyennes) est incomplete
         )
-        t = tab.make_page(
+        t = tab.make_page(format="pdf", with_html_headers=False, REQUEST=REQUEST)
-            context, format="pdf", with_html_headers=False, REQUEST=REQUEST
-        )
         return t
 
 

app/scodoc/sco_poursuite_dut.py

@@ -215,7 +215,6 @@ def formsemestre_poursuite_report(
     tab.html_caption = "Récapitulatif %s." % sem["titreannee"]
     tab.base_url = "%s?formsemestre_id=%s" % (REQUEST.URL0, formsemestre_id)
     return tab.make_page(
-        context,
         title="""<h2 class="formsemestre">Poursuite d'études</h2>""",
         init_qtip=True,
         javascripts=["js/etud_info.js"],

app/scodoc/sco_pvjury.py

@@ -92,7 +92,7 @@ def _descr_decisions_ues(context, nt, etudid, decisions_ue, decision_sem):
                     and sco_codes_parcours.code_semestre_validant(decision_sem["code"])
                 )
             ):
-                ue = sco_edit_ue.do_ue_list(context, args={"ue_id": ue_id})[0]
+                ue = sco_edit_ue.do_ue_list(args={"ue_id": ue_id})[0]
                 uelist.append(ue)
         except:
             log("descr_decisions_ues: ue_id=%s decisions_ue=%s" % (ue_id, decisions_ue))
@@ -543,7 +543,6 @@ def formsemestre_pvjury(
     )
     if format != "html":
         return tab.make_page(
-            context,
             format=format,
             with_html_headers=False,
             REQUEST=REQUEST,

app/scodoc/sco_report.py

@@ -357,7 +357,6 @@ def formsemestre_report_counts(
         F.append("</p></form>")
 
     t = tab.make_page(
-        context,
         title="""<h2 class="formsemestre">Comptes croisés</h2>""",
         format=format,
         REQUEST=REQUEST,

app/scodoc/sco_saisie_notes.py

@@ -171,9 +171,9 @@ def do_evaluation_upload_xls(context, REQUEST):
     evaluation_id = int(REQUEST.form["evaluation_id"])
     comment = REQUEST.form["comment"]
     E = sco_evaluations.do_evaluation_list({"evaluation_id": evaluation_id})[0]
-    M = sco_moduleimpl.do_moduleimpl_withmodule_list(
+    M = sco_moduleimpl.do_moduleimpl_withmodule_list(moduleimpl_id=E["moduleimpl_id"])[
-        context, moduleimpl_id=E["moduleimpl_id"]
+        0
-    )[0]
+    ]
     # Check access
     # (admin, respformation, and responsable_id)
     if not sco_permissions_check.can_edit_notes(authuser, E["moduleimpl_id"]):
@@ -248,12 +248,8 @@ def do_evaluation_upload_xls(context, REQUEST):
             )
             # news
             E = sco_evaluations.do_evaluation_list({"evaluation_id": evaluation_id})[0]
-            M = sco_moduleimpl.do_moduleimpl_list(
+            M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=E["moduleimpl_id"])[0]
-                context, moduleimpl_id=E["moduleimpl_id"]
+            mod = sco_edit_module.do_module_list(args={"module_id": M["module_id"]})[0]
-            )[0]
-            mod = sco_edit_module.do_module_list(
-                context, args={"module_id": M["module_id"]}
-            )[0]
             mod["moduleimpl_id"] = M["moduleimpl_id"]
             mod["url"] = "Notes/moduleimpl_status?moduleimpl_id=%(moduleimpl_id)s" % mod
             sco_news.add(
@@ -289,9 +285,9 @@ def do_evaluation_set_missing(evaluation_id, value, dialog_confirmed=False):
     # ? evaluation_id = REQUEST.form["evaluation_id"]
     context = None  # XXX #context
     E = sco_evaluations.do_evaluation_list({"evaluation_id": evaluation_id})[0]
-    M = sco_moduleimpl.do_moduleimpl_withmodule_list(
+    M = sco_moduleimpl.do_moduleimpl_withmodule_list(moduleimpl_id=E["moduleimpl_id"])[
-        context, moduleimpl_id=E["moduleimpl_id"]
+        0
-    )[0]
+    ]
     # Check access
     # (admin, respformation, and responsable_id)
     if not sco_permissions_check.can_edit_notes(current_user, E["moduleimpl_id"]):
@@ -337,8 +333,8 @@ def do_evaluation_set_missing(evaluation_id, value, dialog_confirmed=False):
     comment = "Initialisation notes manquantes"
     nb_changed, _, _ = _notes_add(context, current_user, evaluation_id, L, comment)
     # news
-    M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=E["moduleimpl_id"])[0]
+    M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=E["moduleimpl_id"])[0]
-    mod = sco_edit_module.do_module_list(context, args={"module_id": M["module_id"]})[0]
+    mod = sco_edit_module.do_module_list(args={"module_id": M["module_id"]})[0]
     mod["moduleimpl_id"] = M["moduleimpl_id"]
     mod["url"] = "Notes/moduleimpl_status?moduleimpl_id=%(moduleimpl_id)s" % mod
     sco_news.add(
@@ -415,8 +411,8 @@ def evaluation_suppress_alln(evaluation_id, dialog_confirmed=False):
         % E["moduleimpl_id"]
     ]
     # news
-    M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=E["moduleimpl_id"])[0]
+    M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=E["moduleimpl_id"])[0]
-    mod = sco_edit_module.do_module_list(context, args={"module_id": M["module_id"]})[0]
+    mod = sco_edit_module.do_module_list(args={"module_id": M["module_id"]})[0]
     mod["moduleimpl_id"] = M["moduleimpl_id"]
     mod["url"] = "Notes/moduleimpl_status?moduleimpl_id=%(moduleimpl_id)s" % mod
     sco_news.add(
@@ -464,7 +460,7 @@ def _notes_add(
     nb_changed = 0
     nb_suppress = 0
     E = sco_evaluations.do_evaluation_list({"evaluation_id": evaluation_id})[0]
-    M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=E["moduleimpl_id"])[0]
+    M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=E["moduleimpl_id"])[0]
     existing_decisions = (
         []
     )  # etudids pour lesquels il y a une decision de jury et que la note change
@@ -586,7 +582,7 @@ def saisie_notes_tableur(context, evaluation_id, group_ids=[], REQUEST=None):
     if not evals:
         raise ScoValueError("invalid evaluation_id")
     E = evals[0]
-    M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=E["moduleimpl_id"])[0]
+    M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=E["moduleimpl_id"])[0]
     formsemestre_id = M["formsemestre_id"]
     if not sco_permissions_check.can_edit_notes(authuser, E["moduleimpl_id"]):
         return (
@@ -760,9 +756,9 @@ def feuille_saisie_notes(context, evaluation_id, group_ids=[], REQUEST=None):
     if not evals:
         raise ScoValueError("invalid evaluation_id")
     E = evals[0]
-    M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=E["moduleimpl_id"])[0]
+    M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=E["moduleimpl_id"])[0]
     formsemestre_id = M["formsemestre_id"]
-    Mod = sco_edit_module.do_module_list(context, args={"module_id": M["module_id"]})[0]
+    Mod = sco_edit_module.do_module_list(args={"module_id": M["module_id"]})[0]
     sem = sco_formsemestre.get_formsemestre(M["formsemestre_id"])
     mod_responsable = sco_users.user_info(M["responsable_id"])
     if E["jour"]:
@@ -841,7 +837,7 @@ def has_existing_decision(context, M, E, etudid):
         return True
     dec_ues = nt.get_etud_decision_ues(etudid)
     if dec_ues:
-        mod = sco_edit_module.do_module_list(context, {"module_id": M["module_id"]})[0]
+        mod = sco_edit_module.do_module_list({"module_id": M["module_id"]})[0]
         ue_id = mod["ue_id"]
         if ue_id in dec_ues:
             return True  # decision pour l'UE a laquelle appartient cette evaluation
@@ -862,9 +858,9 @@ def saisie_notes(context, evaluation_id, group_ids=[], REQUEST=None):
     if not evals:
         raise ScoValueError("invalid evaluation_id")
     E = evals[0]
-    M = sco_moduleimpl.do_moduleimpl_withmodule_list(
+    M = sco_moduleimpl.do_moduleimpl_withmodule_list(moduleimpl_id=E["moduleimpl_id"])[
-        context, moduleimpl_id=E["moduleimpl_id"]
+        0
-    )[0]
+    ]
     formsemestre_id = M["formsemestre_id"]
     # Check access
     # (admin, respformation, and responsable_id)
@@ -1225,8 +1221,8 @@ def save_note(
         % (evaluation_id, etudid, authuser, value)
     )
     E = sco_evaluations.do_evaluation_list({"evaluation_id": evaluation_id})[0]
-    M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=E["moduleimpl_id"])[0]
+    M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=E["moduleimpl_id"])[0]
-    Mod = sco_edit_module.do_module_list(context, args={"module_id": M["module_id"]})[0]
+    Mod = sco_edit_module.do_module_list(args={"module_id": M["module_id"]})[0]
     Mod["url"] = "Notes/moduleimpl_status?moduleimpl_id=%(moduleimpl_id)s" % M
     result = {"nbchanged": 0}  # JSON
     # Check access: admin, respformation, or responsable_id

app/scodoc/sco_tag_module.py

@@ -212,7 +212,7 @@ def module_tag_search(context, term, REQUEST=None):
     return scu.sendJSON(REQUEST, data)
 
 
-def module_tag_list(context, module_id=""):
+def module_tag_list(module_id=""):
     """les noms de tags associés à ce module"""
     r = ndb.SimpleDictFetch(
         """SELECT t.title
@@ -225,11 +225,12 @@ def module_tag_list(context, module_id=""):
     return [x["title"] for x in r]
 
 
-def module_tag_set(context, module_id="", taglist=None):
+def module_tag_set(module_id="", taglist=None):
     """taglist may either be:
     a string with tag names separated by commas ("un;deux")
     or a list of strings (["un", "deux"])
     """
+    context = None  # #context
     if not taglist:
         taglist = []
     elif isinstance(taglist, str):
@@ -237,12 +238,12 @@ def module_tag_set(context, module_id="", taglist=None):
     taglist = [t.strip() for t in taglist]
     # log("module_tag_set: module_id=%s taglist=%s" % (module_id, taglist))
     # Sanity check:
-    Mod = sco_edit_module.do_module_list(context, args={"module_id": module_id})
+    Mod = sco_edit_module.do_module_list(args={"module_id": module_id})
     if not Mod:
         raise ScoValueError("invalid module !")
 
     newtags = set(taglist)
-    oldtags = set(module_tag_list(context, module_id))
+    oldtags = set(module_tag_list(module_id))
     to_del = oldtags - newtags
     to_add = newtags - oldtags
 
@@ -267,7 +268,7 @@ def get_etud_tagged_modules(context, etudid, tagname):
         nt = sco_cache.NotesTableCache.get(sem["formsemestre_id"])
         modimpls = nt.get_modimpls()
         for modimpl in modimpls:
-            tags = module_tag_list(context, module_id=modimpl["module_id"])
+            tags = module_tag_list(module_id=modimpl["module_id"])
             if tagname in tags:
                 moy = nt.get_etud_mod_moy(
                     modimpl["moduleimpl_id"], etudid

app/scodoc/sco_ue_external.py

@@ -95,11 +95,8 @@ def external_ue_create(
     formation_id = sem["formation_id"]
     log("creating external UE in %s: %s" % (formsemestre_id, acronyme))
 
-    numero = sco_edit_ue.next_ue_numero(
+    numero = sco_edit_ue.next_ue_numero(formation_id, semestre_id=sem["semestre_id"])
-        context, formation_id, semestre_id=sem["semestre_id"]
-    )
     ue_id = sco_edit_ue.do_ue_create(
-        context,
         {
             "formation_id": formation_id,
             "titre": titre,
@@ -112,11 +109,10 @@ def external_ue_create(
     )
 
     matiere_id = sco_edit_matiere.do_matiere_create(
-        context, {"ue_id": ue_id, "titre": titre or acronyme, "numero": 1}
+        {"ue_id": ue_id, "titre": titre or acronyme, "numero": 1}
     )
 
     module_id = sco_edit_module.do_module_create(
-        context,
         {
             "titre": "UE extérieure",
             "code": acronyme,
@@ -129,7 +125,6 @@ def external_ue_create(
     )
 
     moduleimpl_id = sco_moduleimpl.do_moduleimpl_create(
-        context,
         {
             "module_id": module_id,
             "formsemestre_id": formsemestre_id,
@@ -151,7 +146,6 @@ def external_ue_inscrit_et_note(
     )
     # Inscription des étudiants
     sco_moduleimpl.do_moduleimpl_inscrit_etuds(
-        context,
         moduleimpl_id,
         formsemestre_id,
         list(notes_etuds.keys()),
@@ -188,7 +182,7 @@ def external_ue_inscrit_et_note(
 def get_existing_external_ue(context, formation_id):
     "la liste de toutes les UE externes définies dans cette formation"
     return sco_edit_ue.do_ue_list(
-        context, args={"formation_id": formation_id, "is_external": True}
+        args={"formation_id": formation_id, "is_external": True}
     )
 
 

app/scodoc/sco_undo_notes.py

@@ -147,7 +147,7 @@ def list_operations(context, evaluation_id):
 def evaluation_list_operations(context, REQUEST, evaluation_id):
     """Page listing operations on evaluation"""
     E = sco_evaluations.do_evaluation_list({"evaluation_id": evaluation_id})[0]
-    M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=E["moduleimpl_id"])[0]
+    M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=E["moduleimpl_id"])[0]
 
     Ops = list_operations(context, evaluation_id)
 

app/scodoc/sco_users.py

@@ -214,9 +214,7 @@ def list_users(
         preferences=sco_preferences.SemPreferences(context),
     )
 
-    return tab.make_page(
+    return tab.make_page(format=format, with_html_headers=False, REQUEST=REQUEST)
-        context, format=format, with_html_headers=False, REQUEST=REQUEST
-    )
 
 
 def get_user_list(dept=None, with_inactives=False):

app/views/absences.py

@@ -353,7 +353,7 @@ def SignaleAbsenceGrHebdo(
             [
                 x["etudid"]
                 for x in sco_moduleimpl.do_moduleimpl_inscription_list(
-                    context, moduleimpl_id=moduleimpl_id
+                    moduleimpl_id=moduleimpl_id
                 )
             ]
         )
@@ -512,7 +512,7 @@ def SignaleAbsenceGrSemestre(
             [
                 x["etudid"]
                 for x in sco_moduleimpl.do_moduleimpl_inscription_list(
-                    context, moduleimpl_id=moduleimpl_id
+                    moduleimpl_id=moduleimpl_id
                 )
             ]
         )

app/views/notes.py

@@ -394,7 +394,7 @@ def index_html(context, REQUEST=None):
         """<h2>Programmes pédagogiques</h2>
             """,
     ]
-    T = sco_formations.formation_list_table(context, REQUEST=REQUEST)
+    T = sco_formations.formation_list_table(REQUEST=REQUEST)
 
     H.append(T.html())
 
@@ -437,7 +437,7 @@ sco_publish(
 @scodoc
 @permission_required(Permission.ScoView)
 @scodoc7func(context)
-def formation_list(context, format=None, REQUEST=None, formation_id=None, args={}):
+def formation_list(format=None, REQUEST=None, formation_id=None, args={}):
     """List formation(s) with given id, or matching args
     (when args is given, formation_id is ignored).
     """
@@ -454,7 +454,7 @@ def formation_export(
 ):
     "Export de la formation au format indiqué (xml ou json)"
     return sco_formations.formation_export(
-        context, formation_id, export_ids=export_ids, format=format, REQUEST=REQUEST
+        formation_id, export_ids=export_ids, format=format, REQUEST=REQUEST
     )
 
 
@@ -462,11 +462,11 @@ def formation_export(
 @scodoc
 @permission_required(Permission.ScoChangeFormation)
 @scodoc7func(context)
-def formation_import_xml(context, file):
+def formation_import_xml(file):
     "import d'une formation en XML"
     log("formation_import_xml")
     doc = file.read()
-    return sco_formations.formation_import_xml(context, doc)
+    return sco_formations.formation_import_xml(doc)
 
 
 @bp.route("/formation_import_xml_form", methods=["GET", "POST"])
@@ -681,7 +681,7 @@ def formsemestre_custommenu_edit(context, REQUEST, formsemestre_id):
 @scodoc7func(context)
 def edit_enseignants_form(context, REQUEST, moduleimpl_id):
     "modif liste enseignants/moduleimpl"
-    M, sem = sco_moduleimpl.can_change_ens(context, REQUEST, moduleimpl_id)
+    M, sem = sco_moduleimpl.can_change_ens(REQUEST, moduleimpl_id)
     # --
     header = html_sco_header.html_sem_header(
         context,
@@ -778,7 +778,7 @@ def edit_enseignants_form(context, REQUEST, moduleimpl_id):
                 )
             else:
                 sco_moduleimpl.do_ens_create(
-                    context, {"moduleimpl_id": moduleimpl_id, "ens_id": ens_id}
+                    {"moduleimpl_id": moduleimpl_id, "ens_id": ens_id}
                 )
                 return flask.redirect(
                     "edit_enseignants_form?moduleimpl_id=%s" % moduleimpl_id
@@ -794,7 +794,7 @@ def edit_moduleimpl_resp(context, REQUEST, moduleimpl_id):
     """Changement d'un enseignant responsable de module
     Accessible par Admin et dir des etud si flag resp_can_change_ens
     """
-    M, sem = sco_moduleimpl.can_change_module_resp(context, REQUEST, moduleimpl_id)
+    M, sem = sco_moduleimpl.can_change_module_resp(REQUEST, moduleimpl_id)
     H = [
         html_sco_header.html_sem_header(
             context,
@@ -861,7 +861,6 @@ def edit_moduleimpl_resp(context, REQUEST, moduleimpl_id):
         ):  # presque impossible: tf verifie les valeurs (mais qui peuvent changer entre temps)
             return flask.redirect("moduleimpl_status?moduleimpl_id=" + moduleimpl_id)
         sco_moduleimpl.do_moduleimpl_edit(
-            context,
             {"moduleimpl_id": moduleimpl_id, "responsable_id": responsable_id},
             formsemestre_id=sem["formsemestre_id"],
         )
@@ -902,7 +901,7 @@ def edit_moduleimpl_expr(context, REQUEST, moduleimpl_id):
     """Edition formule calcul moyenne module
     Accessible par Admin, dir des etud et responsable module
     """
-    M, sem = sco_moduleimpl.can_change_ens(context, REQUEST, moduleimpl_id)
+    M, sem = sco_moduleimpl.can_change_ens(REQUEST, moduleimpl_id)
     H = [
         html_sco_header.html_sem_header(
             context,
@@ -946,7 +945,6 @@ def edit_moduleimpl_expr(context, REQUEST, moduleimpl_id):
         return flask.redirect("moduleimpl_status?moduleimpl_id=" + moduleimpl_id)
     else:
         sco_moduleimpl.do_moduleimpl_edit(
-            context,
             {
                 "moduleimpl_id": moduleimpl_id,
                 "computation_expr": tf[2]["computation_expr"],
@@ -969,13 +967,11 @@ def edit_moduleimpl_expr(context, REQUEST, moduleimpl_id):
 @scodoc7func(context)
 def view_module_abs(context, REQUEST, moduleimpl_id, format="html"):
     """Visualisation des absences a un module"""
-    M = sco_moduleimpl.do_moduleimpl_withmodule_list(
+    M = sco_moduleimpl.do_moduleimpl_withmodule_list(moduleimpl_id=moduleimpl_id)[0]
-        context, moduleimpl_id=moduleimpl_id
-    )[0]
     sem = sco_formsemestre.get_formsemestre(M["formsemestre_id"])
     debut_sem = ndb.DateDMYtoISO(sem["date_debut"])
     fin_sem = ndb.DateDMYtoISO(sem["date_fin"])
-    list_insc = sco_moduleimpl.do_moduleimpl_listeetuds(context, moduleimpl_id)
+    list_insc = sco_moduleimpl.do_moduleimpl_listeetuds(moduleimpl_id)
 
     T = []
     for etudid in list_insc:
@@ -1051,12 +1047,12 @@ def view_module_abs(context, REQUEST, moduleimpl_id, format="html"):
 def edit_ue_expr(context, REQUEST, formsemestre_id, ue_id):
     """Edition formule calcul moyenne UE"""
     # Check access
-    sem = sco_formsemestre_edit.can_edit_sem(context, REQUEST, formsemestre_id)
+    sem = sco_formsemestre_edit.can_edit_sem(REQUEST, formsemestre_id)
     if not sem:
         raise AccessDenied("vous n'avez pas le droit d'effectuer cette opération")
     cnx = ndb.GetDBConnexion()
     #
-    ue = sco_edit_ue.do_ue_list(context, {"ue_id": ue_id})[0]
+    ue = sco_edit_ue.do_ue_list({"ue_id": ue_id})[0]
     H = [
         html_sco_header.html_sem_header(
             context,
@@ -1129,9 +1125,7 @@ def formsemestre_enseignants_list(context, REQUEST, formsemestre_id, format="htm
     """
     sem = sco_formsemestre.get_formsemestre(formsemestre_id)
     # resp. de modules:
-    mods = sco_moduleimpl.do_moduleimpl_withmodule_list(
+    mods = sco_moduleimpl.do_moduleimpl_withmodule_list(formsemestre_id=formsemestre_id)
-        context, formsemestre_id=formsemestre_id
-    )
     sem_ens = {}
     for mod in mods:
         if not mod["responsable_id"] in sem_ens:
@@ -1210,7 +1204,7 @@ def formsemestre_enseignants_list(context, REQUEST, formsemestre_id, format="htm
         preferences=sco_preferences.SemPreferences(formsemestre_id),
     )
     return T.make_page(
-        context, page_title=title, title=title, REQUEST=REQUEST, format=format
+        page_title=title, title=title, REQUEST=REQUEST, format=format
     )
 
 
@@ -1223,7 +1217,7 @@ def edit_enseignants_form_delete(context, REQUEST, moduleimpl_id, ens_id: int):
 
     ens_id:  user.id
     """
-    M, _ = sco_moduleimpl.can_change_ens(context, REQUEST, moduleimpl_id)
+    M, _ = sco_moduleimpl.can_change_ens(REQUEST, moduleimpl_id)
     # search ens_id
     ok = False
     for ens in M["ens"]:
@@ -1268,7 +1262,7 @@ sco_publish(
 @permission_required(Permission.ScoView)
 @scodoc7func(context)
 def do_formsemestre_inscription_listinscrits(
-    context, formsemestre_id, format=None, REQUEST=None
+    formsemestre_id, format=None, REQUEST=None
 ):
     """Liste les inscrits (état I) à ce semestre et cache le résultat"""
     r = sco_formsemestre_inscriptions.do_formsemestre_inscription_listinscrits(
@@ -1454,8 +1448,8 @@ def evaluation_delete(context, REQUEST, evaluation_id):
     if not El:
         raise ValueError("Evalution inexistante ! (%s)" % evaluation_id)
     E = El[0]
-    M = sco_moduleimpl.do_moduleimpl_list(context, moduleimpl_id=E["moduleimpl_id"])[0]
+    M = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=E["moduleimpl_id"])[0]
-    Mod = sco_edit_module.do_module_list(context, args={"module_id": M["module_id"]})[0]
+    Mod = sco_edit_module.do_module_list(args={"module_id": M["module_id"]})[0]
     tit = "Suppression de l'évaluation %(description)s (%(jour)s)" % E
     etat = sco_evaluations.do_evaluation_etat(evaluation_id)
     H = [
@@ -2378,18 +2372,14 @@ def check_sem_integrity(context, formsemestre_id, REQUEST, fix=False):
     """
     sem = sco_formsemestre.get_formsemestre(formsemestre_id)
 
-    modimpls = sco_moduleimpl.do_moduleimpl_list(
+    modimpls = sco_moduleimpl.do_moduleimpl_list(formsemestre_id=formsemestre_id)
-        context, formsemestre_id=formsemestre_id
-    )
     bad_ue = []
     bad_sem = []
     formations_set = set()  # les formations mentionnées dans les UE et modules
     for modimpl in modimpls:
-        mod = sco_edit_module.do_module_list(
+        mod = sco_edit_module.do_module_list({"module_id": modimpl["module_id"]})[0]
-            context, {"module_id": modimpl["module_id"]}
-        )[0]
         formations_set.add(mod["formation_id"])
-        ue = sco_edit_ue.do_ue_list(context, {"ue_id": mod["ue_id"]})[0]
+        ue = sco_edit_ue.do_ue_list({"ue_id": mod["ue_id"]})[0]
         formations_set.add(ue["formation_id"])
         if ue["formation_id"] != mod["formation_id"]:
             modimpl["mod"] = mod
@@ -2448,14 +2438,12 @@ def check_sem_integrity(context, formsemestre_id, REQUEST, fix=False):
 def check_form_integrity(context, formation_id, fix=False, REQUEST=None):
     "debug"
     log("check_form_integrity: formation_id=%s  fix=%s" % (formation_id, fix))
-    ues = sco_edit_ue.do_ue_list(context, args={"formation_id": formation_id})
+    ues = sco_edit_ue.do_ue_list(args={"formation_id": formation_id})
     bad = []
     for ue in ues:
-        mats = sco_edit_matiere.do_matiere_list(context, args={"ue_id": ue["ue_id"]})
+        mats = sco_edit_matiere.do_matiere_list(args={"ue_id": ue["ue_id"]})
         for mat in mats:
-            mods = sco_edit_module.do_module_list(
+            mods = sco_edit_module.do_module_list({"matiere_id": mat["matiere_id"]})
-                context, {"matiere_id": mat["matiere_id"]}
-            )
             for mod in mods:
                 if mod["ue_id"] != ue["ue_id"]:
                     if fix:
@@ -2464,7 +2452,7 @@ def check_form_integrity(context, formation_id, fix=False, REQUEST=None):
                             "fix: mod.ue_id = %s (was %s)" % (ue["ue_id"], mod["ue_id"])
                         )
                         mod["ue_id"] = ue["ue_id"]
-                        sco_edit_module.do_module_edit(context, mod)
+                        sco_edit_module.do_module_edit(mod)
                     bad.append(mod)
                 if mod["formation_id"] != formation_id:
                     bad.append(mod)
@@ -2495,7 +2483,7 @@ def check_formsemestre_integrity(context, formsemestre_id, REQUEST=None):
     diag = []
 
     Mlist = sco_moduleimpl.do_moduleimpl_withmodule_list(
-        context, formsemestre_id=formsemestre_id
+        formsemestre_id=formsemestre_id
     )
     for mod in Mlist:
         if mod["module"]["ue_id"] != mod["matiere"]["ue_id"]:

scotests/test_api7doc.py

@@ -20,7 +20,7 @@ file.close()
 
 # --- Création de la formation
 
-f = sco_formations.formation_import_xml(doc=doc, context=context.Notes)
+f = sco_formations.formation_import_xml(doc=doc)
 
 # --- Création des semestres
 
@@ -222,9 +222,7 @@ load_lif = json.loads(lif)
 assert len(load_lif) == 1
 assert load_lif[0]["formation_id"] == f[0]
 
-exp = sco_formations.formation_export(
+exp = sco_formations.formation_export(formation_id=f[0], format="json", REQUEST=REQUEST)
-    context.Notes, formation_id=f[0], format="json", REQUEST=REQUEST
-)
 load_exp = json.loads(exp)
 assert load_exp["acronyme"] == "DUT Info"
 assert load_exp["titre_officiel"] == "DUT Informatique"

scotests/test_bonusmalus.py

@@ -48,8 +48,7 @@ sem, eval_list = G.setup_formsemestre(
 )
 
 # --- Recupère le module de malus
-modimpls = sco_moduleimpl.do_moduleimpl_list(
+modimpls = sco_moduleimpl.do_moduleimpl_list(  # pylint: disable=undefined-variable
-    context,  # pylint: disable=undefined-variable
     formsemestre_id=sem["formsemestre_id"],
 )
 # de façon tout à fait inefficace ;-)

scotests/test_formation_export_xml.py

@@ -19,7 +19,7 @@ print(doc)
 print("\n \n \n")
 # --- Création de la formation
 
-f = sco_formations.formation_import_xml(doc=doc, context=context.Notes)
+f = sco_formations.formation_import_xml(doc=doc)
 
 
 # --- Création des semestres
@@ -76,7 +76,7 @@ for mod in li_module:
 
 # --- Test de export_formation format xml
 
-form_exp = context.Notes.formation_export(
+form_exp = sco_formations.formation_export(
     formation_id=f[0], format="xml", REQUEST=REQUEST
 )
 print(form_exp[39:])

scotests/test_scenario2_formation.py

@@ -18,7 +18,7 @@ file.close()
 
 # --- Création de la formation
 
-f = sco_formations.formation_import_xml(doc=doc, context=context.Notes)
+f = sco_formations.formation_import_xml(doc=doc)
 
 # --- Création des semestres
 

scotests/test_scenario3_formation.py

@@ -19,7 +19,7 @@ file.close()
 
 # --- Création de la formation
 
-f = sco_formations.formation_import_xml(doc=doc, context=context.Notes)
+f = sco_formations.formation_import_xml(doc=doc)
 
 # --- Création des semestres
 

scotests/test_scenario4_formation.py

@@ -19,7 +19,7 @@ file.close()
 
 # --- Création de la formation
 
-f = sco_formations.formation_import_xml(doc=doc, context=context.Notes)
+f = sco_formations.formation_import_xml(doc=doc)
 
 # --- Création des semestres
 

tests/scenarios/test_scenario1_formation.py

@@ -33,7 +33,7 @@ def run_scenario1():
         doc = f.read()
 
     # --- Création de la formation
-    f = sco_formations.formation_import_xml(doc=doc, context=context)
+    f = sco_formations.formation_import_xml(doc=doc)
 
     # --- Création des semestres
     formation_id = f[0]
@@ -54,7 +54,7 @@ def run_scenario1():
     ]
 
     # --- Implémentation des modules
-    modules = sco_edit_module.do_module_list(context, {"formation_id": formation_id})
+    modules = sco_edit_module.do_module_list({"formation_id": formation_id})
     mods_imp = []
     for mod in modules:
         mi = G.create_moduleimpl(

tests/unit/sco_fake_gen.py

@@ -153,7 +153,7 @@ class ScoFake(object):
         """Crée une formation"""
         if not acronyme:
             acronyme = "TEST" + str(random.randint(100000, 999999))
-        oid = sco_edit_formation.do_formation_create(context, locals())
+        oid = sco_edit_formation.do_formation_create(locals())
         oids = sco_formations.formation_list(formation_id=oid)
         if not oids:
             raise ScoValueError("formation not created !")
@@ -175,17 +175,17 @@ class ScoFake(object):
     ):
         """Crée une UE"""
         if numero is None:
-            numero = sco_edit_ue.next_ue_numero(context, formation_id, 0)
+            numero = sco_edit_ue.next_ue_numero(formation_id, 0)
-        oid = sco_edit_ue.do_ue_create(context, locals())
+        oid = sco_edit_ue.do_ue_create(locals())
-        oids = sco_edit_ue.do_ue_list(context, args={"ue_id": oid})
+        oids = sco_edit_ue.do_ue_list(args={"ue_id": oid})
         if not oids:
             raise ScoValueError("ue not created !")
         return oids[0]
 
     @logging_meth
     def create_matiere(self, ue_id=None, titre=None, numero=None):
-        oid = sco_edit_matiere.do_matiere_create(context, locals())
+        oid = sco_edit_matiere.do_matiere_create(locals())
-        oids = sco_edit_matiere.do_matiere_list(context, args={"matiere_id": oid})
+        oids = sco_edit_matiere.do_matiere_list(args={"matiere_id": oid})
         if not oids:
             raise ScoValueError("matiere not created !")
         return oids[0]
@@ -209,8 +209,8 @@ class ScoFake(object):
         code_apogee=None,
         module_type=None,
     ):
-        oid = sco_edit_module.do_module_create(context, locals())
+        oid = sco_edit_module.do_module_create(locals())
-        oids = sco_edit_module.do_module_list(context, args={"module_id": oid})
+        oids = sco_edit_module.do_module_list(args={"module_id": oid})
         if not oids:
             raise ScoValueError("module not created ! (oid=%s)" % oid)
         return oids[0]
@@ -256,10 +256,8 @@ class ScoFake(object):
     ):
         if not responsable_id:
             responsable_id = self.default_user.id
-        oid = sco_moduleimpl.do_moduleimpl_create(context, locals())
+        oid = sco_moduleimpl.do_moduleimpl_create(locals())
-        oids = sco_moduleimpl.do_moduleimpl_list(
+        oids = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=oid)  # API inconsistency
-            context, moduleimpl_id=oid
-        )  # API inconsistency
         if not oids:
             raise ScoValueError("moduleimpl not created !")
         return oids[0]

tests/unit/test_caches.py

@@ -54,7 +54,7 @@ def test_cache_evaluations(test_client):
     # prépare le département avec quelques semestres:
     run_sco_basic()
     #
-    sems = sco_formsemestre.do_formsemestre_list(None)
+    sems = sco_formsemestre.do_formsemestre_list()
     assert len(sems)
     sem_evals = []
     for sem in sems:

tests/unit/test_departements.py

@@ -16,6 +16,8 @@ from app.scodoc import sco_formsemestre
 from app.scodoc import sco_preferences
 from tests.unit import test_sco_basic
 
+context = None  # #context
+
 
 def test_preferences_orm(test_client):
     """preferences, via ORM and legacy ScoDoc"""
@@ -59,7 +61,7 @@ def test_preferences(test_client):
         .value
     )
     # Compare valeurs
-    sco_val = prefs.get(None, "abs_notification_mail_tmpl")
+    sco_val = prefs.get(context, "abs_notification_mail_tmpl")
     assert orm_val.strip() == sco_val.strip()
     # nb: I don't understand why SQLAlchemy strips the string ?!
 
@@ -71,9 +73,9 @@ def test_preferences(test_client):
     app.set_sco_dept("D2")
     prefs2 = sco_preferences.get_base_preferences()
     assert len(prefs2) == len(prefs)
-    prefs2.set(None, "abs_notification_mail_tmpl", "toto")
+    prefs2.set(context, "abs_notification_mail_tmpl", "toto")
-    assert prefs2.get(None, "abs_notification_mail_tmpl") == "toto"
+    assert prefs2.get(context, "abs_notification_mail_tmpl") == "toto"
-    assert prefs.get(None, "abs_notification_mail_tmpl") != "toto"
+    assert prefs.get(context, "abs_notification_mail_tmpl") != "toto"
     orm_val = (
         ScoPreference.query.filter_by(dept_id=d.id, name="abs_notification_mail_tmpl")
         .first()
@@ -83,7 +85,7 @@ def test_preferences(test_client):
     # --- Preferences d'un semestre
     # rejoure ce test pour avoir un semestre créé
     test_sco_basic.run_sco_basic()
-    sem = sco_formsemestre.do_formsemestre_list(None)[0]
+    sem = sco_formsemestre.do_formsemestre_list()[0]
     formsemestre_id = sem["formsemestre_id"]
     semp = sco_preferences.SemPreferences(formsemestre_id=formsemestre_id)
     assert semp["abs_notification_mail_tmpl"] == "toto"

tests/unit/test_export_xml.py

@@ -98,7 +98,7 @@ def test_export_xml(test_client):
 
     # test du sendXML compatible ScoDoc7
     etuds = [{"x": 1, "etuds": ["allo", "mama"]}, {"x": 2, "etuds": ["un", "deux"]}]
-    # Le résultat de l'ancien print(sendXML(None, etuds, tagname="etudiants"))
+    # Le résultat de l'ancien print(sendXML(etuds, tagname="etudiants"))
     expected_result = """
     <?xml version="1.0" encoding="utf-8"?>
     <etudiants_list>

tests/unit/test_formations.py

@@ -164,7 +164,7 @@ def test_formations(test_client):
 
     # --- Afficher la liste des formations
 
-    lif = notes.formation_list(context, format="json", formation_id=f["formation_id"])
+    lif = notes.formation_list(format="json", formation_id=f["formation_id"])
     # lif est une Response car on a appelé une vue (1er appel)
     assert isinstance(lif, flask.Response)
     load_lif = json.loads(lif.get_data().decode("utf-8"))
@@ -174,7 +174,7 @@ def test_formations(test_client):
     assert load_lif[0]["formation_id"] == f["formation_id"]
     assert load_lif[0]["titre"] == f["titre"]
 
-    lif2 = notes.formation_list(context, format="json")
+    lif2 = notes.formation_list(format="json")
     # lif2 est un chaine
     assert isinstance(lif2, str)
     load_lif2 = json.loads(lif2)
@@ -184,9 +184,7 @@ def test_formations(test_client):
 
     # --- Export de formation_id
 
-    exp = sco_formations.formation_export(
+    exp = sco_formations.formation_export(formation_id=f["formation_id"], format="json")
-        context, formation_id=f["formation_id"], format="json"
-    )
     assert isinstance(exp, str)
     load_exp = json.loads(exp)
 
@@ -235,19 +233,19 @@ def test_formations(test_client):
     # --- Liste des modules
 
     lim_sem1 = sco_moduleimpl.do_moduleimpl_list(
-        context, formsemestre_id=sem1["formsemestre_id"]
+        formsemestre_id=sem1["formsemestre_id"]
     )
 
     assert len(lim_sem1) == 2
     assert mod["module_id"] in (lim_sem1[0]["module_id"], lim_sem1[1]["module_id"])
     assert mod2["module_id"] in (lim_sem1[0]["module_id"], lim_sem1[1]["module_id"])
 
-    lim_modid = sco_moduleimpl.do_moduleimpl_list(context, module_id=mod["module_id"])
+    lim_modid = sco_moduleimpl.do_moduleimpl_list(module_id=mod["module_id"])
 
     assert len(lim_modid) == 1
 
     lim_modimpl_id = sco_moduleimpl.do_moduleimpl_list(
-        context, moduleimpl_id=mi["moduleimpl_id"]
+        moduleimpl_id=mi["moduleimpl_id"]
     )
     # print(lim_modimpl_id)
 
@@ -256,7 +254,7 @@ def test_formations(test_client):
     assert lim_modid == lim_modimpl_id  # doit etre le meme resultat
 
     liimp_sem1 = sco_moduleimpl.do_moduleimpl_withmodule_list(
-        context, formsemestre_id=sem1["formsemestre_id"]
+        formsemestre_id=sem1["formsemestre_id"]
     )
 
     assert len(liimp_sem1) == 2
@@ -266,16 +264,16 @@ def test_formations(test_client):
         liimp_sem1[1]["module_id"],
     )
     liimp_sem2 = sco_moduleimpl.do_moduleimpl_withmodule_list(
-        context, formsemestre_id=sem2["formsemestre_id"]
+        formsemestre_id=sem2["formsemestre_id"]
     )
     assert modt["module_id"] == liimp_sem2[0]["module_id"]
     liimp_modid = sco_moduleimpl.do_moduleimpl_withmodule_list(
-        context, module_id=mod["module_id"]
+        module_id=mod["module_id"]
     )
     assert len(liimp_modid) == 1
 
     liimp_modimplid = sco_moduleimpl.do_moduleimpl_withmodule_list(
-        context, moduleimpl_id=mi["moduleimpl_id"]
+        moduleimpl_id=mi["moduleimpl_id"]
     )
 
     assert liimp_modid == liimp_modimplid
@@ -299,35 +297,31 @@ def test_formations(test_client):
 
     # RIEN NE SE PASSE AVEC CES FONCTIONS
 
-    li_module = sco_edit_module.do_module_list(context)
+    li_module = sco_edit_module.do_module_list()
     assert len(li_module) == 4
-    sco_edit_module.do_module_delete(
+    sco_edit_module.do_module_delete(oid=modt["module_id"])  # on supprime le semestre
-        context, oid=modt["module_id"]
-    )  # on supprime le semestre
     # sco_formsemestre_edit.formsemestre_delete_moduleimpls(context.Notes, formsemestre_id=sem2["formsemestre_id"], module_ids_to_del=[modt["module_id"]])
     # deuxieme methode de supression d'un module
-    li_module2 = sco_edit_module.do_module_list(context)
+    li_module2 = sco_edit_module.do_module_list()
 
     assert len(li_module2) == 3  # verification de la suppression du module
 
     lim_sem2 = sco_moduleimpl.do_moduleimpl_list(
-        context, formsemestre_id=sem2["formsemestre_id"]
+        formsemestre_id=sem2["formsemestre_id"]
     )
 
     assert len(lim_sem2) == 0  # deuxieme vérification si le module s'est bien sup
 
-    li_mat = sco_edit_matiere.do_matiere_list(context)
+    li_mat = sco_edit_matiere.do_matiere_list()
     assert len(li_mat) == 4
-    sco_edit_matiere.do_matiere_delete(
+    sco_edit_matiere.do_matiere_delete(oid=matt["matiere_id"])  # on supprime la matiere
-        context, oid=matt["matiere_id"]
+    li_mat2 = sco_edit_matiere.do_matiere_list()
-    )  # on supprime la matiere
-    li_mat2 = sco_edit_matiere.do_matiere_list(context)
     assert len(li_mat2) == 3  # verification de la suppression de la matiere
 
-    li_ue = sco_edit_ue.do_ue_list(context)
+    li_ue = sco_edit_ue.do_ue_list()
     assert len(li_ue) == 4
-    sco_edit_ue.ue_delete(context, ue_id=uet["ue_id"], dialog_confirmed=True)
+    sco_edit_ue.ue_delete(ue_id=uet["ue_id"], dialog_confirmed=True)
-    li_ue2 = sco_edit_ue.do_ue_list(context)
+    li_ue2 = sco_edit_ue.do_ue_list()
     assert len(li_ue2) == 3  # verification de la suppression de l'UE
 
     # --- Suppression d'une formation
@@ -336,8 +330,8 @@ def test_formations(test_client):
         context, formsemestre_id=semt["formsemestre_id"]
     )
 
-    sco_edit_formation.do_formation_delete(context, oid=f2["formation_id"])
+    sco_edit_formation.do_formation_delete(oid=f2["formation_id"])
-    lif3 = notes.formation_list(context, format="json")
+    lif3 = notes.formation_list(format="json")
     assert isinstance(lif3, str)
     load_lif3 = json.loads(lif3)
     assert len(load_lif3) == 1
@@ -351,7 +345,7 @@ def test_import_formation(test_client):
         doc = f.read()
 
     # --- Création de la formation
-    f = sco_formations.formation_import_xml(context, doc)
+    f = sco_formations.formation_import_xml(doc)
     assert len(f) == 3  # 3-uple
     formation_id = f[0]
     # --- Mise en place de 4 semestres
@@ -370,7 +364,7 @@ def test_import_formation(test_client):
         )
     ]
     # et les modules
-    modules = sco_edit_module.do_module_list(context, {"formation_id": formation_id})
+    modules = sco_edit_module.do_module_list({"formation_id": formation_id})
     for mod in modules:
         mi = G.create_moduleimpl(
             module_id=mod["module_id"],
@@ -380,5 +374,5 @@ def test_import_formation(test_client):
         assert mi["module_id"] == mod["module_id"]
 
     # --- Export formation en XML
-    doc1 = sco_formations.formation_export(context, formation_id, format="xml")
+    doc1 = sco_formations.formation_export(formation_id, format="xml")
     assert isinstance(doc1, str)