Renommage dans UI et code des anciens 'Parcours' ScoDoc en 'Cursus'

app/but/apc_edit_ue.py

@@ -9,14 +9,14 @@ Edition associations UE <-> Ref. Compétence
 """
 from flask import g, url_for
 from app.models import ApcReferentielCompetences, Formation, UniteEns
-from app.scodoc import sco_codes_parcours
+from app.scodoc import codes_cursus
 
 
 def form_ue_choix_niveau(ue: UniteEns) -> str:
     """Form. HTML pour associer une UE à un niveau de compétence.
     Le menu select lui meême est vide et rempli en JS par appel à get_ue_niveaux_options_html
     """
-    if ue.type != sco_codes_parcours.UE_STANDARD:
+    if ue.type != codes_cursus.UE_STANDARD:
         return ""
     ref_comp = ue.formation.referentiel_competence
     if ref_comp is None:

app/but/bulletin_but.py

@@ -19,10 +19,10 @@ from app.models.ues import UniteEns
 from app.scodoc import sco_bulletins, sco_utils as scu
 from app.scodoc import sco_bulletins_json
 from app.scodoc import sco_bulletins_pdf
-from app.scodoc import sco_codes_parcours
+from app.scodoc import codes_cursus
 from app.scodoc import sco_groups
 from app.scodoc import sco_preferences
-from app.scodoc.sco_codes_parcours import UE_SPORT, DEF
+from app.scodoc.codes_cursus import UE_SPORT, DEF
 from app.scodoc.sco_utils import fmt_note
 
 
@@ -157,7 +157,7 @@ class BulletinBUT:
         for _, ue_capitalisee in self.res.validations.ue_capitalisees.loc[
             [etud.id]
         ].iterrows():
-            if sco_codes_parcours.code_ue_validant(ue_capitalisee.code):
+            if codes_cursus.code_ue_validant(ue_capitalisee.code):
                 ue = UniteEns.query.get(ue_capitalisee.ue_id)  # XXX cacher ?
                 # déjà capitalisé ? montre la meilleure
                 if ue.acronyme in d:

app/but/bulletin_but_pdf.py

@@ -12,7 +12,7 @@ from reportlab.platypus import Paragraph, Spacer
 
 from app.scodoc.sco_bulletins_standard import BulletinGeneratorStandard
 from app.scodoc import gen_tables
-from app.scodoc.sco_codes_parcours import UE_SPORT
+from app.scodoc.codes_cursus import UE_SPORT
 from app.scodoc import sco_utils as scu
 
 

app/but/bulletin_but_xml_compat.py

@@ -43,7 +43,7 @@ from app.but import bulletin_but
 from app.models import FormSemestre, Identite
 import app.scodoc.sco_utils as scu
 import app.scodoc.notesdb as ndb
-from app.scodoc import sco_codes_parcours
+from app.scodoc import codes_cursus
 from app.scodoc import sco_edit_ue
 from app.scodoc import sco_etud
 from app.scodoc import sco_photos
@@ -159,7 +159,7 @@ def bulletin_but_xml_compat(
                 code_apogee=quote_xml_attr(ue.code_apogee or ""),
             )
             doc.append(x_ue)
-            if ue.type != sco_codes_parcours.UE_SPORT:
+            if ue.type != codes_cursus.UE_SPORT:
                 v = results.etud_moy_ue[ue.id][etud.id]
                 vmin = results.etud_moy_ue[ue.id].min()
                 vmax = results.etud_moy_ue[ue.id].max()

app/but/cursus_but.py

@@ -44,8 +44,8 @@ from app.models.formations import Formation
 from app.models.formsemestre import FormSemestre, FormSemestreInscription
 from app.models.ues import UniteEns
 from app.models.validations import ScolarFormSemestreValidation
-from app.scodoc import sco_codes_parcours as sco_codes
-from app.scodoc.sco_codes_parcours import RED, UE_STANDARD
+from app.scodoc import codes_cursus as sco_codes
+from app.scodoc.codes_cursus import RED, UE_STANDARD
 from app.scodoc import sco_utils as scu
 from app.scodoc.sco_exceptions import ScoNoReferentielCompetences, ScoValueError
 

app/but/jury_but.py

@@ -90,8 +90,8 @@ from app.models.formsemestre import FormSemestre, FormSemestreInscription
 from app.models.ues import UniteEns
 from app.models.validations import ScolarFormSemestreValidation
 from app.scodoc import sco_cache
-from app.scodoc import sco_codes_parcours as sco_codes
-from app.scodoc.sco_codes_parcours import (
+from app.scodoc import codes_cursus as sco_codes
+from app.scodoc.codes_cursus import (
     BUT_CODES_ORDERED,
     CODES_RCUE_VALIDES,
     CODES_UE_CAPITALISANTS,
@@ -641,7 +641,7 @@ class DecisionsProposeesAnnee(DecisionsProposees):
         ids = set()
         # La poursuite d'études dans un semestre pair d’une même année
         # est de droit pour tout étudiant:
-        if (self.formsemestre.semestre_id % 2) and sco_codes.ParcoursBUT.NB_SEM:
+        if (self.formsemestre.semestre_id % 2) and sco_codes.CursusBUT.NB_SEM:
             ids.add(self.formsemestre.semestre_id + 1)
 
         # La poursuite d’études dans un semestre impair est possible si
@@ -656,7 +656,7 @@ class DecisionsProposeesAnnee(DecisionsProposees):
         if (
             self.jury_annuel
             and code in sco_codes.BUT_CODES_PASSAGE
-            and self.formsemestre_pair.semestre_id < sco_codes.ParcoursBUT.NB_SEM
+            and self.formsemestre_pair.semestre_id < sco_codes.CursusBUT.NB_SEM
         ):
             ids.add(self.formsemestre.semestre_id + 1)
 
@@ -1250,10 +1250,10 @@ class DecisionsProposeesUE(DecisionsProposees):
         if self.inscription_etat != scu.INSCRIT:
             return
         if (
-            self.moy_ue > (sco_codes.ParcoursBUT.BARRE_MOY - sco_codes.NOTES_TOLERANCE)
+            self.moy_ue > (sco_codes.CursusBUT.BARRE_MOY - sco_codes.NOTES_TOLERANCE)
         ) or self.formsemestre.modalite == "EXT":
             self.codes.insert(0, sco_codes.ADM)
-            self.explanation = f"Moyenne >= {sco_codes.ParcoursBUT.BARRE_MOY}/20"
+            self.explanation = f"Moyenne >= {sco_codes.CursusBUT.BARRE_MOY}/20"
         elif self.rcue and self.rcue.est_compensable():
             self.codes.insert(0, sco_codes.CMP)
             self.explanation = "compensable dans le RCUE"

app/but/jury_but_view.py

@@ -291,7 +291,7 @@ def jury_but_semestriel(
     parcour, ues = jury_but.list_ue_parcour_etud(formsemestre, etud, res)
     inscription_etat = etud.inscription_etat(formsemestre.id)
     semestre_terminal = (
-        formsemestre.semestre_id >= formsemestre.formation.get_parcours().NB_SEM
+        formsemestre.semestre_id >= formsemestre.formation.get_cursus().NB_SEM
     )
     autorisations_passage = ScolarAutorisationInscription.query.filter_by(
         etudid=etud.id,
@@ -474,7 +474,7 @@ def jury_but_semestriel(
             """
         )
     else:
-        if formsemestre.semestre_id < formsemestre.formation.get_parcours().NB_SEM:
+        if formsemestre.semestre_id < formsemestre.formation.get_cursus().NB_SEM:
             H.append(
                 f"""
                 <div class="but_settings">

app/comp/bonus_spo.py

@@ -18,8 +18,8 @@ import pandas as pd
 
 from flask import g
 
-from app.scodoc.sco_codes_parcours import UE_SPORT
-from app.scodoc.sco_codes_parcours import ParcoursDUT, ParcoursDUTMono
+from app.scodoc.codes_cursus import UE_SPORT
+from app.scodoc.codes_cursus import CursusDUT, CursusDUTMono
 from app.scodoc.sco_utils import ModuleType
 
 
@@ -677,11 +677,11 @@ class BonusCalais(BonusSportAdditif):
     proportion_point = 0.06  # 6%
 
     def compute_bonus(self, sem_modimpl_moys_inscrits, modimpl_coefs_etuds_no_nan):
-        parcours = self.formsemestre.formation.get_parcours()
+        parcours = self.formsemestre.formation.get_cursus()
         # Variantes de DUT ?
         if (
-            isinstance(parcours, ParcoursDUT)
-            or parcours.TYPE_PARCOURS == ParcoursDUTMono.TYPE_PARCOURS
+            isinstance(parcours, CursusDUT)
+            or parcours.TYPE_CURSUS == CursusDUTMono.TYPE_CURSUS
         ):  # DUT
             super().compute_bonus(sem_modimpl_moys_inscrits, modimpl_coefs_etuds_no_nan)
         else:

app/comp/jury.py

@@ -12,7 +12,7 @@ from app import db
 from app.models import FormSemestre, Identite, ScolarFormSemestreValidation, UniteEns
 from app.comp.res_cache import ResultatsCache
 from app.scodoc import sco_cache
-from app.scodoc import sco_codes_parcours
+from app.scodoc import codes_cursus
 
 
 class ValidationsSemestre(ResultatsCache):
@@ -89,7 +89,7 @@ class ValidationsSemestre(ResultatsCache):
             if decision.etudid not in decisions_jury_ues:
                 decisions_jury_ues[decision.etudid] = {}
             # Calcul des ECTS associés à cette UE:
-            if sco_codes_parcours.code_ue_validant(decision.code) and decision.ue:
+            if codes_cursus.code_ue_validant(decision.code) and decision.ue:
                 ects = decision.ue.ects or 0.0  # 0 if None
             else:
                 ects = 0.0

app/comp/moy_mat.py

@@ -14,7 +14,7 @@ import pandas as pd
 from app.comp import moy_ue
 from app.models.formsemestre import FormSemestre
 
-from app.scodoc.sco_codes_parcours import UE_SPORT
+from app.scodoc.codes_cursus import UE_SPORT
 from app.scodoc.sco_utils import ModuleType
 
 

app/comp/moy_mod.py

@@ -44,7 +44,7 @@ from app import db
 from app.models import Evaluation, EvaluationUEPoids, ModuleImpl
 from app.scodoc import sco_cache
 from app.scodoc import sco_utils as scu
-from app.scodoc.sco_codes_parcours import UE_SPORT
+from app.scodoc.codes_cursus import UE_SPORT
 from app.scodoc.sco_exceptions import ScoBugCatcher
 from app.scodoc.sco_utils import ModuleType
 

app/comp/moy_ue.py

@@ -40,9 +40,9 @@ from app.models import (
     UniteEns,
 )
 from app.comp import moy_mod
-from app.scodoc import sco_codes_parcours
+from app.scodoc import codes_cursus
 from app.scodoc import sco_preferences
-from app.scodoc.sco_codes_parcours import UE_SPORT
+from app.scodoc.codes_cursus import UE_SPORT
 from app.scodoc.sco_utils import ModuleType
 
 
@@ -61,7 +61,7 @@ def df_load_module_coefs(formation_id: int, semestre_idx: int = None) -> pd.Data
     """
     ues = (
         UniteEns.query.filter_by(formation_id=formation_id)
-        .filter(UniteEns.type != sco_codes_parcours.UE_SPORT)
+        .filter(UniteEns.type != codes_cursus.UE_SPORT)
         .order_by(UniteEns.semestre_idx, UniteEns.numero, UniteEns.acronyme)
     )
     modules = (
@@ -69,10 +69,7 @@ def df_load_module_coefs(formation_id: int, semestre_idx: int = None) -> pd.Data
         .filter(
             (Module.module_type == ModuleType.RESSOURCE)
             | (Module.module_type == ModuleType.SAE)
-            | (
-                (Module.ue_id == UniteEns.id)
-                & (UniteEns.type == sco_codes_parcours.UE_SPORT)
-            )
+            | ((Module.ue_id == UniteEns.id) & (UniteEns.type == codes_cursus.UE_SPORT))
         )
         .order_by(Module.semestre_id, Module.module_type, Module.numero, Module.code)
     )

app/comp/res_but.py

@@ -18,7 +18,7 @@ from app.models import ScoDocSiteConfig
 from app.models.moduleimpls import ModuleImpl
 from app.models.ues import DispenseUE, UniteEns
 from app.scodoc import sco_preferences
-from app.scodoc.sco_codes_parcours import UE_SPORT
+from app.scodoc.codes_cursus import UE_SPORT
 from app.scodoc.sco_utils import ModuleType
 
 

app/comp/res_classic.py

@@ -22,7 +22,7 @@ from app.models import ScoDocSiteConfig
 from app.models.etudiants import Identite
 from app.models.formsemestre import FormSemestre
 from app.models.ues import UniteEns
-from app.scodoc.sco_codes_parcours import UE_SPORT
+from app.scodoc.codes_cursus import UE_SPORT
 from app.scodoc.sco_exceptions import ScoValueError
 from app.scodoc import sco_preferences
 from app.scodoc.sco_utils import ModuleType

app/comp/res_common.py

@@ -25,7 +25,7 @@ from app.models import ModuleImpl, ModuleImplInscription
 from app.models import ScolarAutorisationInscription
 from app.models.ues import UniteEns
 from app.scodoc.sco_cache import ResultatsSemestreCache
-from app.scodoc.sco_codes_parcours import UE_SPORT
+from app.scodoc.codes_cursus import UE_SPORT
 from app.scodoc.sco_exceptions import ScoValueError
 from app.scodoc import sco_utils as scu
 

app/comp/res_compat.py

@@ -17,7 +17,7 @@ from app.comp.res_common import ResultatsSemestre
 from app.models import FormSemestre
 from app.models import Identite
 from app.models import ModuleImpl
-from app.scodoc.sco_codes_parcours import UE_SPORT, DEF
+from app.scodoc.codes_cursus import UE_SPORT, DEF
 from app.scodoc import sco_utils as scu
 
 # Pour raccorder le code des anciens codes qui attendent une NoteTable
@@ -52,7 +52,7 @@ class NotesTableCompat(ResultatsSemestre):
         self.moy_gen_rangs_by_group = {}  # { group_id : (Series, Series) }
         self.ue_rangs_by_group = {}  # { ue_id : {group_id : (Series, Series)}}
         self.expr_diagnostics = ""
-        self.parcours = self.formsemestre.formation.get_parcours()
+        self.parcours = self.formsemestre.formation.get_cursus()
         self._modimpls_dict_by_ue = {}  # local cache
 
     def get_inscrits(self, include_demdef=True, order_by=False) -> list[Identite]:

app/forms/main/config_apo.py

@@ -35,14 +35,14 @@ from wtforms.fields.simple import StringField
 
 from app.models import SHORT_STR_LEN
 
-from app.scodoc import sco_codes_parcours
+from app.scodoc import codes_cursus
 
 
 def _build_code_field(code):
     return StringField(
         label=code,
         default=code,
-        description=sco_codes_parcours.CODES_EXPL[code],
+        description=codes_cursus.CODES_EXPL[code],
         validators=[
             validators.regexp(
                 r"^[A-Z0-9_]*$",

app/models/but_validations.py

@@ -13,7 +13,7 @@ from app.models.etudiants import Identite
 from app.models.formations import Formation
 from app.models.formsemestre import FormSemestre
 from app.models.ues import UniteEns
-from app.scodoc import sco_codes_parcours as sco_codes
+from app.scodoc import codes_cursus as sco_codes
 from app.scodoc import sco_utils as scu
 
 

app/models/config.py

@@ -8,7 +8,7 @@ from app import db, log
 from app.comp import bonus_spo
 from app.scodoc import sco_utils as scu
 
-from app.scodoc.sco_codes_parcours import (
+from app.scodoc.codes_cursus import (
     ABAN,
     ABL,
     ADC,

app/models/formations.py

@@ -17,9 +17,9 @@ from app.models.modules import Module
 from app.models.moduleimpls import ModuleImpl
 from app.models.ues import UniteEns
 from app.scodoc import sco_cache
-from app.scodoc import sco_codes_parcours
+from app.scodoc import codes_cursus
 from app.scodoc import sco_utils as scu
-from app.scodoc.sco_codes_parcours import UE_STANDARD
+from app.scodoc.codes_cursus import UE_STANDARD
 
 
 class Formation(db.Model):
@@ -80,12 +80,12 @@ class Formation(db.Model):
 
         return e
 
-    def get_parcours(self):
-        """get l'instance de TypeParcours de cette formation
-        (le TypeParcours définit le genre de formation, à ne pas confondre
+    def get_cursus(self) -> codes_cursus.TypeCursus:
+        """get l'instance de TypeCursus de cette formation
+        (le TypeCursus définit le genre de formation, à ne pas confondre
         avec les parcours du BUT).
         """
-        return sco_codes_parcours.get_parcours_from_code(self.type_parcours)
+        return codes_cursus.get_cursus_from_code(self.type_parcours)
 
     def get_titre_version(self) -> str:
         """Titre avec version"""
@@ -93,7 +93,7 @@ class Formation(db.Model):
 
     def is_apc(self):
         "True si formation APC avec SAE (BUT)"
-        return self.get_parcours().APC_SAE
+        return self.get_cursus().APC_SAE
 
     def get_module_coefs(self, semestre_idx: int = None):
         """Les coefs des modules vers les UE (accès via cache)"""

app/models/formsemestre.py

@@ -39,7 +39,7 @@ from app.models.moduleimpls import ModuleImpl, ModuleImplInscription
 from app.models.modules import Module
 from app.models.ues import UniteEns
 from app.models.validations import ScolarFormSemestreValidation
-from app.scodoc import sco_codes_parcours, sco_preferences
+from app.scodoc import codes_cursus, sco_preferences
 from app.scodoc.sco_exceptions import ScoValueError
 from app.scodoc.sco_permissions import Permission
 from app.scodoc.sco_utils import MONTH_NAMES_ABBREV
@@ -276,7 +276,7 @@ class FormSemestre(db.Model):
             - sont associées à l'un des parcours de ce formsemestre (ou à aucun)
 
         """
-        if self.formation.get_parcours().APC_SAE:
+        if self.formation.get_cursus().APC_SAE:
             sem_ues = UniteEns.query.filter_by(
                 formation=self.formation, semestre_idx=self.semestre_id
             )
@@ -294,7 +294,7 @@ class FormSemestre(db.Model):
                 UniteEns.id == Module.ue_id,
             )
         if not with_sport:
-            sem_ues = sem_ues.filter(UniteEns.type != sco_codes_parcours.UE_SPORT)
+            sem_ues = sem_ues.filter(UniteEns.type != codes_cursus.UE_SPORT)
         return sem_ues.order_by(UniteEns.numero)
 
     def query_ues_parcours_etud(self, etudid: int) -> flask_sqlalchemy.BaseQuery:
@@ -598,7 +598,7 @@ class FormSemestre(db.Model):
         if not imputation_dept:
             imputation_dept = prefs["DeptName"]
         imputation_dept = imputation_dept.upper()
-        parcours_name = self.formation.get_parcours().NAME
+        cursus_name = self.formation.get_cursus().NAME
         modalite = self.modalite
         # exception pour code Apprentissage:
         modalite = (modalite or "").replace("FAP", "FA").replace("APP", "FA")
@@ -611,7 +611,7 @@ class FormSemestre(db.Model):
             scu.annee_scolaire_debut(self.date_debut.year, self.date_debut.month)
         )
         return scu.sanitize_string(
-            f"{imputation_dept}-{parcours_name}-{modalite}-{semestre_id}-{annee_sco}"
+            f"{imputation_dept}-{cursus_name}-{modalite}-{semestre_id}-{annee_sco}"
         )
 
     def titre_annee(self) -> str:
@@ -643,9 +643,9 @@ class FormSemestre(db.Model):
 
     def titre_num(self) -> str:
         """Le titre et le semestre, ex ""DUT Informatique semestre 2"" """
-        if self.semestre_id == sco_codes_parcours.NO_SEMESTRE_ID:
+        if self.semestre_id == codes_cursus.NO_SEMESTRE_ID:
             return self.titre
-        return f"{self.titre} {self.formation.get_parcours().SESSION_NAME} {self.semestre_id}"
+        return f"{self.titre} {self.formation.get_cursus().SESSION_NAME} {self.semestre_id}"
 
     def sem_modalite(self) -> str:
         """Le semestre et la modalité, ex "S2 FI" ou "S3 APP" """

app/models/moduleimpls.py

@@ -66,7 +66,7 @@ class ModuleImpl(db.Model):
         """true si les poids des évaluations du module permettent de satisfaire
         les coefficients du PN.
         """
-        if not self.module.formation.get_parcours().APC_SAE or (
+        if not self.module.formation.get_cursus().APC_SAE or (
             self.module.module_type != scu.ModuleType.RESSOURCE
             and self.module.module_type != scu.ModuleType.SAE
         ):

app/models/modules.py

@@ -5,7 +5,7 @@ from app import db
 from app.models import APO_CODE_STR_LEN
 from app.models.but_refcomp import ApcParcours, app_critiques_modules, parcours_modules
 from app.scodoc import sco_utils as scu
-from app.scodoc.sco_codes_parcours import UE_SPORT
+from app.scodoc.codes_cursus import UE_SPORT
 from app.scodoc.sco_exceptions import ScoValueError
 from app.scodoc.sco_utils import ModuleType
 

app/pe/pe_jurype.py

@@ -52,7 +52,7 @@ from app.models import FormSemestre
 
 from app.scodoc.gen_tables import GenTable, SeqGenTable
 import app.scodoc.sco_utils as scu
-from app.scodoc import sco_codes_parcours  # sco_codes_parcours.NEXT -> sem suivant
+from app.scodoc import codes_cursus  # codes_cursus.NEXT -> sem suivant
 from app.scodoc import sco_etud
 from app.scodoc import sco_formsemestre
 from app.pe import pe_tagtable
@@ -68,7 +68,7 @@ def comp_nom_semestre_dans_parcours(sem):
     from app.scodoc import sco_formations
 
     F = sco_formations.formation_list(args={"formation_id": sem["formation_id"]})[0]
-    parcours = sco_codes_parcours.get_parcours_from_code(F["type_parcours"])
+    parcours = codes_cursus.get_cursus_from_code(F["type_parcours"])
     return "%s %s %s  %s" % (
         parcours.SESSION_NAME,  # eg "semestre"
         sem["semestre_id"],  # eg 2
@@ -457,9 +457,9 @@ class JuryPE(object):
 
         reponse = False
         etud = self.get_cache_etudInfo_d_un_etudiant(etudid)
-        (_, parcours) = sco_report.get_codeparcoursetud(etud)
+        (_, parcours) = sco_report.get_code_cursus_etud(etud)
         if (
-            len(sco_codes_parcours.CODES_SEM_REO & set(parcours.values())) > 0
+            len(codes_cursus.CODES_SEM_REO & set(parcours.values())) > 0
         ):  # Eliminé car NAR apparait dans le parcours
             reponse = True
             if pe_tools.PE_DEBUG and pe_tools.PE_DEBUG >= 2:
@@ -528,14 +528,14 @@ class JuryPE(object):
         from app.scodoc import sco_report
 
         etud = self.get_cache_etudInfo_d_un_etudiant(etudid)
-        (code, parcours) = sco_report.get_codeparcoursetud(
+        (code, parcours) = sco_report.get_code_cursus_etud(
             etud
         )  # description = '1234:A', parcours = {1:ADM, 2:NAR, ...}
         sonDernierSemestreValide = max(
             [
                 int(cle)
                 for (cle, code) in parcours.items()
-                if code in sco_codes_parcours.CODES_SEM_VALIDES
+                if code in codes_cursus.CODES_SEM_VALIDES
             ]
             + [0]
         )  # n° du dernier semestre valide, 0 sinon
@@ -562,7 +562,7 @@ class JuryPE(object):
                 dec = nt.get_etud_decision_sem(
                     etudid
                 )  # quelle est la décision du jury ?
-                if dec and (dec["code"] in sco_codes_parcours.CODES_SEM_VALIDES):
+                if dec and (dec["code"] in codes_cursus.CODES_SEM_VALIDES):
                     # isinstance( sesMoyennes[i+1], float) and
                     # mT = sesMoyennes[i+1] # substitue la moyenne si le semestre suivant est "valide"
                     leFid = sem["formsemestre_id"]

app/pe/pe_semestretag.py

@@ -43,7 +43,7 @@ from app.models import FormSemestre
 from app.models.moduleimpls import ModuleImpl
 from app.pe import pe_tagtable
 
-from app.scodoc import sco_codes_parcours
+from app.scodoc import codes_cursus
 from app.scodoc import sco_tag_module
 from app.scodoc import sco_utils as scu
 
@@ -116,7 +116,7 @@ class SemestreTag(pe_tagtable.TableTag):
         self.modimpls = [
             modimpl
             for modimpl in self.nt.formsemestre.modimpls_sorted
-            if modimpl.module.ue.type == sco_codes_parcours.UE_STANDARD
+            if modimpl.module.ue.type == codes_cursus.UE_STANDARD
         ]  # la liste des modules (objet modimpl)
         self.somme_coeffs = sum(
             [

app/scodoc/codes_cursus.py

@@ -25,9 +25,10 @@
 #
 ##############################################################################
 
-"""Semestres: Codes gestion parcours (constantes)
+"""Semestres: Codes gestion cursus (constantes)
+Attention: ne pas confondre avec les "parcours" du BUT.
+Renommage des anciens "parcours" -> "cursus" effectué en 9.4.41
 """
-import collections
 import enum
 
 import numpy as np
@@ -36,8 +37,8 @@ from app import log
 
 
 @enum.unique
-class CodesParcours(enum.IntEnum):
-    """Codes numériques des parcours, enregistrés en base
+class CodesCursus(enum.IntEnum):
+    """Codes numériques des cursus (ex parcours), enregistrés en base
     dans notes_formations.type_parcours
     Ne pas modifier.
     """
@@ -79,7 +80,7 @@ UE_STANDARD = 0  # UE "fondamentale"
 UE_SPORT = 1  # bonus "sport"
 UE_STAGE_LP = 2  # ue "projet tuteuré et stage" dans les Lic. Pro.
 UE_STAGE_10 = 3  # ue "stage" avec moyenne requise > 10
-UE_ELECTIVE = 4  # UE "élective" dans certains parcours (UCAC?, ISCID)
+UE_ELECTIVE = 4  # UE "élective" dans certains cursus (UCAC?, ISCID)
 UE_PROFESSIONNELLE = 5  # UE "professionnelle" (ISCID, ...)
 UE_OPTIONNELLE = 6  # UE non fondamentales (ILEPS, ...)
 
@@ -274,7 +275,7 @@ DEVENIRS_NEXT2 = {NEXT_OR_NEXT2: 1, NEXT2: 1}
 
 NO_SEMESTRE_ID = -1  # code semestre si pas de semestres
 
-# Règles gestion parcours
+# Règles gestion cursus
 class DUTRule(object):
     def __init__(self, rule_id, premise, conclusion):
         self.rule_id = rule_id
@@ -296,12 +297,12 @@ class DUTRule(object):
         return True
 
 
-# Types de parcours
-DEFAULT_TYPE_PARCOURS = 100  # pour le menu de creation nouvelle formation
+# Types de cursus
+DEFAULT_TYPE_CURSUS = 100  # pour le menu de creation nouvelle formation
 
 
-class TypeParcours(object):
-    TYPE_PARCOURS = None  # id, utilisé par notes_formation.type_parcours
+class TypeCursus:
+    TYPE_CURSUS = None  # id, utilisé par notes_formation.type_parcours
     NAME = None  # required
     NB_SEM = 1  # Nombre de semestres
     COMPENSATION_UE = True  # inutilisé
@@ -315,9 +316,9 @@ class TypeParcours(object):
     SESSION_NAME = "semestre"
     SESSION_NAME_A = "du "
     SESSION_ABBRV = "S"  # S1, S2, ...
-    UNUSED_CODES = set()  # Ensemble des codes jury non autorisés dans ce parcours
+    UNUSED_CODES = set()  # Ensemble des codes jury non autorisés dans ce cursus
     UE_IS_MODULE = False  # 1 seul module par UE (si plusieurs modules, etudiants censéments inscrits à un seul d'entre eux)
-    ECTS_ONLY = False  # Parcours avec progression basée uniquement sur les ECTS
+    ECTS_ONLY = False  # Cursus avec progression basée uniquement sur les ECTS
     ALLOWED_UE_TYPES = list(
         UE_TYPE_NAME.keys()
     )  # par defaut, autorise tous les types d'UE
@@ -363,18 +364,18 @@ class TypeParcours(object):
             return False, """<b>%d UE sous la barre</b>""" % n
 
 
-# Parcours définis (instances de sous-classes de TypeParcours):
-TYPES_PARCOURS = collections.OrderedDict()  # type : Parcours
+# Cursus définis (instances de sous-classes de TypeCursus):
+SCO_CURSUS: dict[int, TypeCursus] = {}  # type : Cursus
 
 
-def register_parcours(Parcours):
-    TYPES_PARCOURS[int(Parcours.TYPE_PARCOURS)] = Parcours
+def register_cursus(cursus: TypeCursus):
+    SCO_CURSUS[int(cursus.TYPE_CURSUS)] = cursus
 
 
-class ParcoursBUT(TypeParcours):
+class CursusBUT(TypeCursus):
     """BUT Bachelor Universitaire de Technologie"""
 
-    TYPE_PARCOURS = 700
+    TYPE_CURSUS = 700
     NAME = "BUT"
     NB_SEM = 6
     COMPENSATION_UE = False
@@ -383,63 +384,63 @@ class ParcoursBUT(TypeParcours):
     ALLOWED_UE_TYPES = [UE_STANDARD, UE_SPORT]
 
 
-register_parcours(ParcoursBUT())
+register_cursus(CursusBUT())
 
 
-class ParcoursDUT(TypeParcours):
+class CursusDUT(TypeCursus):
     """DUT selon l'arrêté d'août 2005"""
 
-    TYPE_PARCOURS = 100
+    TYPE_CURSUS = 100
     NAME = "DUT"
     NB_SEM = 4
     COMPENSATION_UE = True
     ALLOWED_UE_TYPES = [UE_STANDARD, UE_SPORT]
 
 
-register_parcours(ParcoursDUT())
+register_cursus(CursusDUT())
 
 
-class ParcoursDUT4(ParcoursDUT):
+class CursusDUT4(CursusDUT):
     """DUT (en 4 semestres sans compensations)"""
 
-    TYPE_PARCOURS = 110
+    TYPE_CURSUS = 110
     NAME = "DUT4"
     COMPENSATION_UE = False
 
 
-register_parcours(ParcoursDUT4())
+register_cursus(CursusDUT4())
 
 
-class ParcoursDUTMono(TypeParcours):
+class CursusDUTMono(TypeCursus):
     """DUT en un an (FC, Années spéciales)"""
 
-    TYPE_PARCOURS = 120
+    TYPE_CURSUS = 120
     NAME = "DUT"
     NB_SEM = 1
     COMPENSATION_UE = False
     UNUSED_CODES = set((ADC, ATT, ATB))
 
 
-register_parcours(ParcoursDUTMono())
+register_cursus(CursusDUTMono())
 
 
-class ParcoursDUT2(ParcoursDUT):
+class CursusDUT2(CursusDUT):
     """DUT en deux semestres (par ex.: années spéciales semestrialisées)"""
 
-    TYPE_PARCOURS = CodesParcours.DUT2
+    TYPE_CURSUS = CodesCursus.DUT2
     NAME = "DUT2"
     NB_SEM = 2
 
 
-register_parcours(ParcoursDUT2())
+register_cursus(CursusDUT2())
 
 
-class ParcoursLP(TypeParcours):
+class CursusLP(TypeCursus):
     """Licence Pro (en un "semestre")
-    (pour anciennes LP. Après 2014, préférer ParcoursLP2014)
+    (pour anciennes LP. Après 2014, préférer CursusLP2014)
     """
 
-    TYPE_PARCOURS = CodesParcours.LP
+    TYPE_CURSUS = CodesCursus.LP
     NAME = "LP"
     NB_SEM = 1
     COMPENSATION_UE = False
@@ -450,35 +451,35 @@ class ParcoursLP(TypeParcours):
     UNUSED_CODES = set((ADC, ATT, ATB))
 
 
-register_parcours(ParcoursLP())
+register_cursus(CursusLP())
 
 
-class ParcoursLP2sem(ParcoursLP):
+class CursusLP2sem(CursusLP):
     """Licence Pro (en deux "semestres")"""
 
-    TYPE_PARCOURS = CodesParcours.LP2sem
+    TYPE_CURSUS = CodesCursus.LP2sem
     NAME = "LP2sem"
     NB_SEM = 2
     COMPENSATION_UE = True
     UNUSED_CODES = set((ADC,))  # autorise les codes ATT et ATB, mais pas ADC.
 
 
-register_parcours(ParcoursLP2sem())
+register_cursus(CursusLP2sem())
 
 
-class ParcoursLP2semEvry(ParcoursLP):
+class CursusLP2semEvry(CursusLP):
     """Licence Pro (en deux "semestres", U. Evry)"""
 
-    TYPE_PARCOURS = CodesParcours.LP2semEvry
+    TYPE_CURSUS = CodesCursus.LP2semEvry
     NAME = "LP2semEvry"
     NB_SEM = 2
     COMPENSATION_UE = True
 
 
-register_parcours(ParcoursLP2semEvry())
+register_cursus(CursusLP2semEvry())
 
 
-class ParcoursLP2014(TypeParcours):
+class CursusLP2014(TypeCursus):
     """Licence Pro (en un "semestre"), selon arrêté du 22/01/2014"""
 
     # Note: texte de référence
@@ -495,7 +496,7 @@ class ParcoursLP2014(TypeParcours):
     # l'établissement d'un coefficient qui peut varier dans un rapport de 1 à 3. ", etc ne sont _pas_
     # vérifiés par ScoDoc)
 
-    TYPE_PARCOURS = CodesParcours.LP2014
+    TYPE_CURSUS = CodesCursus.LP2014
     NAME = "LP2014"
     NB_SEM = 1
     ALLOWED_UE_TYPES = [UE_STANDARD, UE_SPORT, UE_STAGE_LP]
@@ -533,74 +534,74 @@ class ParcoursLP2014(TypeParcours):
             return True, ""  # pas de coef, condition ok
 
 
-register_parcours(ParcoursLP2014())
+register_cursus(CursusLP2014())
 
 
-class ParcoursLP2sem2014(ParcoursLP):
+class CursusLP2sem2014(CursusLP):
     """Licence Pro (en deux "semestres", selon arrêté du 22/01/2014)"""
 
-    TYPE_PARCOURS = CodesParcours.LP2sem2014
+    TYPE_CURSUS = CodesCursus.LP2sem2014
     NAME = "LP2014_2sem"
     NB_SEM = 2
 
 
-register_parcours(ParcoursLP2sem2014())
+register_cursus(CursusLP2sem2014())
 
 
 # Masters: M2 en deux semestres
-class ParcoursM2(TypeParcours):
+class CursusM2(TypeCursus):
     """Master 2 (en deux "semestres")"""
 
-    TYPE_PARCOURS = CodesParcours.M2
+    TYPE_CURSUS = CodesCursus.M2
     NAME = "M2sem"
     NB_SEM = 2
     COMPENSATION_UE = True
     UNUSED_CODES = set((ATT, ATB))
 
 
-register_parcours(ParcoursM2())
+register_cursus(CursusM2())
 
 
-class ParcoursM2noncomp(ParcoursM2):
+class CursusM2noncomp(CursusM2):
     """Master 2 (en deux "semestres") sans compensation"""
 
-    TYPE_PARCOURS = CodesParcours.M2noncomp
+    TYPE_CURSUS = CodesCursus.M2noncomp
     NAME = "M2noncomp"
     COMPENSATION_UE = False
     UNUSED_CODES = set((ADC, ATT, ATB))
 
 
-register_parcours(ParcoursM2noncomp())
+register_cursus(CursusM2noncomp())
 
 
-class ParcoursMono(TypeParcours):
+class CursusMono(TypeCursus):
     """Formation générique en une session"""
 
-    TYPE_PARCOURS = CodesParcours.Mono
+    TYPE_CURSUS = CodesCursus.Mono
     NAME = "Mono"
     NB_SEM = 1
     COMPENSATION_UE = False
     UNUSED_CODES = set((ADC, ATT, ATB))
 
 
-register_parcours(ParcoursMono())
+register_cursus(CursusMono())
 
 
-class ParcoursLegacy(TypeParcours):
+class CursusLegacy(TypeCursus):
     """DUT (ancien ScoDoc, ne plus utiliser)"""
 
-    TYPE_PARCOURS = CodesParcours.Legacy
+    TYPE_CURSUS = CodesCursus.Legacy
     NAME = "DUT"
     NB_SEM = 4
     COMPENSATION_UE = None  # backward compat: defini dans formsemestre
     ALLOWED_UE_TYPES = [UE_STANDARD, UE_SPORT]
 
 
-register_parcours(ParcoursLegacy())
+register_cursus(CursusLegacy())
 
 
-class ParcoursISCID(TypeParcours):
-    """Superclasse pour les parcours de l'ISCID"""
+class CursusISCID(TypeCursus):
+    """Superclasse pour les cursus de l'ISCID"""
 
     # SESSION_NAME = "année"
     # SESSION_NAME_A = "de l'"
@@ -619,32 +620,32 @@ class ParcoursISCID(TypeParcours):
     ECTS_PROF_DIPL = 0  # crédits professionnels requis pour obtenir le diplôme
 
 
-class ParcoursBachelorISCID6(ParcoursISCID):
+class CursusBachelorISCID6(CursusISCID):
     """ISCID: Bachelor en 3 ans (6 sem.)"""
 
-    NAME = "ParcoursBachelorISCID6"
-    TYPE_PARCOURS = CodesParcours.ISCID6
+    NAME = "CursusBachelorISCID6"
+    TYPE_CURSUS = CodesCursus.ISCID6
     NAME = ""
     NB_SEM = 6
     ECTS_PROF_DIPL = 8  # crédits professionnels requis pour obtenir le diplôme
 
 
-register_parcours(ParcoursBachelorISCID6())
+register_cursus(CursusBachelorISCID6())
 
 
-class ParcoursMasterISCID4(ParcoursISCID):
+class CursusMasterISCID4(CursusISCID):
     "ISCID: Master en 2 ans (4 sem.)"
-    TYPE_PARCOURS = CodesParcours.ISCID4
-    NAME = "ParcoursMasterISCID4"
+    TYPE_CURSUS = CodesCursus.ISCID4
+    NAME = "CursusMasterISCID4"
     NB_SEM = 4
     ECTS_PROF_DIPL = 15  # crédits professionnels requis pour obtenir le diplôme
 
 
-register_parcours(ParcoursMasterISCID4())
+register_cursus(CursusMasterISCID4())
 
 
-class ParcoursILEPS(TypeParcours):
-    """Superclasse pour les parcours de l'ILEPS"""
+class CursusILEPS(TypeCursus):
+    """Superclasse pour les cursus de l'ILEPS"""
 
     # SESSION_NAME = "année"
     # SESSION_NAME_A = "de l'"
@@ -660,18 +661,18 @@ class ParcoursILEPS(TypeParcours):
     BARRE_UE_DEFAULT = 0.0  # pas de barre sur les autres UE
 
 
-class ParcoursLicenceILEPS6(ParcoursILEPS):
+class CursusLicenceILEPS6(CursusILEPS):
     """ILEPS: Licence 6 semestres"""
 
-    TYPE_PARCOURS = 1010
+    TYPE_CURSUS = 1010
     NAME = "LicenceILEPS6"
     NB_SEM = 6
 
 
-register_parcours(ParcoursLicenceILEPS6())
+register_cursus(CursusLicenceILEPS6())
 
 
-class ParcoursUCAC(TypeParcours):
+class CursusUCAC(TypeCursus):
     """Règles de validation UCAC"""
 
     SESSION_NAME = "année"
@@ -685,79 +686,79 @@ class ParcoursUCAC(TypeParcours):
     )
 
 
-class ParcoursLicenceUCAC3(ParcoursUCAC):
+class CursusLicenceUCAC3(CursusUCAC):
     """UCAC: Licence en 3 sessions d'un an"""
 
-    TYPE_PARCOURS = CodesParcours.LicenceUCAC3
+    TYPE_CURSUS = CodesCursus.LicenceUCAC3
     NAME = "Licence UCAC en 3 sessions d'un an"
     NB_SEM = 3
 
 
-register_parcours(ParcoursLicenceUCAC3())
+register_cursus(CursusLicenceUCAC3())
 
 
-class ParcoursMasterUCAC2(ParcoursUCAC):
+class CursusMasterUCAC2(CursusUCAC):
     """UCAC: Master en 2 sessions d'un an"""
 
-    TYPE_PARCOURS = CodesParcours.MasterUCAC2
+    TYPE_CURSUS = CodesCursus.MasterUCAC2
     NAME = "Master UCAC en 2 sessions d'un an"
     NB_SEM = 2
 
 
-register_parcours(ParcoursMasterUCAC2())
+register_cursus(CursusMasterUCAC2())
 
 
-class ParcoursMonoUCAC(ParcoursUCAC):
+class CursusMonoUCAC(CursusUCAC):
     """UCAC: Formation en 1 session de durée variable"""
 
-    TYPE_PARCOURS = CodesParcours.MonoUCAC
+    TYPE_CURSUS = CodesCursus.MonoUCAC
     NAME = "Formation UCAC en 1 session de durée variable"
     NB_SEM = 1
     UNUSED_CODES = set((ADC, ATT, ATB))
 
 
-register_parcours(ParcoursMonoUCAC())
+register_cursus(CursusMonoUCAC())
 
 
-class Parcours6Sem(TypeParcours):
-    """Parcours générique en 6 semestres"""
+class Cursus6Sem(TypeCursus):
+    """Cursus générique en 6 semestres"""
 
-    TYPE_PARCOURS = CodesParcours.GEN_6_SEM
+    TYPE_CURSUS = CodesCursus.GEN_6_SEM
     NAME = "Formation en 6 semestres"
     NB_SEM = 6
     COMPENSATION_UE = True
 
 
-register_parcours(Parcours6Sem())
+register_cursus(Cursus6Sem())
 
 # # En cours d'implémentation:
-# class ParcoursLicenceLMD(TypeParcours):
+# class CursusLicenceLMD(TypeCursus):
 #     """Licence standard en 6 semestres dans le LMD"""
-#     TYPE_PARCOURS = 401
+#     TYPE_CURSUS = 401
 #     NAME = "Licence LMD"
 #     NB_SEM = 6
 #     COMPENSATION_UE = True
 
-# register_parcours(ParcoursLicenceLMD())
+# register_cursus(CursusLicenceLMD())
 
 
-class ParcoursMasterLMD(TypeParcours):
+class CursusMasterLMD(TypeCursus):
     """Master générique en 4 semestres dans le LMD"""
 
-    TYPE_PARCOURS = CodesParcours.MasterLMD
+    TYPE_CURSUS = CodesCursus.MasterLMD
     NAME = "Master LMD"
     NB_SEM = 4
     COMPENSATION_UE = True  # variabale inutilisée
     UNUSED_CODES = set((ADC, ATT, ATB))
 
 
-register_parcours(ParcoursMasterLMD())
+register_cursus(CursusMasterLMD())
 
 
-class ParcoursMasterIG(ParcoursMasterLMD):
+class CursusMasterIG(CursusMasterLMD):
     """Master de l'Institut Galilée (U. Paris 13) en 4 semestres (LMD)"""
 
-    TYPE_PARCOURS = CodesParcours.MasterIG
+    TYPE_CURSUS = CodesCursus.MasterIG
     NAME = "Master IG P13"
     BARRE_MOY = 10.0
     NOTES_BARRE_VALID_UE_TH = 10.0  # seuil pour valider UE
@@ -767,7 +768,7 @@ class ParcoursMasterIG(ParcoursMasterLMD):
     BARRE_MOY_UE_STAGE = 10.0
     ALLOWED_UE_TYPES = [UE_STANDARD, UE_SPORT, UE_STAGE_10]
 
-    def check_barre_ues(self, ues_status):  # inspire de la fonction de ParcoursLP2014
+    def check_barre_ues(self, ues_status):  # inspire de la fonction de CursusLP2014
         """True si la ou les conditions sur les UE sont valides
         moyenne d'UE > 7, ou > 10 si UE de stage
         """
@@ -806,10 +807,10 @@ class ParcoursMasterIG(ParcoursMasterLMD):
             return True, ""  # pas de coef, condition ok
 
 
-register_parcours(ParcoursMasterIG())
+register_cursus(CursusMasterIG())
 
 
-# Ajouter ici vos parcours, le TYPE_PARCOURS devant être unique au monde
+# Ajouter ici vos cursus, le TYPE_CURSUS devant être unique au monde
 # (avisez sur la liste de diffusion)
 
 
@@ -817,16 +818,16 @@ register_parcours(ParcoursMasterIG())
 
 
 # -------------------------
-_tp = list(TYPES_PARCOURS.items())
+_tp = list(SCO_CURSUS.items())
 _tp.sort(key=lambda x: x[1].__doc__)  # sort by intitulé
-FORMATION_PARCOURS_DESCRS = [p[1].__doc__ for p in _tp]  # intitulés (eg pour menu)
-FORMATION_PARCOURS_TYPES = [p[0] for p in _tp]  # codes numeriques (TYPE_PARCOURS)
+FORMATION_CURSUS_DESCRS = [p[1].__doc__ for p in _tp]  # intitulés (eg pour menu)
+FORMATION_CURSUS_TYPES = [p[0] for p in _tp]  # codes numeriques (TYPE_CURSUS)
 
 
-def get_parcours_from_code(code_parcours):
-    parcours = TYPES_PARCOURS.get(code_parcours)
-    if parcours is None:
-        log(f"Warning: invalid code_parcours: {code_parcours}")
+def get_cursus_from_code(code_cursus):
+    cursus = SCO_CURSUS.get(code_cursus)
+    if cursus is None:
+        log(f"Warning: invalid code_cursus: {code_cursus}")
         # default to legacy
-        parcours = TYPES_PARCOURS.get(0)
-    return parcours
+        cursus = SCO_CURSUS.get(0)
+    return cursus

app/scodoc/dutrules.py

@@ -4,7 +4,7 @@
 #
 # Command: ./csv2rules.py misc/parcoursDUT.csv
 #
-from app.scodoc.sco_codes_parcours import (
+from app.scodoc.codes_cursus import (
     DUTRule,
     ADC,
     ADJ,

app/scodoc/notes_table.py

@@ -48,14 +48,14 @@ from app.scodoc.sco_formsemestre import (
     formsemestre_uecoef_list,
     formsemestre_uecoef_create,
 )
-from app.scodoc.sco_codes_parcours import (
+from app.scodoc.codes_cursus import (
     DEF,
     UE_SPORT,
     ue_is_fondamentale,
     ue_is_professionnelle,
 )
 from app.scodoc import sco_cache
-from app.scodoc import sco_codes_parcours
+from app.scodoc import codes_cursus
 from app.scodoc import sco_compute_moy
 from app.scodoc.sco_cursus import formsemestre_get_etud_capitalisation
 from app.scodoc import sco_cursus_dut
@@ -244,7 +244,7 @@ class NotesTable:
         self.formation = sco_formations.formation_list(
             args={"formation_id": self.sem["formation_id"]}
         )[0]
-        self.parcours = sco_codes_parcours.get_parcours_from_code(
+        self.parcours = codes_cursus.get_cursus_from_code(
             self.formation["type_parcours"]
         )
 
@@ -1048,7 +1048,7 @@ class NotesTable:
                 decisions_jury_ues[etudid] = {}
             # Calcul des ECTS associes a cette UE:
             ects = 0.0
-            if sco_codes_parcours.code_ue_validant(code):
+            if codes_cursus.code_ue_validant(code):
                 ue = self.uedict.get(ue_id, None)
                 if ue is None:  # not in list for this sem ??? (probably an error)
                     log(

app/scodoc/sco_apogee_csv.py

@@ -106,8 +106,8 @@ import app.scodoc.sco_utils as scu
 from app.scodoc.sco_exceptions import ScoValueError, ScoFormatError
 from app.scodoc.gen_tables import GenTable
 from app.scodoc.sco_vdi import ApoEtapeVDI
-from app.scodoc.sco_codes_parcours import code_semestre_validant
-from app.scodoc.sco_codes_parcours import (
+from app.scodoc.codes_cursus import code_semestre_validant
+from app.scodoc.codes_cursus import (
     DEF,
     DEM,
     NAR,

app/scodoc/sco_bulletins.py

@@ -53,7 +53,7 @@ from app.scodoc import sco_bulletins_generator
 from app.scodoc import sco_bulletins_json
 from app.scodoc import sco_bulletins_pdf
 from app.scodoc import sco_bulletins_xml
-from app.scodoc import sco_codes_parcours
+from app.scodoc import codes_cursus
 from app.scodoc import sco_etud
 from app.scodoc import sco_evaluation_db
 from app.scodoc import sco_formations
@@ -174,9 +174,7 @@ def formsemestre_bulletinetud_dict(formsemestre_id, etudid, version="long"):
             "version": 0,
         }
     I["formation"] = formation_dict
-    I["parcours"] = sco_codes_parcours.get_parcours_from_code(
-        I["formation"]["type_parcours"]
-    )
+    I["parcours"] = codes_cursus.get_cursus_from_code(I["formation"]["type_parcours"])
     # Infos sur l'etudiant
     I["etud"] = sco_etud.get_etud_info(etudid=etudid, filled=True)[0]
     I["descr_situation"] = I["etud"]["inscriptionstr"]
@@ -222,7 +220,7 @@ def formsemestre_bulletinetud_dict(formsemestre_id, etudid, version="long"):
     I["demission"] = ""
     if I["etud_etat"] == scu.DEMISSION:
         I["demission"] = "(Démission)"
-    elif I["etud_etat"] == sco_codes_parcours.DEF:
+    elif I["etud_etat"] == codes_cursus.DEF:
         I["demission"] = "(Défaillant)"
 
     # --- Appreciations
@@ -239,9 +237,7 @@ def formsemestre_bulletinetud_dict(formsemestre_id, etudid, version="long"):
     I["mention"] = ""
     if dpv:
         decision_sem = dpv["decisions"][0]["decision_sem"]
-        if decision_sem and sco_codes_parcours.code_semestre_validant(
-            decision_sem["code"]
-        ):
+        if decision_sem and codes_cursus.code_semestre_validant(decision_sem["code"]):
             I["mention"] = scu.get_mention(moy_gen)
 
     if dpv and dpv["decisions"][0]:
@@ -307,7 +303,7 @@ def formsemestre_bulletinetud_dict(formsemestre_id, etudid, version="long"):
             continue
 
         u["ue_status"] = ue_status  # { 'moy', 'coef_ue', ...}
-        if ue["type"] != sco_codes_parcours.UE_SPORT:
+        if ue["type"] != codes_cursus.UE_SPORT:
             u["cur_moy_ue_txt"] = scu.fmt_note(ue_status["cur_moy_ue"])
         else:
             if nt.bonus is not None:
@@ -335,7 +331,7 @@ def formsemestre_bulletinetud_dict(formsemestre_id, etudid, version="long"):
             and ue["ue_id"] in dpv["decisions"][0]["decisions_ue"]
         ):
             u["ects"] = dpv["decisions"][0]["decisions_ue"][ue["ue_id"]]["ects"]
-            if ue["type"] == sco_codes_parcours.UE_ELECTIVE:
+            if ue["type"] == codes_cursus.UE_ELECTIVE:
                 u["ects"] = (
                     "%g+" % u["ects"]
                 )  # ajoute un "+" pour indiquer ECTS d'une UE élective
@@ -388,7 +384,7 @@ def formsemestre_bulletinetud_dict(formsemestre_id, etudid, version="long"):
                     _sort_mod_by_matiere(u["modules_capitalized"], nt_cap, etudid)
                 )
         else:
-            if prefs["bul_show_ue_rangs"] and ue["type"] != sco_codes_parcours.UE_SPORT:
+            if prefs["bul_show_ue_rangs"] and ue["type"] != codes_cursus.UE_SPORT:
                 if ue_attente or nt.ue_rangs[ue["ue_id"]][0] is None:
                     u["ue_descr_txt"] = "%s/%s" % (
                         scu.RANG_ATTENTE_STR,

app/scodoc/sco_bulletins_pdf.py

@@ -63,7 +63,7 @@ from app import log, ScoValueError
 from app.models import FormSemestre
 
 from app.scodoc import sco_cache
-from app.scodoc import sco_codes_parcours
+from app.scodoc import codes_cursus
 from app.scodoc import sco_pdf
 from app.scodoc import sco_preferences
 from app.scodoc import sco_etud
@@ -286,7 +286,7 @@ def get_filigranne(etud_etat: str, prefs, decision_sem=None) -> str:
     """Texte à placer en "filigranne" sur le bulletin pdf"""
     if etud_etat == scu.DEMISSION:
         return "Démission"
-    elif etud_etat == sco_codes_parcours.DEF:
+    elif etud_etat == codes_cursus.DEF:
         return "Défaillant"
     elif (prefs["bul_show_temporary"] and not decision_sem) or prefs[
         "bul_show_temporary_forced"

app/scodoc/sco_bulletins_standard.py

@@ -56,7 +56,7 @@ import app.scodoc.sco_utils as scu
 from app.scodoc.sco_pdf import SU, make_paras
 from app.scodoc import sco_preferences
 from app.scodoc.sco_permissions import Permission
-from app.scodoc.sco_codes_parcours import (
+from app.scodoc.codes_cursus import (
     UE_COLORS,
     UE_DEFAULT_COLOR,
     UE_ELECTIVE,

app/scodoc/sco_bulletins_xml.py

@@ -52,7 +52,7 @@ from app import log
 from app.but.bulletin_but_xml_compat import bulletin_but_xml_compat
 from app.models.formsemestre import FormSemestre
 from app.scodoc import sco_abs
-from app.scodoc import sco_codes_parcours
+from app.scodoc import codes_cursus
 from app.scodoc import sco_edit_ue
 from app.scodoc import sco_evaluation_db
 from app.scodoc import sco_formsemestre
@@ -218,7 +218,7 @@ def make_xml_formsemestre_bulletinetud(
             code_apogee=quote_xml_attr(ue["code_apogee"]),
         )
         doc.append(x_ue)
-        if ue["type"] != sco_codes_parcours.UE_SPORT:
+        if ue["type"] != codes_cursus.UE_SPORT:
             v = ue_status["cur_moy_ue"] if ue_status else ""
         else:
             v = nt.bonus[etudid] if nt.bonus is not None else 0.0

app/scodoc/sco_config.py

@@ -98,7 +98,7 @@ CONFIG.PUBLISH_PORTAL_PHOTO_URL = False
 # (le test cracklib.FascistCheck s'appliquera dans tous les cas)
 CONFIG.MIN_PASSWORD_LENGTH = 0
 
-# Ce dictionnaire est fusionné à celui de sco_codes_parcours
+# Ce dictionnaire est fusionné à celui de codes_cursus
 # pour définir les codes jury et explications associées
 CONFIG.CODES_EXPL = {
     # AJ  : 'Ajourné (échec)',

app/scodoc/sco_cursus_dut.py

@@ -40,7 +40,7 @@ from app.scodoc.scolog import logdb
 from app.scodoc import sco_cache, sco_etud
 from app.scodoc import sco_formsemestre
 from app.scodoc import sco_formations
-from app.scodoc.sco_codes_parcours import (
+from app.scodoc.codes_cursus import (
     CMP,
     ADC,
     ADJ,
@@ -353,7 +353,7 @@ class SituationEtudCursusClassic(SituationEtudCursus):
         l'étudiant (quelle que soit la formation), le plus ancien en tête"""
         return self.sems
 
-    def get_parcours_descr(self, filter_futur=False):
+    def get_cursus_descr(self, filter_futur=False):
         """Description brève du parcours: "S1, S2, ..."
         Si filter_futur, ne mentionne pas les semestres qui sont après le semestre courant.
         """

app/scodoc/sco_edit_apc.py

@@ -31,7 +31,7 @@ from app import db
 from app.but import apc_edit_ue
 from app.models import UniteEns, Matiere, Module, FormSemestre, ModuleImpl
 from app.models.validations import ScolarFormSemestreValidation
-from app.scodoc.sco_codes_parcours import UE_SPORT
+from app.scodoc.codes_cursus import UE_SPORT
 import app.scodoc.sco_utils as scu
 from app.scodoc import sco_groups
 from app.scodoc.sco_utils import ModuleType
@@ -48,8 +48,8 @@ def html_edit_formation_apc(
     - Les ressources
     - Les SAÉs
     """
-    parcours = formation.get_parcours()
-    assert parcours.APC_SAE
+    cursus = formation.get_cursus()
+    assert cursus.APC_SAE
 
     ressources = formation.modules.filter_by(module_type=ModuleType.RESSOURCE).order_by(
         Module.semestre_id, Module.numero, Module.code
@@ -58,7 +58,7 @@ def html_edit_formation_apc(
         Module.semestre_id, Module.numero, Module.code
     )
     if semestre_idx is None:
-        semestre_ids = range(1, parcours.NB_SEM + 1)
+        semestre_ids = range(1, cursus.NB_SEM + 1)
     else:
         semestre_ids = [semestre_idx]
     other_modules = formation.modules.filter(

app/scodoc/sco_edit_formation.py

@@ -46,7 +46,7 @@ from app.scodoc.sco_exceptions import ScoValueError, ScoNonEmptyFormationObject
 
 from app.scodoc import html_sco_header
 from app.scodoc import sco_cache
-from app.scodoc import sco_codes_parcours
+from app.scodoc import codes_cursus
 from app.scodoc import sco_edit_ue
 from app.scodoc import sco_formations
 from app.scodoc import sco_formsemestre
@@ -157,7 +157,7 @@ def formation_edit(formation_id=None, create=False):
 """,
         ]
         submitlabel = "Créer cette formation"
-        initvalues = {"type_parcours": sco_codes_parcours.DEFAULT_TYPE_PARCOURS}
+        initvalues = {"type_parcours": codes_cursus.DEFAULT_TYPE_CURSUS}
         is_locked = False
     else:
         # edit an existing formation
@@ -211,8 +211,8 @@ def formation_edit(formation_id=None, create=False):
                     "input_type": "menu",
                     "title": "Type de parcours",
                     "type": "int",
-                    "allowed_values": sco_codes_parcours.FORMATION_PARCOURS_TYPES,
-                    "labels": sco_codes_parcours.FORMATION_PARCOURS_DESCRS,
+                    "allowed_values": codes_cursus.FORMATION_CURSUS_TYPES,
+                    "labels": codes_cursus.FORMATION_CURSUS_DESCRS,
                     "explanation": "détermine notamment le nombre de semestres et les règles de validation d'UE et de semestres (barres)",
                     "readonly": is_locked,
                 },

app/scodoc/sco_edit_module.py

@@ -52,7 +52,7 @@ from app.scodoc.sco_exceptions import (
     ScoNonEmptyFormationObject,
 )
 from app.scodoc import html_sco_header
-from app.scodoc import sco_codes_parcours
+from app.scodoc import codes_cursus
 from app.scodoc import sco_edit_matiere
 from app.scodoc import sco_moduleimpl
 
@@ -300,7 +300,7 @@ def module_edit(
         formation = module.formation
         unlocked = not module_is_locked(module_id)
 
-    parcours = sco_codes_parcours.get_parcours_from_code(formation.type_parcours)
+    parcours = codes_cursus.get_cursus_from_code(formation.type_parcours)
     is_apc = parcours.APC_SAE  # BUT
     if not create:
         orig_semestre_idx = module.ue.semestre_idx if is_apc else module.semestre_id
@@ -724,7 +724,7 @@ def module_edit(
                         )
                     ]
                 else:
-                    if module.ue.type == sco_codes_parcours.UE_STANDARD:
+                    if module.ue.type == codes_cursus.UE_STANDARD:
                         descr += [
                             (
                                 "app_critiques",
@@ -957,7 +957,7 @@ def formation_add_malus_modules(
     if semestre_id is not None:
         ues = ues.filter_by(semestre_idx=semestre_id)
     for ue in ues:
-        if ue.type == sco_codes_parcours.UE_STANDARD:
+        if ue.type == codes_cursus.UE_STANDARD:
             if ue_add_malus_module(ue, titre=titre) != None:
                 nb += 1
 

app/scodoc/sco_edit_ue.py

@@ -59,7 +59,7 @@ from app.scodoc.sco_exceptions import (
 )
 
 from app.scodoc import html_sco_header
-from app.scodoc import sco_codes_parcours
+from app.scodoc import codes_cursus
 from app.scodoc import sco_edit_apc
 from app.scodoc import sco_edit_matiere
 from app.scodoc import sco_edit_module
@@ -273,9 +273,9 @@ def ue_edit(ue_id=None, create=False, formation_id=None, default_semestre_idx=No
     formation = Formation.query.get(formation_id)
     if not formation:
         raise ScoValueError(f"Formation inexistante ! (id={formation_id})")
-    parcours = formation.get_parcours()
-    is_apc = parcours.APC_SAE
-    semestres_indices = list(range(1, parcours.NB_SEM + 1))
+    cursus = formation.get_cursus()
+    is_apc = cursus.APC_SAE
+    semestres_indices = list(range(1, cursus.NB_SEM + 1))
     H = [
         html_sco_header.sco_header(page_title=title, javascripts=["js/edit_ue.js"]),
         "<h2>" + title,
@@ -296,9 +296,9 @@ def ue_edit(ue_id=None, create=False, formation_id=None, default_semestre_idx=No
         else "",
     ]
 
-    ue_types = parcours.ALLOWED_UE_TYPES
+    ue_types = cursus.ALLOWED_UE_TYPES
     ue_types.sort()
-    ue_types_names = [sco_codes_parcours.UE_TYPE_NAME[k] for k in ue_types]
+    ue_types_names = [codes_cursus.UE_TYPE_NAME[k] for k in ue_types]
     ue_types = [str(x) for x in ue_types]
 
     form_descr = [
@@ -324,8 +324,8 @@ def ue_edit(ue_id=None, create=False, formation_id=None, default_semestre_idx=No
                     "input_type": "menu",
                     "type": "int",
                     "allow_null": False,
-                    "title": parcours.SESSION_NAME.capitalize(),
-                    "explanation": f"{parcours.SESSION_NAME} de l'UE dans la formation",
+                    "title": cursus.SESSION_NAME.capitalize(),
+                    "explanation": f"{cursus.SESSION_NAME} de l'UE dans la formation",
                     "labels": ["non spécifié"] + [str(x) for x in semestres_indices],
                     "allowed_values": [""] + semestres_indices,
                 },
@@ -433,7 +433,7 @@ def ue_edit(ue_id=None, create=False, formation_id=None, default_semestre_idx=No
             },
         ),
     ]
-    if create and not parcours.UE_IS_MODULE and not is_apc:
+    if create and not cursus.UE_IS_MODULE and not is_apc:
         form_descr.append(
             (
                 "create_matiere",
@@ -502,13 +502,13 @@ def ue_edit(ue_id=None, create=False, formation_id=None, default_semestre_idx=No
                     formation_id, int(tf[2]["semestre_idx"])
                 )
             ue_id = do_ue_create(tf[2])
-            if is_apc or parcours.UE_IS_MODULE or tf[2]["create_matiere"]:
+            if is_apc or cursus.UE_IS_MODULE or tf[2]["create_matiere"]:
                 # rappel: en APC, toutes les UE ont une matière, créée ici
                 # (inutilisée mais à laquelle les modules sont rattachés)
                 matiere_id = sco_edit_matiere.do_matiere_create(
                     {"ue_id": ue_id, "titre": tf[2]["titre"], "numero": 1},
                 )
-            if parcours.UE_IS_MODULE:
+            if cursus.UE_IS_MODULE:
                 # dans ce mode, crée un (unique) module dans l'UE:
                 _ = sco_edit_module.do_module_create(
                     {
@@ -560,14 +560,14 @@ def _add_ue_semestre_id(ues: list[dict], is_apc):
         if ue["semestre_idx"] is not None:
             ue["semestre_id"] = ue["semestre_idx"]
         elif is_apc:
-            ue["semestre_id"] = sco_codes_parcours.UE_SEM_DEFAULT
+            ue["semestre_id"] = codes_cursus.UE_SEM_DEFAULT
         else:
             # était le comportement ScoDoc7
             modules = sco_edit_module.module_list(args={"ue_id": ue["ue_id"]})
             if modules:
                 ue["semestre_id"] = modules[0]["semestre_id"]
             else:
-                ue["semestre_id"] = sco_codes_parcours.UE_SEM_DEFAULT
+                ue["semestre_id"] = codes_cursus.UE_SEM_DEFAULT
 
 
 def next_ue_numero(formation_id, semestre_id=None):
@@ -582,7 +582,7 @@ def next_ue_numero(formation_id, semestre_id=None):
         return ues[-1]["numero"] + 1000
     else:
         # Avec semestre: (prend le semestre du 1er module de l'UE)
-        _add_ue_semestre_id(ues, formation.get_parcours().APC_SAE)
+        _add_ue_semestre_id(ues, formation.get_cursus().APC_SAE)
         ue_list_semestre = [ue for ue in ues if ue["semestre_id"] == semestre_id]
         if ue_list_semestre:
             return ue_list_semestre[-1]["numero"] + 10
@@ -641,7 +641,7 @@ def ue_table(formation_id=None, semestre_idx=1, msg=""):  # was ue_list
     formation: Formation = Formation.query.get(formation_id)
     if not formation:
         raise ScoValueError("invalid formation_id")
-    parcours = formation.get_parcours()
+    parcours = formation.get_cursus()
     is_apc = parcours.APC_SAE
     locked = formation.has_locked_sems()
     if semestre_idx == "all" or semestre_idx == "":
@@ -1044,7 +1044,7 @@ def _ue_table_ues(
 
         if cur_ue_semestre_id != ue["semestre_id"]:
             cur_ue_semestre_id = ue["semestre_id"]
-            if ue["semestre_id"] == sco_codes_parcours.UE_SEM_DEFAULT:
+            if ue["semestre_id"] == codes_cursus.UE_SEM_DEFAULT:
                 lab = "Pas d'indication de semestre:"
             else:
                 lab = f"""Semestre {ue["semestre_id"]}:"""
@@ -1076,10 +1076,10 @@ def _ue_table_ues(
             """
             % ue
         )
-        if ue["type"] != sco_codes_parcours.UE_STANDARD:
+        if ue["type"] != codes_cursus.UE_STANDARD:
             H.append(
                 '<span class="ue_type">%s</span>'
-                % sco_codes_parcours.UE_TYPE_NAME[ue["type"]]
+                % codes_cursus.UE_TYPE_NAME[ue["type"]]
             )
         if ue["is_external"]:
             # Cas spécial: si l'UE externe a plus d'un module, c'est peut être une UE

app/scodoc/sco_export_results.py

@@ -37,7 +37,7 @@ import app.scodoc.sco_utils as scu
 from app import log
 from app.scodoc import html_sco_header
 from app.scodoc import sco_bac
-from app.scodoc import sco_codes_parcours
+from app.scodoc import codes_cursus
 from app.scodoc import sco_cache
 from app.scodoc import sco_formations
 from app.scodoc import sco_preferences
@@ -45,7 +45,7 @@ from app.scodoc import sco_pvjury
 from app.scodoc import sco_etud
 import sco_version
 from app.scodoc.gen_tables import GenTable
-from app.scodoc.sco_codes_parcours import NO_SEMESTRE_ID
+from app.scodoc.codes_cursus import NO_SEMESTRE_ID
 
 
 def _build_results_table(start_date=None, end_date=None, types_parcours=[]):
@@ -68,10 +68,10 @@ def _build_results_table(start_date=None, end_date=None, types_parcours=[]):
         sem["formation"] = sco_formations.formation_list(
             args={"formation_id": sem["formation_id"]}
         )[0]
-        sem["parcours"] = sco_codes_parcours.get_parcours_from_code(
+        sem["parcours"] = codes_cursus.get_cursus_from_code(
             sem["formation"]["type_parcours"]
         )
-        if sem["parcours"].TYPE_PARCOURS in types_parcours:
+        if sem["parcours"].TYPE_CURSUS in types_parcours:
             semlist_parcours.append(sem)
     formsemestre_ids_parcours = [sem["formsemestre_id"] for sem in semlist_parcours]
 
@@ -266,18 +266,18 @@ def scodoc_table_results(
     menu_options = []
     type_parcours_set = set()
     for sem in sorted(semlist, key=lambda x: x["dateord"]):
-        if sem["parcours"].TYPE_PARCOURS in types_parcours:
+        if sem["parcours"].TYPE_CURSUS in types_parcours:
             selected = "selected"
         else:
             selected = ""
-        if sem["parcours"].TYPE_PARCOURS not in type_parcours_set:
-            type_parcours_set.add(sem["parcours"].TYPE_PARCOURS)
+        if sem["parcours"].TYPE_CURSUS not in type_parcours_set:
+            type_parcours_set.add(sem["parcours"].TYPE_CURSUS)
             menu_options.append(
                 '<option value="%s" %s>%s</option>'
-                % (sem["parcours"].TYPE_PARCOURS, selected, sem["parcours"].__doc__)
+                % (sem["parcours"].TYPE_CURSUS, selected, sem["parcours"].__doc__)
             )
 
-        if sem["parcours"].TYPE_PARCOURS in types_parcours:
+        if sem["parcours"].TYPE_CURSUS in types_parcours:
             info_sems.append(
                 '<li><a class="stdlink" href="formsemestre_status?formsemestre_id=%(formsemestre_id)s">%(titremois)s</a></li>'
                 % sem

app/scodoc/sco_formations.py

@@ -48,7 +48,7 @@ from app.models.but_refcomp import (
     ApcReferentielCompetences,
 )
 from app.scodoc import sco_cache
-from app.scodoc import sco_codes_parcours
+from app.scodoc import codes_cursus
 from app.scodoc import sco_edit_matiere
 from app.scodoc import sco_edit_module
 from app.scodoc import sco_edit_ue
@@ -467,7 +467,7 @@ def formation_list_table(formation_id=None, args={}):
     # Traduit/ajoute des champs à afficher:
     for f in formations:
         try:
-            f["parcours_name"] = sco_codes_parcours.get_parcours_from_code(
+            f["parcours_name"] = codes_cursus.get_cursus_from_code(
                 f["type_parcours"]
             ).NAME
         except:

app/scodoc/sco_formsemestre.py

@@ -39,9 +39,9 @@ import app.scodoc.sco_utils as scu
 from app import log
 from app.models import Departement
 from app.models import FormSemestre
-from app.scodoc import sco_cache, sco_codes_parcours, sco_formations, sco_preferences
+from app.scodoc import sco_cache, codes_cursus, sco_formations, sco_preferences
 from app.scodoc.gen_tables import GenTable
-from app.scodoc.sco_codes_parcours import NO_SEMESTRE_ID
+from app.scodoc.codes_cursus import NO_SEMESTRE_ID
 from app.scodoc.sco_exceptions import ScoInvalidIdType, ScoValueError
 from app.scodoc.sco_vdi import ApoEtapeVDI
 
@@ -151,7 +151,7 @@ def _formsemestre_enrich(sem):
     if not formations:
         raise ScoValueError("pas de formation pour ce semestre !")
     F = formations[0]
-    parcours = sco_codes_parcours.get_parcours_from_code(F["type_parcours"])
+    parcours = codes_cursus.get_cursus_from_code(F["type_parcours"])
     # 'S1', 'S2', ... ou '' pour les monosemestres
     if sem["semestre_id"] != NO_SEMESTRE_ID:
         sem["sem_id_txt"] = "S%s" % sem["semestre_id"]

app/scodoc/sco_formsemestre_edit.py

@@ -50,7 +50,7 @@ from app.scodoc.sco_exceptions import AccessDenied, ScoValueError
 from app.scodoc.sco_permissions import Permission
 from app.scodoc.sco_vdi import ApoEtapeVDI
 from app.scodoc import html_sco_header
-from app.scodoc import sco_codes_parcours
+from app.scodoc import codes_cursus
 from app.scodoc import sco_compute_moy
 from app.scodoc import sco_edit_module
 from app.scodoc import sco_etud
@@ -206,7 +206,7 @@ def do_formsemestre_createwithmodules(edit=False, formsemestre: FormSemestre = N
 
     # Liste des ID de semestres
     if formation.type_parcours is not None:
-        parcours = sco_codes_parcours.get_parcours_from_code(formation.type_parcours)
+        parcours = codes_cursus.get_cursus_from_code(formation.type_parcours)
         nb_sem = parcours.NB_SEM
     else:
         nb_sem = 10  # fallback, max 10 semestres
@@ -1008,7 +1008,7 @@ def _formsemestre_check_module_list(module_ids, semestre_idx):
 def _formsemestre_check_ue_bonus_unicity(module_ids):
     """Vérifie qu'il n'y a qu'une seule UE bonus associée aux modules choisis"""
     ues = [Module.query.get_or_404(module_id).ue for module_id in module_ids]
-    ues_bonus = {ue.id for ue in ues if ue.type == sco_codes_parcours.UE_SPORT}
+    ues_bonus = {ue.id for ue in ues if ue.type == codes_cursus.UE_SPORT}
     if len(ues_bonus) > 1:
         raise ScoValueError(
             """Les modules de bonus sélectionnés ne sont pas tous dans la même UE bonus.

app/scodoc/sco_formsemestre_exterieurs.py

@@ -55,7 +55,7 @@ from app.scodoc import sco_formsemestre
 from app.scodoc import sco_formsemestre_inscriptions
 from app.scodoc import sco_formsemestre_validation
 from app.scodoc import sco_etud
-from app.scodoc.sco_codes_parcours import UE_SPORT
+from app.scodoc.codes_cursus import UE_SPORT
 
 
 def formsemestre_ext_create(etudid, sem_params):

app/scodoc/sco_formsemestre_inscriptions.py

@@ -43,7 +43,7 @@ import app.scodoc.sco_utils as scu
 from app import log
 from app.scodoc.scolog import logdb
 from app.scodoc.sco_exceptions import ScoException, ScoValueError
-from app.scodoc.sco_codes_parcours import UE_STANDARD, UE_SPORT, UE_TYPE_NAME
+from app.scodoc.codes_cursus import UE_STANDARD, UE_SPORT, UE_TYPE_NAME
 import app.scodoc.notesdb as ndb
 from app.scodoc.TrivialFormulator import TrivialFormulator
 from app.scodoc import sco_find_etud

app/scodoc/sco_formsemestre_status.py

@@ -56,7 +56,7 @@ from app.scodoc import htmlutils
 from app.scodoc import sco_abs
 from app.scodoc import sco_archives
 from app.scodoc import sco_bulletins
-from app.scodoc import sco_codes_parcours
+from app.scodoc import codes_cursus
 from app.scodoc import sco_compute_moy
 from app.scodoc import sco_edit_ue
 from app.scodoc import sco_evaluations
@@ -89,14 +89,14 @@ def _build_menu_stats(formsemestre_id):
             "enabled": True,
         },
         {
-            "title": "Graphe des parcours",
-            "endpoint": "notes.formsemestre_graph_parcours",
+            "title": "Graphe des cursus",
+            "endpoint": "notes.formsemestre_graph_cursus",
             "args": {"formsemestre_id": formsemestre_id},
             "enabled": True,
         },
         {
-            "title": "Codes des parcours",
-            "endpoint": "notes.formsemestre_suivi_parcours",
+            "title": "Codes des cursus",
+            "endpoint": "notes.formsemestre_suivi_cursus",
             "args": {"formsemestre_id": formsemestre_id},
             "enabled": True,
         },
@@ -577,7 +577,7 @@ def fill_formsemestre(sem):
         sem["eyelink"] = ""
     F = sco_formations.formation_list(args={"formation_id": sem["formation_id"]})[0]
     sem["formation"] = F
-    parcours = sco_codes_parcours.get_parcours_from_code(F["type_parcours"])
+    parcours = codes_cursus.get_cursus_from_code(F["type_parcours"])
     if sem["semestre_id"] != -1:
         sem["num_sem"] = f""", {parcours.SESSION_NAME} {sem["semestre_id"]}"""
     else:
@@ -617,7 +617,7 @@ def formsemestre_description_table(
     F = sco_formations.formation_list(args={"formation_id": formsemestre.formation_id})[
         0
     ]
-    parcours = sco_codes_parcours.get_parcours_from_code(F["type_parcours"])
+    parcours = codes_cursus.get_cursus_from_code(F["type_parcours"])
     # --- Colonnes à proposer:
     columns_ids = ["UE", "Code", "Module"]
     if with_parcours:
@@ -969,7 +969,7 @@ def formsemestre_status_head(formsemestre_id: int = None, page_title: str = None
     if not sem:
         raise ScoValueError("Semestre inexistant (il a peut être été supprimé ?)")
     formation: Formation = sem.formation
-    parcours = formation.get_parcours()
+    parcours = formation.get_cursus()
 
     page_title = page_title or "Modules de "
 
@@ -1268,7 +1268,7 @@ def formsemestre_tableau_modules(
 
             H.append("</td></tr>")
 
-        if modimpl["ue"]["type"] != sco_codes_parcours.UE_STANDARD:
+        if modimpl["ue"]["type"] != codes_cursus.UE_STANDARD:
             fontorange = " fontorange"  # style css additionnel
         else:
             fontorange = ""

app/scodoc/sco_formsemestre_validation.py

@@ -48,12 +48,12 @@ from app.models.validations import (
 from app.models.but_validations import ApcValidationRCUE, ApcValidationAnnee
 from app.scodoc.sco_exceptions import ScoValueError
 from app.scodoc.scolog import logdb
-from app.scodoc.sco_codes_parcours import *
+from app.scodoc.codes_cursus import *
 from app.scodoc.TrivialFormulator import TrivialFormulator, tf_error_message
 
 from app.scodoc import html_sco_header
 from app.scodoc import sco_abs
-from app.scodoc import sco_codes_parcours
+from app.scodoc import codes_cursus
 from app.scodoc import sco_cache
 from app.scodoc import sco_edit_ue
 from app.scodoc import sco_etud
@@ -179,13 +179,13 @@ def formsemestre_validation_etud_form(
                 etud["nomprenom"],
                 Se.parcours.SESSION_NAME_A,
                 Se.parcours.SESSION_NAME,
-                Se.get_parcours_descr(),
+                Se.get_cursus_descr(),
             )
         )
     else:
         H.append(
             '<h2 class="formsemestre">Parcours de %s</h2>%s'
-            % (etud["nomprenom"], Se.get_parcours_descr())
+            % (etud["nomprenom"], Se.get_cursus_descr())
         )
 
     H.append(
@@ -793,7 +793,7 @@ def form_decision_manuelle(Se, formsemestre_id, etudid, desturl="", sortcol=None
     )
 
     # Choix code semestre:
-    codes = sorted(sco_codes_parcours.CODES_JURY_SEM)
+    codes = sorted(codes_cursus.CODES_JURY_SEM)
     # fortuitement, cet ordre convient bien !
 
     H.append(
@@ -805,7 +805,7 @@ def form_decision_manuelle(Se, formsemestre_id, etudid, desturl="", sortcol=None
         if cod != ADC:
             H.append(
                 '<option value="%s">%s (code %s)</option>'
-                % (cod, sco_codes_parcours.CODES_EXPL[cod], cod)
+                % (cod, codes_cursus.CODES_EXPL[cod], cod)
             )
         elif Se.sem["gestion_compensation"]:
             # traitement spécial pour ADC (compensation)
@@ -845,24 +845,24 @@ def form_decision_manuelle(Se, formsemestre_id, etudid, desturl="", sortcol=None
                 sel = ""
             H.append(
                 '<option value="%s" %s>%s (code %s)</option>'
-                % (cod, sel, sco_codes_parcours.CODES_EXPL[cod], cod)
+                % (cod, sel, codes_cursus.CODES_EXPL[cod], cod)
             )
         H.append("</select></td></tr>")
 
     # Choix code devenir
-    codes = list(sco_codes_parcours.DEVENIR_EXPL.keys())
+    codes = list(codes_cursus.DEVENIR_EXPL.keys())
     codes.sort()  # fortuitement, cet ordre convient aussi bien !
 
     if Se.sem["semestre_id"] == -1:
-        allowed_codes = sco_codes_parcours.DEVENIRS_MONO
+        allowed_codes = codes_cursus.DEVENIRS_MONO
     else:
-        allowed_codes = set(sco_codes_parcours.DEVENIRS_STD)
+        allowed_codes = set(codes_cursus.DEVENIRS_STD)
         # semestres decales ?
         if Se.sem["gestion_semestrielle"]:
-            allowed_codes = allowed_codes.union(sco_codes_parcours.DEVENIRS_DEC)
+            allowed_codes = allowed_codes.union(codes_cursus.DEVENIRS_DEC)
         # n'autorise les codes NEXT2 que si semestres décalés et s'il ne manque qu'un semestre avant le n+2
         if Se.can_jump_to_next2():
-            allowed_codes = allowed_codes.union(sco_codes_parcours.DEVENIRS_NEXT2)
+            allowed_codes = allowed_codes.union(codes_cursus.DEVENIRS_NEXT2)
 
     H.append(
         '<tr><td>Devenir: </td><td><select name="devenir"><option value="" selected>Choisir...</option>'

app/scodoc/sco_groups.py

@@ -57,7 +57,7 @@ from app import log, cache
 from app.scodoc.scolog import logdb
 from app.scodoc import html_sco_header
 from app.scodoc import sco_cache
-from app.scodoc import sco_codes_parcours
+from app.scodoc import codes_cursus
 from app.scodoc import sco_cursus
 from app.scodoc import sco_etud
 from app.scodoc.sco_etud import etud_sort_key
@@ -326,7 +326,7 @@ def get_group_infos(group_id, etat=None):  # was _getlisteetud
             else:
                 t["etath"] = "(dem.)"
             nbdem += 1
-        elif t["etat"] == sco_codes_parcours.DEF:
+        elif t["etat"] == codes_cursus.DEF:
             t["etath"] = "Défaillant"
         else:
             t["etath"] = t["etat"]

app/scodoc/sco_groups_view.py

@@ -775,7 +775,7 @@ def groups_table(
             "boursier",
             "debouche",
             "parcours",
-            "codeparcours",
+            "code_cursus",
         ]
         titles = keys[:]
         other_partitions = sco_groups.get_group_other_partitions(groups_infos.groups[0])
@@ -791,8 +791,8 @@ def groups_table(
             Se = sco_cursus.get_situation_etud_cursus(
                 etud, groups_infos.formsemestre_id
             )
-            m["parcours"] = Se.get_parcours_descr()
-            m["codeparcours"], _ = sco_report.get_codeparcoursetud(etud)
+            m["parcours"] = Se.get_cursus_descr()
+            m["code_cursus"], _ = sco_report.get_code_cursus_etud(etud)
 
         L = [[m.get(k, "") for k in keys] for m in groups_infos.members]
         title = "etudiants_%s" % groups_infos.groups_filename

app/scodoc/sco_inscr_passage.py

@@ -40,7 +40,7 @@ from app.models import FormSemestre
 from app.scodoc.gen_tables import GenTable
 from app.scodoc import html_sco_header
 from app.scodoc import sco_cache
-from app.scodoc import sco_codes_parcours
+from app.scodoc import codes_cursus
 from app.scodoc import sco_etud
 from app.scodoc import sco_formations
 from app.scodoc import sco_formsemestre
@@ -258,11 +258,11 @@ def list_source_sems(sem, delai=None) -> list[dict]:
             if date_fin > date_debut_dst:
                 continue  # semestre trop récent
         # Elimine les semestres de formations speciales (sans parcours)
-        if s["semestre_id"] == sco_codes_parcours.NO_SEMESTRE_ID:
+        if s["semestre_id"] == codes_cursus.NO_SEMESTRE_ID:
             continue
         #
         F = sco_formations.formation_list(args={"formation_id": s["formation_id"]})[0]
-        parcours = sco_codes_parcours.get_parcours_from_code(F["type_parcours"])
+        parcours = codes_cursus.get_cursus_from_code(F["type_parcours"])
         if not parcours.ALLOW_SEM_SKIP:
             if s["semestre_id"] < (sem["semestre_id"] - 1):
                 continue

app/scodoc/sco_liste_notes.py

@@ -246,7 +246,7 @@ def _make_table_notes(
     modimpl = ModuleImpl.query.get_or_404(moduleimpl_id)
     module: Module = modimpl.module
     formsemestre: FormSemestre = modimpl.formsemestre
-    is_apc = module.formation.get_parcours().APC_SAE
+    is_apc = module.formation.get_cursus().APC_SAE
     if is_apc:
         res: ResultatsSemestreBUT = res_sem.load_formsemestre_results(formsemestre)
         is_conforme = modimpl.check_apc_conformity(res)

app/scodoc/sco_moduleimpl_inscriptions.py

@@ -43,7 +43,7 @@ from app.scodoc.scolog import logdb
 from app.scodoc import html_sco_header
 from app.scodoc import htmlutils
 from app.scodoc import sco_cache
-from app.scodoc import sco_codes_parcours
+from app.scodoc import codes_cursus
 from app.scodoc import sco_edit_module
 from app.scodoc import sco_edit_ue
 from app.scodoc import sco_etud
@@ -546,7 +546,7 @@ def _list_but_ue_inscriptions(res: NotesTableCompat, read_only: bool = True) ->
                         ScolarFormSemestreValidation.formsemestre_id
                         != res.formsemestre.id,
                         ScolarFormSemestreValidation.code.in_(
-                            sco_codes_parcours.CODES_UE_VALIDES
+                            codes_cursus.CODES_UE_VALIDES
                         ),
                     )
                     .join(UniteEns)
@@ -554,7 +554,7 @@ def _list_but_ue_inscriptions(res: NotesTableCompat, read_only: bool = True) ->
                     .all()
                 )
                 validations_ue.sort(
-                    key=lambda v: sco_codes_parcours.BUT_CODES_ORDERED.get(v.code, 0)
+                    key=lambda v: codes_cursus.BUT_CODES_ORDERED.get(v.code, 0)
                 )
                 validation = validations_ue[-1] if validations_ue else None
                 expl_validation = (

app/scodoc/sco_moduleimpl_status.py

@@ -42,7 +42,7 @@ from app.models import FormSemestre, ModuleImpl
 from app.models.evaluations import Evaluation
 from app.models.ues import UniteEns
 import app.scodoc.sco_utils as scu
-from app.scodoc.sco_codes_parcours import UE_SPORT
+from app.scodoc.codes_cursus import UE_SPORT
 from app.scodoc.sco_exceptions import ScoInvalidIdType
 from app.scodoc.sco_cursus_dut import formsemestre_has_decisions
 from app.scodoc.sco_permissions import Permission

app/scodoc/sco_page_etud.py

@@ -43,7 +43,7 @@ from app.scodoc import html_sco_header
 from app.scodoc import htmlutils
 from app.scodoc import sco_archives_etud
 from app.scodoc import sco_bac
-from app.scodoc import sco_codes_parcours
+from app.scodoc import codes_cursus
 from app.scodoc import sco_formsemestre
 from app.scodoc import sco_formsemestre_status
 from app.scodoc import sco_groups
@@ -82,10 +82,10 @@ def _menu_scolarite(authuser, sem: dict, etudid: int):
         dem_url = "scolar.do_cancel_dem"
 
     # Note: seul un etudiant inscrit (I) peut devenir défaillant.
-    if ins["etat"] != sco_codes_parcours.DEF:
+    if ins["etat"] != codes_cursus.DEF:
         def_title = "Déclarer défaillance"
         def_url = "scolar.form_def"
-    elif ins["etat"] == sco_codes_parcours.DEF:
+    elif ins["etat"] == codes_cursus.DEF:
         def_title = "Annuler la défaillance"
         def_url = "scolar.do_cancel_def"
     def_enabled = (
@@ -611,7 +611,7 @@ def etud_info_html(etudid, with_photo="1", debug=False):
         abort(404, "etudiant inconnu")
     photo_html = sco_photos.etud_photo_html(etud, title="fiche de " + etud["nom"])
     # experimental: may be too slow to be here
-    codeparcours, _ = sco_report.get_codeparcoursetud(etud, prefix="S", separator=", ")
+    code_cursus, _ = sco_report.get_code_cursus_etud(etud, prefix="S", separator=", ")
 
     bac = sco_bac.Baccalaureat(etud["bac"], etud["specialite"])
     bac_abbrev = bac.abbrev()
@@ -619,7 +619,7 @@ def etud_info_html(etudid, with_photo="1", debug=False):
     <div class="eid_left">
      <div class="eid_nom"><div>{etud["nomprenom"]}</div></div>
      <div class="eid_info eid_bac">Bac: <span class="eid_bac">{bac_abbrev}</span></div>
-     <div class="eid_info eid_parcours">{codeparcours}</div>
+     <div class="eid_info eid_parcours">{code_cursus}</div>
     """
 
     # Informations sur l'etudiant dans le semestre courant:

app/scodoc/sco_poursuite_dut.py

@@ -45,7 +45,7 @@ from app.scodoc import sco_preferences
 from app.scodoc import sco_etud
 import sco_version
 from app.scodoc.gen_tables import GenTable
-from app.scodoc.sco_codes_parcours import code_semestre_validant, code_semestre_attente
+from app.scodoc.codes_cursus import code_semestre_validant, code_semestre_attente
 
 
 def etud_get_poursuite_info(sem, etud):

app/scodoc/sco_prepajury.py

@@ -39,7 +39,7 @@ from app.comp import res_sem
 from app.comp.res_compat import NotesTableCompat
 from app.models import FormSemestre, Identite, ScolarAutorisationInscription
 from app.scodoc import sco_abs
-from app.scodoc import sco_codes_parcours
+from app.scodoc import codes_cursus
 from app.scodoc import sco_groups
 from app.scodoc import sco_etud
 from app.scodoc import sco_excel
@@ -129,7 +129,7 @@ def feuille_preparation_jury(formsemestre_id):
             [f"S{x.semestre_id}" for x in autorisations_etud]
         )
         # parcours:
-        parcours[etud.id] = Se.get_parcours_descr()
+        parcours[etud.id] = Se.get_cursus_descr()
         # groupe principal (td)
         groupestd[etud.id] = ""
         for s in Se.etud["sems"]:
@@ -295,12 +295,12 @@ def feuille_preparation_jury(formsemestre_id):
     #
     sheet.append_blank_row()
     # Explications des codes
-    codes = list(sco_codes_parcours.CODES_EXPL.keys())
+    codes = list(codes_cursus.CODES_EXPL.keys())
     codes.sort()
     sheet.append_single_cell_row("Explication des codes")
     for code in codes:
         sheet.append_row(
-            sheet.make_row(["", "", "", code, sco_codes_parcours.CODES_EXPL[code]])
+            sheet.make_row(["", "", "", code, codes_cursus.CODES_EXPL[code]])
         )
     sheet.append_row(
         sheet.make_row(

app/scodoc/sco_pvjury.py

@@ -69,7 +69,7 @@ import app.scodoc.sco_utils as scu
 import app.scodoc.notesdb as ndb
 from app import log
 from app.scodoc import html_sco_header
-from app.scodoc import sco_codes_parcours
+from app.scodoc import codes_cursus
 from app.scodoc import sco_cursus
 from app.scodoc import sco_cursus_dut
 from app.scodoc import sco_edit_ue
@@ -82,7 +82,7 @@ from app.scodoc import sco_pdf
 from app.scodoc import sco_preferences
 from app.scodoc import sco_pvpdf
 from app.scodoc.gen_tables import GenTable
-from app.scodoc.sco_codes_parcours import NO_SEMESTRE_ID
+from app.scodoc.codes_cursus import NO_SEMESTRE_ID
 from app.scodoc.sco_pdf import PDFLOCK
 from app.scodoc.TrivialFormulator import TrivialFormulator
 
@@ -96,16 +96,14 @@ def _descr_decisions_ues(nt, etudid, decisions_ue, decision_sem) -> list[dict]:
     for ue_id in decisions_ue.keys():
         try:
             if decisions_ue[ue_id] and (
-                sco_codes_parcours.code_ue_validant(decisions_ue[ue_id]["code"])
+                codes_cursus.code_ue_validant(decisions_ue[ue_id]["code"])
                 or (
                     (not nt.is_apc)
                     and (
                         # XXX ceci devrait dépendre du parcours et non pas être une option ! #sco8
                         decision_sem
                         and scu.CONFIG.CAPITALIZE_ALL_UES
-                        and sco_codes_parcours.code_semestre_validant(
-                            decision_sem["code"]
-                        )
+                        and codes_cursus.code_semestre_validant(decision_sem["code"])
                     )
                 )
             ):
@@ -134,7 +132,7 @@ def _descr_decision_sem(etat, decision_sem):
     else:
         if decision_sem:
             cod = decision_sem["code"]
-            decision = sco_codes_parcours.CODES_EXPL.get(cod, "")  # + ' (%s)' % cod
+            decision = codes_cursus.CODES_EXPL.get(cod, "")  # + ' (%s)' % cod
         else:
             decision = ""
     return decision
@@ -269,7 +267,7 @@ def dict_pvjury(
         ects_by_ue_code = _comp_ects_by_ue_code(nt, d["decisions_ue"])
         d["sum_ects"] = _sum_ects_dicts(ects_capitalises_by_ue_code, ects_by_ue_code)
 
-        if d["decision_sem"] and sco_codes_parcours.code_semestre_validant(
+        if d["decision_sem"] and codes_cursus.code_semestre_validant(
             d["decision_sem"]["code"]
         ):
             d["mention"] = scu.get_mention(nt.get_etud_moy_gen(etudid))
@@ -304,7 +302,7 @@ def dict_pvjury(
         d["autorisations_descr"] = descr_autorisations(autorisations)
 
         d["validation_parcours"] = Se.parcours_validated()
-        d["parcours"] = Se.get_parcours_descr(filter_futur=True)
+        d["parcours"] = Se.get_cursus_descr(filter_futur=True)
         if with_parcours_decisions:
             d["parcours_decisions"] = Se.get_parcours_decisions()
         # Observations sur les compensations:
@@ -604,7 +602,7 @@ def formsemestre_pvjury(formsemestre_id, format="html", publish=True):
             {
                 "code": code,
                 "count": counts[code],
-                "expl": sco_codes_parcours.CODES_EXPL.get(code, ""),
+                "expl": codes_cursus.CODES_EXPL.get(code, ""),
             }
         )
 

app/scodoc/sco_pvpdf.py

@@ -48,7 +48,7 @@ from app.models import FormSemestre, Identite
 
 import app.scodoc.sco_utils as scu
 from app.scodoc import sco_bulletins_pdf
-from app.scodoc import sco_codes_parcours
+from app.scodoc import codes_cursus
 from app.scodoc import sco_etud
 from app.scodoc import sco_pdf
 from app.scodoc import sco_preferences
@@ -892,7 +892,7 @@ def _pvjury_pdf_type(
     )
 
     # Légende des codes
-    codes = list(sco_codes_parcours.CODES_EXPL.keys())
+    codes = list(codes_cursus.CODES_EXPL.keys())
     codes.sort()
     objects += sco_pdf.make_paras(
         """<para spaceBefore="15mm" fontSize="14">
@@ -901,7 +901,7 @@ def _pvjury_pdf_type(
     )
     L = []
     for code in codes:
-        L.append((code, sco_codes_parcours.CODES_EXPL[code]))
+        L.append((code, codes_cursus.CODES_EXPL[code]))
     TableStyle2 = [
         (
             "FONTNAME",

app/scodoc/sco_report.py

@@ -49,7 +49,7 @@ from app.models.etudiants import Identite
 import app.scodoc.sco_utils as scu
 from app.scodoc import notesdb as ndb
 from app.scodoc import html_sco_header
-from app.scodoc import sco_codes_parcours
+from app.scodoc import codes_cursus
 from app.scodoc import sco_etud
 from app.scodoc import sco_formsemestre
 from app.scodoc import sco_formsemestre_inscriptions
@@ -58,7 +58,7 @@ from app.scodoc import sco_pvjury
 import sco_version
 from app.scodoc.gen_tables import GenTable
 from app import log
-from app.scodoc.sco_codes_parcours import code_semestre_validant
+from app.scodoc.codes_cursus import code_semestre_validant
 
 MAX_ETUD_IN_DESCR = 20
 
@@ -960,7 +960,7 @@ def _count_dem_reo(formsemestre_id, etudids):
         if nt.get_etud_etat(etudid) == "D":
             dems.add(etudid)
         dec = nt.get_etud_decision_sem(etudid)
-        if dec and dec["code"] in sco_codes_parcours.CODES_SEM_REO:
+        if dec and dec["code"] in codes_cursus.CODES_SEM_REO:
             reos.add(etudid)
     return dems, reos
 
@@ -1002,8 +1002,8 @@ def _codesem(sem, short=True, prefix=""):
     return "%s%s%s" % (prefix, idx, d)
 
 
-def get_codeparcoursetud(etud, prefix="", separator=""):
-    """calcule un code de parcours pour un etudiant
+def get_code_cursus_etud(etud, prefix="", separator=""):
+    """calcule un code de cursus (parcours) pour un etudiant
     exemples:
        1234A pour un etudiant ayant effectué S1, S2, S3, S4 puis diplome
        12D   pour un étudiant en S1, S2 puis démission en S2
@@ -1017,7 +1017,7 @@ def get_codeparcoursetud(etud, prefix="", separator=""):
     #
     p = []
     decisions_jury = {}
-    # élimine les semestres spéciaux sans parcours (LP...)
+    # élimine les semestres spéciaux hors cursus (LP en 1 sem., ...)
     sems = [s for s in etud["sems"] if s["semestre_id"] >= 0]
     i = len(sems) - 1
     while i >= 0:
@@ -1035,14 +1035,14 @@ def get_codeparcoursetud(etud, prefix="", separator=""):
                 decisions_jury[s["semestre_id"]] = ""
             else:
                 decisions_jury[s["semestre_id"]] = dec["code"]
-        # code etat dans le codeparcours sur dernier semestre seulement
+        # code etat dans le code_cursus sur dernier semestre seulement
         if i == 0:
             # Démission
             if nt.get_etud_etat(etud["etudid"]) == "D":
                 p.append(":D")
             else:
                 dec = nt.get_etud_decision_sem(etud["etudid"])
-                if dec and dec["code"] in sco_codes_parcours.CODES_SEM_REO:
+                if dec and dec["code"] in codes_cursus.CODES_SEM_REO:
                     p.append(":R")
                 if (
                     dec
@@ -1063,7 +1063,7 @@ def tsp_etud_list(
     civilite="",
     statut="",
 ):
-    """Liste des etuds a considerer dans table suivi parcours
+    """Liste des etuds a considerer dans table suivi cursus
     ramene aussi ensembles des bacs, genres, statuts de (tous) les etudiants
     """
     # log('tsp_etud_list(%s, bac="%s")' % (formsemestre_id,bac))
@@ -1102,7 +1102,8 @@ def tsp_etud_list(
 
 
 def tsp_grouped_list(codes_etuds):
-    """Liste pour table regroupant le nombre d'étudiants (+ bulle avec les noms) de chaque parcours"""
+    """Liste pour table regroupant le nombre d'étudiants
+    (+ bulle avec les noms) de chaque cursus (parcours)"""
     L = []
     parcours = list(codes_etuds.keys())
     parcours.sort()
@@ -1117,7 +1118,7 @@ def tsp_grouped_list(codes_etuds):
     return L
 
 
-def table_suivi_parcours(formsemestre_id, only_primo=False, grouped_parcours=True):
+def table_suivi_cursus(formsemestre_id, only_primo=False, grouped_parcours=True):
     """Tableau recapitulant tous les parcours"""
     sem = sco_formsemestre.get_formsemestre(formsemestre_id)
     etuds, bacs, bacspecialites, annee_bacs, civilites, statuts = tsp_etud_list(
@@ -1125,8 +1126,8 @@ def table_suivi_parcours(formsemestre_id, only_primo=False, grouped_parcours=Tru
     )
     codes_etuds = scu.DictDefault(defaultvalue=[])
     for etud in etuds:
-        etud["codeparcours"], etud["decisions_jury"] = get_codeparcoursetud(etud)
-        codes_etuds[etud["codeparcours"]].append(etud)
+        etud["code_cursus"], etud["decisions_jury"] = get_code_cursus_etud(etud)
+        codes_etuds[etud["code_cursus"]].append(etud)
         fiche_url = url_for(
             "scolar.ficheEtud", scodoc_dept=g.scodoc_dept, etudid=etud["etudid"]
         )
@@ -1135,13 +1136,13 @@ def table_suivi_parcours(formsemestre_id, only_primo=False, grouped_parcours=Tru
         etud["_nom_td_attrs"] = 'id="%s" class="etudinfo"' % (etud["etudid"])
 
     titles = {
-        "parcours": "Code parcours",
+        "parcours": "Code cursus",
         "nb": "Nombre d'étudiants",
         "civilite": "",
         "nom": "Nom",
         "prenom": "Prénom",
         "etudid": "etudid",
-        "codeparcours": "Code parcours",
+        "code_cursus": "Code cursus",
         "bac": "Bac",
         "specialite": "Spe.",
     }
@@ -1150,7 +1151,7 @@ def table_suivi_parcours(formsemestre_id, only_primo=False, grouped_parcours=Tru
         L = tsp_grouped_list(codes_etuds)
         columns_ids = ("parcours", "nb")
     else:
-        # Table avec le parcours de chaque étudiant:
+        # Table avec le cursus de chaque étudiant:
         L = etuds
         columns_ids = (
             "etudid",
@@ -1159,7 +1160,7 @@ def table_suivi_parcours(formsemestre_id, only_primo=False, grouped_parcours=Tru
             "prenom",
             "bac",
             "specialite",
-            "codeparcours",
+            "code_cursus",
         )
         # Calcule intitulés de colonnes
         S = set()
@@ -1198,7 +1199,7 @@ def table_suivi_parcours(formsemestre_id, only_primo=False, grouped_parcours=Tru
         bottom_titles={
             "parcours": "Total",
             "nb": len(etuds),
-            "codeparcours": len(etuds),
+            "code_cursus": len(etuds),
         },
         preferences=sco_preferences.SemPreferences(formsemestre_id),
     )
@@ -1232,14 +1233,14 @@ def tsp_form_primo_group(only_primo, no_grouping, formsemestre_id, format):
     return "\n".join(F)
 
 
-def formsemestre_suivi_parcours(
+def formsemestre_suivi_cursus(
     formsemestre_id,
     format="html",
     only_primo=False,
     no_grouping=False,
 ):
-    """Effectifs dans les differents parcours possibles."""
-    tab = table_suivi_parcours(
+    """Effectifs dans les differents cursus possibles."""
+    tab = table_suivi_cursus(
         formsemestre_id,
         only_primo=only_primo,
         grouped_parcours=not no_grouping,
@@ -1260,7 +1261,7 @@ def formsemestre_suivi_parcours(
             init_qtip=True,
             javascripts=["js/etud_info.js"],
         ),
-        """<h2 class="formsemestre">Parcours suivis par les étudiants de ce semestre</h2>""",
+        """<h2 class="formsemestre">Cursus suivis par les étudiants de ce semestre</h2>""",
         "\n".join(F),
         t,
         html_sco_header.sco_footer(),
@@ -1269,7 +1270,7 @@ def formsemestre_suivi_parcours(
 
 
 # -------------
-def graph_parcours(
+def graph_cursus(
     formsemestre_id,
     format="svg",
     only_primo=False,
@@ -1289,7 +1290,7 @@ def graph_parcours(
         civilite=civilite,
         statut=statut,
     )
-    # log('graph_parcours: %s etuds (only_primo=%s)' % (len(etuds), only_primo))
+    # log('graph_cursus: %s etuds (only_primo=%s)' % (len(etuds), only_primo))
     if not etuds:
         return "", etuds, bacs, bacspecialites, annee_bacs, civilites, statuts
     edges = scu.DictDefault(
@@ -1354,7 +1355,7 @@ def graph_parcours(
             if (
                 s["formsemestre_id"] == formsemestre_id
                 and dec
-                and dec["code"] == sco_codes_parcours.NAR
+                and dec["code"] == codes_cursus.NAR
             ):
                 nid = sem_node_name(s, "_nar_")
                 nar_nodes[s["formsemestre_id"]] = nid
@@ -1421,7 +1422,7 @@ def graph_parcours(
         n = g.get_node(nid)[0]
         n.set_color("red")
         n.set_shape("Mcircle")
-        n.set("label", sco_codes_parcours.NAR)
+        n.set("label", codes_cursus.NAR)
     # diplomes:
     for nid in diploma_nodes:
         n = g.get_node(nid)[0]
@@ -1493,7 +1494,7 @@ def graph_parcours(
     return data, etuds, bacs, bacspecialites, annee_bacs, civilites, statuts
 
 
-def formsemestre_graph_parcours(
+def formsemestre_graph_cursus(
     formsemestre_id,
     format="html",
     only_primo=False,
@@ -1506,7 +1507,7 @@ def formsemestre_graph_parcours(
 ):
     """Graphe suivi cohortes"""
     annee_bac = str(annee_bac)
-    # log("formsemestre_graph_parcours")
+    # log("formsemestre_graph_cursus")
     sem = sco_formsemestre.get_formsemestre(formsemestre_id)
     if format == "pdf":
         (
@@ -1517,7 +1518,7 @@ def formsemestre_graph_parcours(
             annee_bacs,
             civilites,
             statuts,
-        ) = graph_parcours(
+        ) = graph_cursus(
             formsemestre_id,
             format="pdf",
             only_primo=only_primo,
@@ -1539,7 +1540,7 @@ def formsemestre_graph_parcours(
             annee_bacs,
             civilites,
             statuts,
-        ) = graph_parcours(
+        ) = graph_cursus(
             formsemestre_id,
             format="png",
             only_primo=only_primo,
@@ -1575,7 +1576,7 @@ def formsemestre_graph_parcours(
             annee_bacs,
             civilites,
             statuts,
-        ) = graph_parcours(
+        ) = graph_cursus(
             formsemestre_id,
             only_primo=only_primo,
             bac=bac,
@@ -1587,10 +1588,10 @@ def formsemestre_graph_parcours(
 
         H = [
             html_sco_header.sco_header(
-                page_title="Parcours étudiants de %(titreannee)s" % sem,
+                page_title="Graphe cursus de %(titreannee)s" % sem,
                 no_side_bar=True,
             ),
-            """<h2 class="formsemestre">Parcours des étudiants de ce semestre</h2>""",
+            """<h2 class="formsemestre">Cursus des étudiants de ce semestre</h2>""",
             doc,
             "<p>%d étudiants sélectionnés</p>" % len(etuds),
             _gen_form_selectetuds(
@@ -1611,9 +1612,9 @@ def formsemestre_graph_parcours(
             """<p>Origine et devenir des étudiants inscrits dans %(titreannee)s"""
             % sem,
             """(<a href="%s">version pdf</a>"""
-            % url_for("notes.formsemestre_graph_parcours", format="pdf", **url_kw),
+            % url_for("notes.formsemestre_graph_cursus", format="pdf", **url_kw),
             """, <a href="%s">image PNG</a>)"""
-            % url_for("notes.formsemestre_graph_parcours", format="png", **url_kw),
+            % url_for("notes.formsemestre_graph_cursus", format="png", **url_kw),
             """</p>""",
             """<p class="help">Le graphe permet de suivre les étudiants inscrits dans le semestre
               sélectionné (dessiné en vert). Chaque rectangle représente un semestre (cliquez dedans

app/scodoc/sco_report_but.py

@@ -42,7 +42,7 @@ from app.models.formsemestre import FormSemestreInscription
 
 import app.scodoc.sco_utils as scu
 from app.scodoc import html_sco_header
-from app.scodoc import sco_codes_parcours
+from app.scodoc import codes_cursus
 from app.scodoc.sco_exceptions import ScoValueError
 
 from app.scodoc import sco_preferences
@@ -237,7 +237,7 @@ def _indicateurs_enquete_but(
                 [
                     True
                     for deca in decisions_annee.values()
-                    if deca.code_valide == sco_codes_parcours.NAR
+                    if deca.code_valide == codes_cursus.NAR
                 ]
             ),
             # Redoublants sans aucune RCUE

app/scodoc/sco_ue_external.py

@@ -63,7 +63,7 @@ import app.scodoc.sco_utils as scu
 from app import log
 from app.models import UniteEns
 from app.scodoc import html_sco_header
-from app.scodoc import sco_codes_parcours
+from app.scodoc import codes_cursus
 from app.scodoc import sco_edit_matiere
 from app.scodoc import sco_edit_module
 from app.scodoc import sco_edit_ue
@@ -80,7 +80,7 @@ def external_ue_create(
     formsemestre_id,
     titre="",
     acronyme="",
-    ue_type=sco_codes_parcours.UE_STANDARD,
+    ue_type=codes_cursus.UE_STANDARD,
     ects=0.0,
 ) -> int:
     """Crée UE/matiere/module dans la formation du formsemestre
@@ -252,12 +252,12 @@ def external_ue_create_form(formsemestre_id: int, etudid: int):
     """,
     ]
     html_footer = html_sco_header.sco_footer()
-    parcours = formsemestre.formation.get_parcours()
+    parcours = formsemestre.formation.get_cursus()
     ue_types = [
-        typ for typ in parcours.ALLOWED_UE_TYPES if typ != sco_codes_parcours.UE_SPORT
+        typ for typ in parcours.ALLOWED_UE_TYPES if typ != codes_cursus.UE_SPORT
     ]
     ue_types.sort()
-    ue_types_names = [sco_codes_parcours.UE_TYPE_NAME[k] for k in ue_types]
+    ue_types_names = [codes_cursus.UE_TYPE_NAME[k] for k in ue_types]
     ue_types = [str(x) for x in ue_types]
 
     if existing_external_ue:

app/scodoc/sco_utils.py

@@ -58,7 +58,7 @@ from werkzeug.http import HTTP_STATUS_CODES
 from config import Config
 from app import log
 from app.scodoc.sco_vdi import ApoEtapeVDI
-from app.scodoc.sco_codes_parcours import NOTES_TOLERANCE, CODES_EXPL
+from app.scodoc.codes_cursus import NOTES_TOLERANCE, CODES_EXPL
 from app.scodoc import sco_xml
 import sco_version
 

app/tables/jury_recap.py

@@ -26,7 +26,7 @@ from app.models.etudiants import Identite
 from app.scodoc.sco_exceptions import ScoNoReferentielCompetences
 from app.models.formsemestre import FormSemestre
 from app.scodoc import html_sco_header
-from app.scodoc.sco_codes_parcours import (
+from app.scodoc.codes_cursus import (
     BUT_BARRE_RCUE,
     BUT_RCUE_SUFFISANT,
 )

app/tables/recap.py

@@ -14,7 +14,7 @@ from app.auth.models import User
 from app.comp.res_common import ResultatsSemestre
 from app.models import Identite
 from app.models.ues import UniteEns
-from app.scodoc.sco_codes_parcours import UE_SPORT, DEF
+from app.scodoc.codes_cursus import UE_SPORT, DEF
 from app.scodoc import sco_evaluation_db
 from app.scodoc import sco_groups
 from app.scodoc import sco_utils as scu
@@ -63,10 +63,10 @@ class TableRecap(tb.Table):
         self.include_evaluations = include_evaluations
         self.mode_jury = mode_jury
         self.read_only = read_only  # utilisé seulement dans sous-classes
-        parcours = res.formsemestre.formation.get_parcours()
-        self.barre_moy = parcours.BARRE_MOY - scu.NOTES_TOLERANCE
-        self.barre_valid_ue = parcours.NOTES_BARRE_VALID_UE
-        self.barre_warning_ue = parcours.BARRE_UE_DISPLAY_WARNING
+        cursus = res.formsemestre.formation.get_cursus()
+        self.barre_moy = cursus.BARRE_MOY - scu.NOTES_TOLERANCE
+        self.barre_valid_ue = cursus.NOTES_BARRE_VALID_UE
+        self.barre_warning_ue = cursus.BARRE_UE_DISPLAY_WARNING
         self.cache_nomcomplet = {}  # cache uid : nomcomplet
         if convert_values:
             self.fmt_note = scu.fmt_note

app/templates/formsemestre_header.j2

@@ -8,7 +8,7 @@
             scodoc_dept=g.scodoc_dept, formsemestre_id=sco.sem.id)
         }}">{{sco.sem.titre}}</a>
             <a title="{{sco.sem.etapes_apo_str()}}">
-                {% if sco.sem.semestre_id != -1 %}, {{sco.sem.formation.get_parcours().SESSION_NAME}}
+                {% if sco.sem.semestre_id != -1 %}, {{sco.sem.formation.get_cursus().SESSION_NAME}}
                 {{sco.sem.semestre_id}}
                 {% endif %}</a>
             {% if sco.sem.modalite %} en {{sco.sem.modalite}}{% endif %}</span>

app/templates/formsemestre_page_title.j2

@@ -4,31 +4,22 @@
 
 <div class="formsemestre_page_title">
     <div class="infos">
-        <span class="semtitle"><a class="stdlink" 
-        title="{{formsemestre.session_id()}}"
-        href="{{url_for('notes.formsemestre_status', 
-            scodoc_dept=g.scodoc_dept, formsemestre_id=formsemestre.id)}}"
-        >{{formsemestre.titre}}</a>
+        <span class="semtitle"><a class="stdlink" title="{{formsemestre.session_id()}}" href="{{url_for('notes.formsemestre_status', 
+            scodoc_dept=g.scodoc_dept, formsemestre_id=formsemestre.id)}}">{{formsemestre.titre}}</a>
             {%- if formsemestre.semestre_id != -1 -%}
-            <a
-            title="{{formsemestre.etapes_apo_str()
+            <a title="{{formsemestre.etapes_apo_str()
             }}">, {{
-            formsemestre.formation.get_parcours().SESSION_NAME}}
+                formsemestre.formation.get_cursus().SESSION_NAME}}
                 {{formsemestre.semestre_id}}</a>
             {%- endif -%}
             {%- if formsemestre.modalite %} en {{formsemestre.modalite}}
-        {%- endif %}</span><span
-        class="dates"><a 
-        title="du {{formsemestre.date_debut.strftime('%d/%m/%Y')}} 
-        au {{formsemestre.date_fin.strftime('%d/%m/%Y')}} "
-        >{{formsemestre.mois_debut()}} - {{formsemestre.mois_fin()}}</a></span><span 
-        class="resp"><a title="{{formsemestre.responsables_str(abbrev_prenom=False)}}">{{formsemestre.responsables_str()}}</a></span><span 
-        class="nbinscrits"><a class="discretelink" 
-        href="{{url_for('scolar.groups_view', 
+            {%- endif %}</span><span class="dates"><a title="du {{formsemestre.date_debut.strftime('%d/%m/%Y')}} 
+        au {{formsemestre.date_fin.strftime('%d/%m/%Y')}} ">{{formsemestre.mois_debut()}} -
+                {{formsemestre.mois_fin()}}</a></span><span class="resp"><a
+                title="{{formsemestre.responsables_str(abbrev_prenom=False)}}">{{formsemestre.responsables_str()}}</a></span><span
+            class="nbinscrits"><a class="discretelink" href="{{url_for('scolar.groups_view', 
             scodoc_dept=g.scodoc_dept, formsemestre_id=formsemestre.id)
-        }}"
-        >{{formsemestre.etuds_inscriptions|length}} inscrits</a></span><span 
-        class="lock">
+        }}">{{formsemestre.etuds_inscriptions|length}} inscrits</a></span><span class="lock">
             {%-if not formsemestre.etat -%}
             <a href="{{ url_for( 'notes.formsemestre_change_lock', 
         scodoc_dept=g.scodoc_dept, formsemestre_id=formsemestre.id )}}">{{

app/templates/pn/form_mods.j2

@@ -49,7 +49,7 @@
             <span class="formation_module_ue">(<a title="UE de rattachement">{{mod.ue.acronyme}}</a>)</span>,
             {% endif %}
 
-            - parcours <b>{{ mod.get_parcours()|map(attribute="code")|join("</b>, <b>")|default('tronc commun',
+            - parcours <b>{{ mod.get_cursus()|map(attribute="code")|join("</b>, <b>")|default('tronc commun',
                 true)|safe
                 }}</b>
             {% if mod.heures_cours or mod.heures_td or mod.heures_tp %}

app/views/notes.py

@@ -3207,8 +3207,8 @@ sco_publish(
     Permission.ScoView,
 )
 sco_publish(
-    "/formsemestre_suivi_parcours",
-    sco_report.formsemestre_suivi_parcours,
+    "/formsemestre_suivi_cursus",
+    sco_report.formsemestre_suivi_cursus,
     Permission.ScoView,
 )
 sco_publish(
@@ -3222,8 +3222,8 @@ sco_publish(
     Permission.ScoView,
 )
 sco_publish(
-    "/formsemestre_graph_parcours",
-    sco_report.formsemestre_graph_parcours,
+    "/formsemestre_graph_cursus",
+    sco_report.formsemestre_graph_cursus,
     Permission.ScoView,
 )
 sco_publish(

app/views/pn_modules.py

@@ -37,7 +37,7 @@ from flask import current_app, g, request
 from flask.templating import render_template
 from flask_login import current_user
 from werkzeug.utils import redirect
-from app.scodoc.sco_codes_parcours import UE_SPORT
+from app.scodoc.codes_cursus import UE_SPORT
 
 from config import Config
 
@@ -232,7 +232,7 @@ def edit_modules_ue_coefs():
             read_only=locked
             or not current_user.has_permission(Permission.ScoChangeFormation),
             semestre_idx=semestre_idx,
-            semestre_ids=range(1, formation.get_parcours().NB_SEM + 1),
+            semestre_ids=range(1, formation.get_cursus().NB_SEM + 1),
             parcours_id=parcours_id,
         ),
         html_sco_header.sco_footer(),

app/views/scolar.py

@@ -75,7 +75,7 @@ from app.scodoc.gen_tables import GenTable
 from app.scodoc import html_sco_header
 from app.scodoc import sco_import_etuds
 from app.scodoc import sco_archives_etud
-from app.scodoc import sco_codes_parcours
+from app.scodoc import codes_cursus
 from app.scodoc import sco_cache
 from app.scodoc import sco_debouche
 from app.scodoc import sco_dept
@@ -1160,7 +1160,7 @@ def do_def_etudiant(etudid, formsemestre_id, event_date=None):
         etudid,
         formsemestre_id,
         event_date=event_date,
-        etat_new=sco_codes_parcours.DEF,
+        etat_new=codes_cursus.DEF,
         operation_method="defailleEtudiant",
         event_type="DEFAILLANCE",
     )
@@ -1221,7 +1221,7 @@ def do_cancel_def(etudid, formsemestre_id, dialog_confirmed=False, args=None):
         dialog_confirmed=dialog_confirmed,
         args=args,
         operation_name="défaillance",
-        etat_current=sco_codes_parcours.DEF,
+        etat_current=codes_cursus.DEF,
         etat_new=scu.INSCRIT,
         operation_method="cancel_def",
         event_type="DEFAILLANCE",

misc/csv2rules.py

@@ -48,7 +48,7 @@ HEAD = """# -*- coding: utf-8 -*-
 #
 # Command: %s %s
 # 
-from sco_codes_parcours import (
+from codes_cursus import (
     DUTRule,
     ADC,
     ADJ,

tests/unit/sco_fake_gen.py

@@ -19,7 +19,7 @@ from config import Config
 from app.auth.models import User
 from app.models import FormationModalite, Matiere
 from app.scodoc import notesdb as ndb
-from app.scodoc import sco_codes_parcours
+from app.scodoc import codes_cursus
 from app.scodoc import sco_edit_formation
 from app.scodoc import sco_edit_matiere
 from app.scodoc import sco_edit_module
@@ -154,7 +154,7 @@ class ScoFake(object):
         acronyme="test",
         titre="Formation test",
         titre_officiel="Le titre officiel de la formation test",
-        type_parcours=sco_codes_parcours.ParcoursDUT.TYPE_PARCOURS,
+        type_parcours=codes_cursus.CursusDUT.TYPE_CURSUS,
         formation_code=None,
         code_specialite=None,
     ) -> int:
@@ -430,8 +430,8 @@ class ScoFake(object):
         self,
         formsemestre_id,
         etud,
-        code_etat=sco_codes_parcours.ADM,
-        devenir=sco_codes_parcours.NEXT,
+        code_etat=codes_cursus.ADM,
+        devenir=codes_cursus.NEXT,
         assidu=True,
     ):
         """Affecte décision de jury"""

tests/unit/setup.py

@@ -5,7 +5,7 @@ Quelques fonctions d'initialisation pour tests unitaires
 from app import models
 
 import app.scodoc.sco_utils as scu
-from app.scodoc import sco_codes_parcours
+from app.scodoc import codes_cursus
 
 # Valeurs des notes saisies par les tests:
 NOTES_T = [
@@ -16,14 +16,14 @@ from tests.unit import sco_fake_gen
 
 
 def build_formation_test(
-    nb_mods=1, parcours=sco_codes_parcours.ParcoursBUT, with_ue_sport=False
+    nb_mods=1, parcours=codes_cursus.CursusBUT, with_ue_sport=False
 ):
     G = sco_fake_gen.ScoFake(verbose=False)
     formation_id = G.create_formation(
         acronyme="F3",
         titre="Formation 2",
         titre_officiel="Titre officiel 2",
-        type_parcours=parcours.TYPE_PARCOURS,
+        type_parcours=parcours.TYPE_CURSUS,
     )
     _ue1 = G.create_ue(
         formation_id=formation_id, acronyme="UE1", titre="ue 1", semestre_idx=2
@@ -59,7 +59,7 @@ def build_formation_test(
             acronyme="UESPO",
             titre="ue sport",
             semestre_idx=2,
-            type=sco_codes_parcours.UE_SPORT,
+            type=codes_cursus.UE_SPORT,
         )
         ue_ids.append(ue_sport)
         mat_sport = G.create_matiere(ue_id=ue_sport, titre="matière spo")
@@ -109,7 +109,7 @@ def build_modules_with_evaluations(
             formsemestre_id=formsemestre_id,
         )
         modimpl = models.ModuleImpl.query.get(moduleimpl_id)
-        assert modimpl.formsemestre.formation.get_parcours().APC_SAE  # BUT
+        assert modimpl.formsemestre.formation.get_cursus().APC_SAE  # BUT
         # Check ModuleImpl
         ues = modimpl.formsemestre.query_ues().all()
         assert len(ues) == 3

tests/unit/test_but_ues.py

@@ -9,7 +9,7 @@ from app.comp import moy_ue
 from app.comp import inscr_mod
 from app.models import FormSemestre, Evaluation, ModuleImplInscription
 from app.scodoc import sco_saisie_notes
-from app.scodoc.sco_codes_parcours import UE_SPORT
+from app.scodoc.codes_cursus import UE_SPORT
 from app.scodoc.sco_utils import NOTES_NEUTRALISE
 from app.scodoc import sco_exceptions
 

tests/unit/test_sco_basic.py

@@ -26,7 +26,7 @@ from app.scodoc import sco_formsemestre
 from app.scodoc import sco_abs
 from app.scodoc import sco_abs_views
 from app.scodoc import sco_bulletins
-from app.scodoc import sco_codes_parcours
+from app.scodoc import codes_cursus
 from app.scodoc import sco_evaluations
 from app.scodoc import sco_evaluation_db
 from app.scodoc import sco_formsemestre_validation
@@ -207,7 +207,7 @@ def run_sco_basic(verbose=False) -> FormSemestre:
     # Saisie d'un décision AJ, non assidu
     etudid = etuds[-1]["etudid"]
     sco_cursus_dut.formsemestre_validate_ues(
-        formsemestre_id, etudid, sco_codes_parcours.AJ, False
+        formsemestre_id, etudid, codes_cursus.AJ, False
     )
     assert sco_cursus_dut.formsemestre_has_decisions(
         formsemestre_id
@@ -225,7 +225,7 @@ def run_sco_basic(verbose=False) -> FormSemestre:
         sco_formsemestre_validation.formsemestre_validation_etud_manu(
             formsemestre_id,
             etud["etudid"],
-            code_etat=sco_codes_parcours.ADJ,
+            code_etat=codes_cursus.ADJ,
             assidu=True,
             redirect=False,
         )

tools/scodoc_config.py

@@ -126,7 +126,7 @@ CONFIG.PUBLISH_PORTAL_PHOTO_URL = (
 CONFIG.MIN_PASSWORD_LENGTH = 0  # si > 0: longueur minimale requise des nouveaux mots de passe (le test cracklib.FascistCheck s'appliquera dans tous les cas)
 
 # ----------------------------------------------------
-# Ce dictionnaire est fusionné à celui de sco_codes_parcours
+# Ce dictionnaire est fusionné à celui de codes_cursus
 # pour définir les codes jury et explications associées
 CONFIG.CODES_EXPL = {
     # AJ  : 'Ajourné (échec)',

tools/scodoc_config_tmpl.py

@@ -113,7 +113,7 @@ CONFIG = CFG()
 # CONFIG.MIN_PASSWORD_LENGTH = 0
 
 
-# Ce dictionnaire est fusionné à celui de sco_codes_parcours
+# Ce dictionnaire est fusionné à celui de codes_cursus
 # pour définir les codes jury et explications associées
 # CONFIG.CODES_EXPL = {
 #    # AJ  : 'Ajourné (échec)',