def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom_cible = self.a_interpreter
persos = personnage.salle.personnages
objets = []
cibles = []
for o in personnage.salle.objets_sol:
objets.append(o)
for o in personnage.equipement.tenus:
objets.append(o)
for p in persos:
if p is not personnage and contient(p.get_nom_pour(personnage),
nom_cible):
cibles.append(p)
for o in objets:
if contient(o.nom_singulier, nom_cible):
cibles.append(o)
if not cibles:
raise ErreurValidation("|err|Cette cible est introuvable.|ff|")
self.cibles = cibles
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
message = self.a_interpreter
self.texte = message
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom_type = self.a_interpreter
self.nom_type = nom_type
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
coordonnees = self.a_interpreter
coordonnees = tuple(int(e) for e in coordonnees.split("."))
self.coordonnees = coordonnees
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
salle = personnage.salle
nom = self.a_interpreter
t_nom = supprimer_accents(nom).lower()
familiers = importeur.familier.familiers_de(personnage)
familiers = [f for f in familiers if f.pnj]
if self.salle_identique:
familiers = [f for f in familiers if f.pnj.salle is salle]
familier = None
for t_familier in familiers:
if supprimer_accents(t_familier.nom).lower() == t_nom:
familier = t_familier
break
if not self.nouveau and familier is None:
raise ErreurValidation(
"|err|Le familier {} ne peut être trouvé.|ff|".format(nom))
elif self.nouveau and familier:
raise ErreurValidation(
"|err|Le familier {} existe déjà.|ff|".format(nom))
self.nom_familier = nom
self.familier = familier
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
prompt = self.a_interpreter
self.prompt = prompt
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom = self.a_interpreter
salle = personnage.salle
x, y, z = salle.coords.tuple()
etendue = salle.etendue
if not etendue:
raise ErreurValidation(
"Il n'y a pas de navires suffisamment proches.")
navires = list(importeur.navigation.navires.values())
navires = [n for n in navires if n.etendue is etendue and \
contient(n.desc_survol, nom)]
navires = [n for n in navires if mag(n.position.x, n.position.y,
n.position.z, x, y, z) < 15]
if not navires:
raise ErreurValidation(
"Ce navire est introuvable.")
navire = navires[0]
self.nom_navire = navire.nom
self.navire = navire
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
chemin_commande = self.a_interpreter
trans_param = True # doit-on transmettre les sous-commandes ?
if chemin_commande.endswith("."):
chemin_commande = chemin_commande[:-1]
trans_param = False
# On cherche dans les chemins des commandes, dans interpreteur.groupes
chemins = type(self).importeur.interpreteur.groupes.commandes.keys()
commandes = []
for chemin in chemins:
if chemin == chemin_commande:
commandes.append(chemin)
elif trans_param and chemin.startswith(chemin_commande + SEP):
commandes.append(chemin)
if not commandes:
raise ErreurValidation(
"|err|Aucune commande correspondant au chemin n'a pu être " \
"trouvée.|ff|")
self.chemins = commandes
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom = self.a_interpreter
salle = personnage.salle
if not hasattr(salle, "navire"):
raise ErreurValidation(
"|err|Vous n'êtes pas sur un navire.|ff|")
navire = salle.navire
equipage = navire.equipage
matelot = None
try:
matelot = equipage.get_matelot(nom)
except KeyError:
pass
if not self.nouveau and matelot is None:
raise ErreurValidation(
"|err|Le matelot {} ne peut être trouvé.|ff|".format(nom))
elif self.nouveau and matelot:
raise ErreurValidation(
"|err|Le matelot {} existe déjà.|ff|".format(nom))
self.nom_matelot = nom
self.matelot = matelot
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
message = self.a_interpreter
self.message = message
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
id_conversation = self.a_interpreter
conversations = type(self).importeur.communication.conversations
p_conversations = conversations.get_conversations_pour(personnage)
cible = None
if id_conversation == "-":
self.perte_focus = True
return True
try:
id_conversation = int(id_conversation)
except ValueError:
return False
for conversation in p_conversations:
if conversation.id == id_conversation:
cible = conversation.cible
break
if cible is None:
raise ErreurValidation(
"|err|Le numéro spécifié ne correspond à aucun personnage.|ff|"
)
else:
self.id_conversation = id_conversation
self.cible = cible
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
coordonnees = self.a_interpreter
coordonnees = tuple(int(e) for e in coordonnees.split("."))
self.coords = coordonnees
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom_cible = self.a_interpreter
persos = personnage.salle.personnages
objets = []
cibles = []
for o in personnage.salle.objets_sol:
objets.append(o)
for o in personnage.equipement.tenus:
objets.append(o)
for p in persos:
if p is not personnage and contient(
p.get_nom_pour(personnage), nom_cible):
cibles.append(p)
for o in objets:
if contient(o.nom_singulier, nom_cible):
cibles.append(o)
if not cibles:
raise ErreurValidation("|err|Cette cible est introuvable.|ff|")
self.cibles = cibles
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom = self.a_interpreter
salle = personnage.salle
if not hasattr(salle, "navire"):
raise ErreurValidation("|err|Vous n'êtes pas sur un navire.|ff|")
navire = salle.navire
equipage = navire.equipage
matelot = None
try:
matelot = equipage.get_matelot(nom)
except KeyError:
pass
if not self.nouveau and matelot is None:
raise ErreurValidation(
"|err|Le matelot {} ne peut être trouvé.|ff|".format(nom))
elif self.nouveau and matelot:
raise ErreurValidation(
"|err|Le matelot {} existe déjà.|ff|".format(nom))
self.nom_matelot = nom
self.matelot = matelot
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
duree = self.a_interpreter
res = RE_DUREE.search(duree)
if not res:
raise ErreurValidation("Durée invalide.")
nb, mesure = res.groups()
nb = int(nb)
mesure = mesure.lower()
if mesure in ("s", "sec", "seconde", "secondes"):
mult = 1
nom_complet = "seconde"
elif mesure in ("m", "mn", "min", "minute", "minutes"):
mult = 60
nom_complet = "minute"
elif mesure in ("h", "hr", "heure", "heures"):
mult = 3600
nom_complet = "heure"
elif mesure in ("j", "jr", "jour", "jours"):
mult = 86400
nom_complet = "jour"
else:
raise ErreurValidation("Mesure {} inconnue.".format(mesure))
self.secondes = mult * nb
s = ""
if nb > 1:
s = "s"
self.temps = "{} {}{s}".format(nb, nom_complet, s=s)
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom = self.a_interpreter
salle = personnage.salle
cale = salle.navire.cale
for objet, nombre in cale.conteneur.iter_nombres():
if contient(objet.get_nom(nombre), nom):
self.objets.append(objet)
for conteneur in cale.conteneurs.values():
for cle in conteneur.keys():
try:
prototype = importeur.objet.prototypes[cle]
except KeyError:
continue
if contient(prototype.nom_singulier, nom) or contient(
prototype.nom_pluriel, nom):
self.prototype = prototype
return True
if not self.objets:
raise ErreurValidation("Cet objet n'est pas trouvable dans la " \
"cale de ce navire.")
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
duree = self.a_interpreter
res = RE_DUREE.search(duree)
if not res:
raise ErreurValidation("Durée invalide.")
nb, mesure = res.groups()
nb = int(nb)
mesure = mesure.lower()
if mesure in ("s", "sec", "seconde", "secondes"):
mult = 1
nom_complet = "seconde"
elif mesure in ("m", "mn", "min", "minute", "minutes"):
mult = 60
nom_complet = "minute"
elif mesure in ("h", "hr", "heure", "heures"):
mult = 3600
nom_complet = "heure"
elif mesure in ("j", "jr", "jour", "jours"):
mult = 86400
nom_complet = "jour"
else:
raise ErreurValidation("Mesure {} inconnue.".format(mesure))
self.secondes = mult * nb
s = ""
if nb > 1:
s = "s"
self.temps = "{} {}{s}".format(nb, nom_complet, s=s)
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
salle = personnage.salle
nom = self.a_interpreter
t_nom = supprimer_accents(nom).lower()
familiers = importeur.familier.familiers_de(personnage)
familiers = [f for f in familiers if f.pnj]
if self.salle_identique:
familiers = [f for f in familiers if f.pnj.salle is salle]
familier = None
for t_familier in familiers:
if supprimer_accents(t_familier.nom).lower() == t_nom:
familier = t_familier
break
if not self.nouveau and familier is None:
raise ErreurValidation(
"|err|Le familier {} ne peut être trouvé.|ff|".format(nom))
elif self.nouveau and familier:
raise ErreurValidation(
"|err|Le familier {} existe déjà.|ff|".format(nom))
self.nom_familier = nom
self.familier = familier
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
prompt = self.a_interpreter
self.prompt = prompt
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
id_conversation = self.a_interpreter
conversations = type(self).importeur.communication.conversations
p_conversations = conversations.get_conversations_pour(personnage)
cible = None
if id_conversation == "-":
self.perte_focus = True
return True
try:
id_conversation = int(id_conversation)
except ValueError:
return False
for conversation in p_conversations:
if conversation.id == id_conversation:
cible = conversation.cible
break
if cible is None:
raise ErreurValidation(
"|err|Le numéro spécifié ne correspond à aucun personnage.|ff|")
else:
self.id_conversation = id_conversation
self.cible = cible
return True
def __init__(self, francais, anglais):
"""Constructeur du mot-clé"""
Masque.__init__(self)
self.francais = francais
self.anglais = anglais
self.nom = francais
self.gauche = False
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom_type = self.a_interpreter
self.nom_type = nom_type
return True
def __init__(self, francais, anglais):
"""Constructeur du mot-clé"""
Masque.__init__(self)
self.francais = francais
self.anglais = anglais
self.nom = francais
self.gauche = False
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
chemin_commande = self.a_interpreter
trans_param = True # doit-on transmettre les sous-commandes ?
if chemin_commande.endswith("."):
chemin_commande = chemin_commande[:-1]
trans_param = False
# On cherche dans les chemins des commandes, dans interpreteur.groupes
chemins = type(self).importeur.interpreteur.groupes.commandes.keys()
commandes = []
for chemin in chemins:
if chemin == chemin_commande:
commandes.append(chemin)
elif trans_param and chemin.startswith(chemin_commande + SEP):
commandes.append(chemin)
if not commandes:
raise ErreurValidation(
"|err|Aucune commande correspondant au chemin n'a pu être " \
"trouvée.|ff|")
self.chemins = commandes
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom_flag = self.a_interpreter
for flag in self.liste_flags:
if contient(flag, nom_flag):
self.flag = flag
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom_flag = self.a_interpreter
for flag in self.liste_flags:
if contient(flag, nom_flag):
self.flag = flag
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
stat_ent = supprimer_accents(self.a_interpreter).lower()
if not stat_ent in importeur.perso.cfg_stats.entrainables:
raise ErreurValidation( \
"Stat inconnue.")
self.stat_ent = stat_ent
def __init__(self):
"""Constructeur du masque"""
Masque.__init__(self)
self.proprietes["conteneurs"] = "(personnage.salle.objets_sol, )"
self.proprietes["types"] = "None"
self.proprietes["tout_interpreter"] = "True"
self.proprietes["quantite"] = "False"
self.proprietes["conteneur"] = "False"
self.proprietes["heterogene"] = "False"
def __init__(self):
"""Constructeur du masque"""
Masque.__init__(self)
self.proprietes["conteneurs"] = "(personnage.salle.objets_sol, )"
self.proprietes["types"] = "None"
self.proprietes["tout_interpreter"] = "True"
self.proprietes["quantite"] = "False"
self.proprietes["conteneur"] = "False"
self.proprietes["heterogene"] = "False"
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
stat_ent = supprimer_accents(self.a_interpreter).lower()
if not stat_ent in importeur.perso.cfg_stats.entrainables:
raise ErreurValidation( \
"Stat inconnue.")
self.stat_ent = stat_ent
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom_cherchable = self.a_interpreter
cherchables = importeur.recherche.cherchables
if nom_cherchable in cherchables:
self.cherchable = cherchables[nom_cherchable]
return True
else:
raise ErreurValidation("|err|Vous ne pouvez rechercher cela.|ff|")
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
ident = self.a_interpreter
if not ident in type(self).importeur.pnj.prototypes:
raise ErreurValidation("|err|Ce prototype est introuvable.|ff|")
self.prototype = type(self).importeur.pnj.prototypes[ident]
self.ident = ident
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
ident = self.a_interpreter
if not re.search(RE_IDENT_VALIDE, ident):
raise ErreurValidation(
"|err|Cette clé identifiante est invalide.|ff|")
self.ident = ident
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom_groupe = self.a_interpreter
noms_groupes = [groupe.nom for groupe in \
type(self).importeur.interpreteur.groupes._groupes.values()]
if nom_groupe not in noms_groupes:
raise ErreurValidation("|err|Ce groupe est inconnu.|ff|")
self.nom_groupe = nom_groupe.lower()
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
cle = self.a_interpreter
attitudes = type(self).importeur.communication.attitudes
if cle not in attitudes:
raise ErreurValidation( \
"|err|Cette attitude n'existe pas.|ff|")
self.attitude = attitudes[cle]
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
ident = self.a_interpreter
if not re.search(RE_IDENT_VALIDE, ident):
raise ErreurValidation(
"|err|Cette clé identifiante est invalide.|ff|")
self.ident = ident
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
cle = self.a_interpreter
attitudes = type(self).importeur.communication.attitudes
if cle not in attitudes:
raise ErreurValidation( \
"|err|Cette attitude n'existe pas.|ff|")
self.attitude = attitudes[cle]
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom_cherchable = self.a_interpreter
cherchables = importeur.recherche.cherchables
if nom_cherchable in cherchables:
self.cherchable = cherchables[nom_cherchable]
return True
else:
raise ErreurValidation(
"|err|Vous ne pouvez rechercher cela.|ff|")
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom_canal = self.a_interpreter
canaux = type(self).importeur.communication.canaux
if not nom_canal in canaux:
self.canal_existe = False
return True
self.nom_canal = nom_canal
self.canal = canaux[nom_canal]
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
niveau_secondaire = self.a_interpreter
try:
niveau = importeur.perso.get_niveau_par_nom(niveau_secondaire)
except ValueError:
raise ErreurValidation( \
"Niveau secondaire inconnue.")
self.niveau_secondaire = niveau_secondaire
self.cle_niveau = niveau.cle
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
ident = self.a_interpreter
if not ident in type(self).importeur.objet.prototypes:
raise ErreurValidation(
"|err|Ce prototype est introuvable.|ff|")
self.prototype = type(self).importeur.objet.prototypes[ident]
self.ident = ident
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom_groupe = self.a_interpreter
noms_groupes = [groupe.nom for groupe in \
type(self).importeur.interpreteur.groupes._groupes.values()]
if nom_groupe not in noms_groupes:
raise ErreurValidation(
"|err|Ce groupe est inconnu.|ff|")
self.nom_groupe = nom_groupe.lower()
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
langue = self.a_interpreter
if not langue in LANGUES:
raise ErreurValidation(
"|err|La langue précisée n'est pas disponible.|ff|")
self.langue = langue
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
niveau_secondaire = self.a_interpreter
try:
niveau = importeur.perso.get_niveau_par_nom(niveau_secondaire)
except ValueError:
raise ErreurValidation( \
"Niveau secondaire inconnue.")
self.niveau_secondaire = niveau_secondaire
self.cle_niveau = niveau.cle
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom_canal = self.a_interpreter
canaux = type(self).importeur.communication.canaux
if not nom_canal in canaux:
self.canal_existe = False
return True
self.nom_canal = nom_canal
self.canal = canaux[nom_canal]
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom = self.a_interpreter
nom_sa = supprimer_accents(nom)
for cmd in importeur.scripting.commandes_dynamiques.values():
t_nom = str(cmd)
if supprimer_accents(t_nom) == nom_sa:
self.commande = cmd
return True
raise ErreurValidation(
"|err|La commande dynamique '{}' n'existe pas.|ff|".format(nom))
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom = self.a_interpreter
salle = personnage.salle
try:
nom = salle.sorties.get_nom_long(nom)
except KeyError:
raise ErreurValidation(
"|err|La direction '{}' n'existe pas.|ff|".format(nom))
self.direction = nom
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
str_nombre = self.a_interpreter
try:
nombre = int(str_nombre)
assert nombre >= 1
except (ValueError, AssertionError):
raise ErreurValidation( \
"|err|Cet id est invalide.|ff|")
self.id_mail = nombre
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
str_nombre = self.a_interpreter
try:
nombre = int(str_nombre)
assert nombre >= 1
except (ValueError, AssertionError):
raise ErreurValidation( \
"|err|Cet id est invalide.|ff|")
self.id_mail = nombre
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom = self.a_interpreter
salle = personnage.salle
try:
nom = salle.sorties.get_nom_long(nom)
except KeyError:
raise ErreurValidation(
"|err|La direction '{}' n'existe pas.|ff|".format(nom))
self.direction = nom
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom_personnage = self.a_interpreter
for p in personnage.salle.personnages:
if p is not personnage and personnage.peut_voir(p) and \
contient(p.get_nom_pour(personnage), nom_personnage):
self.personnage = p
break
if self.personnage is None:
raise ErreurValidation(
"|err|Ce personnage est introuvable.|ff|".format(nom_personnage))
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom_pnj = self.a_interpreter
for p in personnage.salle.personnages:
if p is not personnage and hasattr(p, "prototype") \
and contient(p.get_nom_pour(personnage), nom_pnj):
self.pnj = p
break
if self.pnj is None:
raise ErreurValidation(
"|err|Ce PNJ est introuvable.|ff|")
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
ident = self.a_interpreter
try:
modele = type(self).importeur.navigation.modeles[ident]
except KeyError:
raise ErreurValidation(
"|err|L'identifiant '{}' n'est pas valide.|ff|".format(ident))
self.modele = modele
self.ident = modele.cle
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom = self.a_interpreter
salle = personnage.salle
try:
sortie = salle.sorties.get_sortie_par_nom(nom, abrege=True)
except KeyError:
raise ErreurValidation(
"|err|Le nom de sortie '{}' n'existe pas.|ff|".format(nom))
self.nom_sortie = nom
self.sortie = sortie
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom_personnage = self.a_interpreter
for p in personnage.salle.personnages:
if p is not personnage and personnage.peut_voir(p) and \
contient(p.get_nom_pour(personnage), nom_personnage):
self.personnage = p
break
if self.personnage is None:
raise ErreurValidation(
"|err|Ce personnage est introuvable.|ff|".format(nom_personnage))
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
encodage = self.a_interpreter
encodages = ["aucun"] + ENCODAGES
msg_enc = "\n\nEncodages disponibles : |ent|" + "|ff|, |ent|".join(
encodages) + "."
if not encodage in encodages:
raise ErreurValidation(
"|err|L'encodage précisé n'est pas disponible.|ff|" + msg_enc)
self.encodage = encodage
return True
