1
0
forked from ScoDoc/ScoDoc

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

This commit is contained in:
Emmanuel Viennet 2023-02-12 13:36:47 +01:00
parent 211054a9af
commit d55e393c15
77 changed files with 402 additions and 418 deletions

View File

@ -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:

View File

@ -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:

View File

@ -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

View File

@ -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()

View File

@ -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

View File

@ -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 dune 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"

View File

@ -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">

View File

@ -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:

View File

@ -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

View File

@ -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

View File

@ -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

View File

@ -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)
)

View File

@ -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

View File

@ -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

View File

@ -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

View File

@ -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]:

View File

@ -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_]*$",

View File

@ -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

View File

@ -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,

View File

@ -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)"""

View File

@ -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" """

View File

@ -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
):

View File

@ -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

View File

@ -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"]

View File

@ -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(
[

View File

@ -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

View File

@ -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,

View File

@ -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(

View File

@ -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,

View File

@ -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,

View File

@ -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"

View File

@ -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,

View File

@ -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

View File

@ -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)',

View File

@ -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.
"""

View File

@ -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(

View File

@ -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,
},

View File

@ -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

View File

@ -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

View File

@ -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

View File

@ -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:

View File

@ -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"]

View File

@ -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.

View File

@ -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):

View File

@ -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

View File

@ -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 = ""

View File

@ -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>'

View File

@ -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"]

View File

@ -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

View File

@ -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

View File

@ -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)

View File

@ -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 = (

View File

@ -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

View File

@ -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:

View File

@ -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):

View File

@ -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(

View File

@ -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, ""),
}
)

View File

@ -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",

View File

@ -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

View File

@ -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

View File

@ -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:

View File

@ -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

View File

@ -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,
)

View File

@ -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

View File

@ -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>

View File

@ -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 )}}">{{

View File

@ -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 %}

View File

@ -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(

View File

@ -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(),

View File

@ -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",

View File

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

View File

@ -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"""

View File

@ -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

View File

@ -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

View File

@ -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,
)

View File

@ -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)',

View File

@ -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)',