def creer_structure(groupe):
"""Crée une structure du groupe indiqué.
Paramètres à entrer :
* groupe : le nom du groupe de la structure
Toutes les structures sont identiques au début : elles sont
toutes créées absolument vides. Vous pouvez mettre les cases
que vous souhaitez dedans, ou bien les transmettre à un
éditeur pour les remplir manuellement. Le groupe détermine
comment les structures seront groupées. Le groupe et l'ID
forme une combinaison unique représentant chaque structure.
Exemple d'utilisation :
# Crée une structure dans le groupe 'journal'
journal1 = creer-structure("journal")
id1 = recuperer(journal1, "id")
# 'id1' vaut 1
journal2 = creer-structure("journal")
id2 = recuperer(journal2, "id")
# 'id2' vaut 2
# Crée une structure vide de groupe 'poeme'
poeme = creer-structure("poeme")
id3 = recuperer(poeme, "id")
# 'id3' vaut 1
"""
valider_cle(groupe)
return importeur.scripting.creer_structure(groupe)
def interpreter(self, msg):
"""Interprétation du contexte"""
msg = msg.strip()
try:
msg = self.type(msg)
except ValueError:
self.pere << "|err|Cette valeur est invalide.|ff|"
else:
# Vérification
verification = self.verification
if verification & CLE:
try:
valider_cle(msg)
except ValueError as err:
self.pere << "|err|" + str(err) + ".|ff|"
return
# Modification
modification = self.modification
if modification & CAPITALIZE:
msg = msg[0].upper() + msg[1:]
elif modification & LOWER:
msg = msg.lower()
setattr(self.objet, self.attribut, msg)
self.actualiser()
def recuperer_structure(structure, cle):
"""Récupère la valeur contenue dans la case de clé indiquée.
Paramètres à préciser :
* structure : la structure qui nous occupe ici
* cle : la clé de la case d'information à retrouver
Exemple d'utilisation :
# Sur une structure enregistrée dans un groupe, on pourrait faire :
id = recuperer(structure, "id")
# Pour récupérer son ID. Ou bien une autre case :
message = recuperer(structure, "message")
# Si la case de la clé indiquée n'existe pas, retourne
# une valeur nulle qu'on peut donc tester.
si message:
# ...
"""
valider_cle(cle)
objet = getattr(structure, cle, None)
if isinstance(objet, (int, float, bool)):
objet = Fraction(objet)
return objet
def creer_structure(groupe):
"""Crée une structure du groupe indiqué.
Paramètres à entrer :
* groupe : le nom du groupe de la structure
Toutes les structures sont identiques au début : elles sont
toutes créées absolument vides. Vous pouvez mettre les cases
que vous souhaitez dedans, ou bien les transmettre à un
éditeur pour les remplir manuellement. Le groupe détermine
comment les structures seront groupées. Le groupe et l'ID
forme une combinaison unique représentant chaque structure.
Exemple d'utilisation :
# Crée une structure dans le groupe 'journal'
journal1 = creer-structure("journal")
id1 = recuperer(journal1, "id")
# 'id1' vaut 1
journal2 = creer-structure("journal")
id2 = recuperer(journal2, "id")
# 'id2' vaut 2
# Crée une structure vide de groupe 'poeme'
poeme = creer-structure("poeme")
id3 = recuperer(poeme, "id")
# 'id3' vaut 1
"""
valider_cle(groupe)
return importeur.scripting.creer_structure(groupe)
def __init__(self, cle=""):
"""Constructeur du prototype."""
BaseObj.__init__(self)
self.n_id = 1
if cle:
valider_cle(cle)
self.cle = cle
self.cycles = []
self.plantes = []
def __init__(self, cle=""):
"""Constructeur du prototype."""
BaseObj.__init__(self)
self.n_id = 1
if cle:
valider_cle(cle)
self.cle = cle
self.cycles = []
self.plantes = []
def ajouter_rang(self, cle):
"""Ajoute le rang indiqué."""
valider_cle(cle)
if self.get_rang(cle, exception=False):
raise ValueError("Le rang de clé {} existe déjà".format(repr(cle)))
rang = Rang(self, cle)
self.rangs.append(rang)
return rang
def __init__(self, niveaux, cle, nom, niveau, difficulte,
liberer_points=True):
"""Constructeur du talent."""
valider_cle(cle)
self.cle = cle
self.nom = nom
self.cle_niveau = niveau
self.niveau = niveaux[niveau]
self.difficulte = difficulte
self.liberer_points = liberer_points
def creer_guilde(self, cle):
"""Crée une guilde."""
valider_cle(cle)
if cle in self.guildes:
raise ValueError("la guilde {} existe déjà".format(repr(cle)))
guilde = Guilde(cle)
self.ajouter_guilde(guilde)
return guilde
def ajouter_rang(self, cle):
"""Ajoute le rang indiqué."""
valider_cle(cle)
if self.get_rang(cle, exception=False):
raise ValueError("Le rang de clé {} existe déjà".format(
repr(cle)))
rang = Rang(self, cle)
self.rangs.append(rang)
return rang
def creer_prototype_objet(prototype, type):
"""Crée un prototype d'objet du type précisé.
Cette fonction permet de créer un prototype d'objet du type
indiqué. Le prototype d'objet est retourné et peut être
manipulé pour d'avantage de configuration (voire les exemples
ci-dessous). La clé précisée est utilisée telle quelle. Si
un prototype d'objet de cette clé existe déjà, cependant, le
système va essayer de créer la clé ${cle}_2, ${cle}_3 et ainsi
de suite, jusqu'à en trouver une libre.
Si la clé de prototype précisée finit par "_X", (le signe
souligné suivi de la lettre X), le système cherchera le prototype
correspondant en remplaçant X par un nombre (ce qui est souvent
un comportement plus logique quand on veut créer des
prototypes en série).
Paramètres à préciser :
* prototype : la clé du prototype à créer (une chaîne de caractères) ;
* type : le nom du type (une chaîne de caractères).
Exemples d'utilisation :
prototype = creer_prototype_objet("pomme_rouge", "fruit")
# Si un prototype d'objet de la clé 'pomme_rouge' existe
# déjà, le système créra le prototype 'pomme_rouge_2'
journal = creer_prototype_objet("journal_X", "livre")
# Le système cherchera à créer le prototype d'objet 'journal_1'.
# Si la clé existe, alors 'journal_2', 'journal_3' et ainsi
# de suite.
changer_nom journal "un journal" "journaux"
changer_etat journal "est posé là" "sont posés là"
changer_description journal "C'est un journal."
changer_poids journal 0.2
changer_prix journal 50
ajouter_chapitre journal "Chapitre 1" "C'est le chapitre 1."
...
"""
type = importeur.objet.get_type(type).nom_type
cles = tuple(importeur.objet.prototypes.keys())
prototype = prototype.lower()
nb = 1
cle = prototype
if prototype.endswith("_x"):
prototype = prototype[:-2]
cle = prototype + "_1"
valider_cle(prototype)
while cle in cles:
nb += 1
cle = "{}_{}".format(prototype, nb)
return importeur.objet.creer_prototype(cle, type)
def creer_prototype_objet(prototype, type):
"""Crée un prototype d'objet du type précisé.
Cette fonction permet de créer un prototype d'objet du type
indiqué. Le prototype d'objet est retourné et peut être
manipulé pour d'avantage de configuration (voire les exemples
ci-dessous). La clé précisée est utilisée telle quelle. Si
un prototype d'objet de cette clé existe déjà, cependant, le
système va essayer de créer la clé ${cle}_2, ${cle}_3 et ainsi
de suite, jusqu'à en trouver une libre.
Si la clé de prototype précisée finit par "_X", (le signe
souligné suivi de la lettre X), le système cherchera le prototype
correspondant en remplaçant X par un nombre (ce qui est souvent
un comportement plus logique quand on veut créer des
prototypes en série).
Paramètres à préciser :
* prototype : la clé du prototype à créer (une chaîne de caractères) ;
* type : le nom du type (une chaîne de caractères).
Exemples d'utilisation :
prototype = creer_prototype_objet("pomme_rouge", "fruit")
# Si un prototype d'objet de la clé 'pomme_rouge' existe
# déjà, le système créra le prototype 'pomme_rouge_2'
journal = creer_prototype_objet("journal_X", "livre")
# Le système cherchera à créer le prototype d'objet 'journal_1'.
# Si la clé existe, alors 'journal_2', 'journal_3' et ainsi
# de suite.
changer_nom journal "un journal" "journaux"
changer_etat journal "est posé là" "sont posés là"
changer_description journal "C'est un journal."
changer_poids journal 0.2
changer_prix journal 50
ajouter_chapitre journal "Chapitre 1" "C'est le chapitre 1."
...
"""
type = importeur.objet.get_type(type).nom_type
cles = tuple(importeur.objet.prototypes.keys())
prototype = prototype.lower()
nb = 1
cle = prototype
if prototype.endswith("_x"):
prototype = prototype[:-2]
cle = prototype + "_1"
valider_cle(prototype)
while cle in cles:
nb += 1
cle = "{}_{}".format(prototype, nb)
return importeur.objet.creer_prototype(cle, type)
def creer_guilde(self, cle):
"""Crée une guilde."""
valider_cle(cle)
if cle in self.guildes:
raise ValueError("la guilde {} existe déjà".format(
repr(cle)))
guilde = Guilde(cle)
self.ajouter_guilde(guilde)
return guilde
def __init__(self, cle=""):
"""Constructeur d'un type"""
if cle:
valider_cle(cle)
BaseObj.__init__(self)
self.cle = cle
self._attributs = {}
self.nom = "un élément inconnu"
self.description = Description(parent=self)
# Editeur
self._extensions_editeur = []
def __init__(self, cle=""):
"""Constructeur d'un type"""
if cle:
valider_cle(cle)
BaseObj.__init__(self)
self.cle = cle
self._attributs = {}
self.nom = "un élément inconnu"
self.description = Description(parent=self)
# Editeur
self._extensions_editeur = []
def __init__(self,
niveaux,
cle,
nom,
niveau,
difficulte,
liberer_points=True):
"""Constructeur du talent."""
valider_cle(cle)
self.cle = cle
self.nom = nom
self.cle_niveau = niveau
self.niveau = niveaux[niveau]
self.difficulte = difficulte
self.liberer_points = liberer_points
def creer_tag(self, cle, type):
"""Crée un nouveau tag."""
valider_cle(cle)
if type not in self.types:
raise ValueError("le type de tag {} n'existe pas".format(
repr(type)))
if cle in self.tags:
raise ValueError("le tag {} existe déjà".format(
repr(cle)))
tag = Tag(cle, type)
self.ajouter_tag(tag)
return tag
def creer_banc(self, cle):
"""Crée un banc de poisson et l'ajoute dans le dictionnaire.
Retourne le banc créé.
Lève une exception KeyError si le banc existe déjà.
"""
valider_cle(cle)
if cle in self.bancs:
raise KeyError("le banc de poisson '{}' existe déjà".format(cle))
banc = Banc(cle)
self.ajouter_banc(banc)
return banc
def creer_modele(self, cle):
"""Crée un modèle de navire et l'ajoute dans le dictionnaire.
Retourne le modèle créé.
Lève une exception KeyError si le modèle existe déjà.
"""
valider_cle(cle)
if cle in self.modeles:
raise KeyError("le modèle de navire {} existe déjà".format(cle))
modele = ModeleNavire(cle)
self.ajouter_modele(modele)
return modele
def creer_modele(self, cle):
"""Crée un modèle de navire et l'ajoute dans le dictionnaire.
Retourne le modèle créé.
Lève une exception KeyError si le modèle existe déjà.
"""
valider_cle(cle)
if cle in self.modeles:
raise KeyError("le modèle de navire {} existe déjà".format(cle))
modele = ModeleNavire(cle)
self.ajouter_modele(modele)
return modele
def ajouter_talent(self, cle, nom="un talent inconnu",
ouvert_a_tous=False):
"""Ajoute un talent à la guilde."""
valider_cle(cle)
if cle in importeur.perso.talents:
raise ValueError("la clé de talent {} est déjà utilisée".format(
repr(cle)))
if cle in self.talents:
raise ValueError("la clé de talent {} existe déjà dans " \
"cette guilde".format(repr(cle)))
talent = Talent(self, cle)
talent.nom = nom
talent.ouvert_a_tous = ouvert_a_tous
self.talents[cle] = talent
return talent
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
cle = self.a_interpreter
if self.regex:
res = re.search(self.regex, cle)
if res is None:
raise ErreurValidation(
"|err|Cette clé identifiante est invalide.|ff|")
else:
try:
valider_cle(cle)
except ValueError:
raise ErreurValidation(
"|err|Cette clé identifiante est invalide.|ff|")
self.cle = cle
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
cle = self.a_interpreter
if self.regex:
res = re.search(self.regex, cle)
if res is None:
raise ErreurValidation(
"|err|Cette clé identifiante est invalide.|ff|")
else:
try:
valider_cle(cle)
except ValueError:
raise ErreurValidation(
"|err|Cette clé identifiante est invalide.|ff|")
self.cle = cle
return True
def ajouter_talent(self,
cle,
nom="un talent inconnu",
ouvert_a_tous=False):
"""Ajoute un talent à la guilde."""
valider_cle(cle)
if cle in importeur.perso.talents:
raise ValueError("la clé de talent {} est déjà utilisée".format(
repr(cle)))
if cle in self.talents:
raise ValueError("la clé de talent {} existe déjà dans " \
"cette guilde".format(repr(cle)))
talent = Talent(self, cle)
talent.nom = nom
talent.ouvert_a_tous = ouvert_a_tous
self.talents[cle] = talent
return talent
def __init__(self, cle):
if cle:
valider_cle(cle)
BaseObj.__init__(self)
self.tick_actif = True
self.resume = "non spécifié"
self.visible = True
self.cle = cle
self.force_max = 50
self.duree_max = -1
self.infinie = False
self.variation = -1
self.duree_tick = 60 # durée du tick en secondes
self.flags = 0
# Liste de tuple (force, message)
self.messages_visibles = []
self._construire()
def ecrire(structure, cle, valeur):
"""Écrit l'information dans la structure indiquée.
Paramètres à préciser :
* structure : la structure à modifier
* cle : la clé de la case à modifier
* valeur : la valeur de la case à écrire (tous types acceptés)
Exemple d'utilisation :
ecrire structure "nom" "Quelque chose"
ecrire structure "numero" 5
ecrire structure "elements" liste(1, 2, 3, 8)
ecrire structure "coupable" joueur("Kredh")
**ATTENTION** : la clé de case doit être une clé (sans
majuscules ni accents, ne comprenant que des lettres et
des chiffres, ainsi que le signe souligné _, si il n'est
pas en début de mot). Les noms suivants sont par ailleurs interdits :
"e_existe", "get_nom_pour", "id", "structure"
"""
valider_cle(cle)
if cle.startswith("_"):
raise ErreurExecution("la clé précisée {} commence par " \
"un signe souligné".format(repr(cle)))
interdits = ("e_existe", "get_nom_pour", "id", "structure")
if cle in interdits:
raise ErreurExecution("Ce nom de clé est interdit. Clés " \
"interdites : {}.".format(repr(interdits)))
setattr(structure, cle, valeur)
def interpreter(self, msg):
"""Interprétation du contexte"""
msg = msg.strip()
try:
msg = self.type(msg)
except ValueError:
self.pere << "|err|Cette valeur est invalide.|ff|"
else:
# Vérification
verification = self.verification
if verification & CLE:
try:
valider_cle(msg)
except ValueError as err:
self.pere << "|err|" + str(err) + ".|ff|"
return
# Modification
modification = self.modification
if modification & CAPITALIZE:
msg = msg.capitalize()
setattr(self.objet, self.attribut, msg)
self.actualiser()
def interpreter(self, msg):
"""Interprétation du contexte"""
objet = getattr(self.objet, self.attribut)
if objet is None:
objet = self.nouveau
setattr(self.objet, self.attribut, objet)
msgs = msg.split(" / ")
colonnes = self.colonnes
if len(msgs) != len(colonnes):
self.pere << "|err|Le nombre d'informations précisées " \
"est invalide.\n{} colonnes attendues contre " \
"{} renseignées.|ff|".format(len(colonnes), len(msgs))
return
# On transforme maintenant chaque colonnes
i = 0
for nom, n_type in self.colonnes:
valeur = msgs[i]
valeur_sa = supprimer_accents(valeur).lower()
if isinstance(n_type, str):
if n_type == "chaîne":
pass
elif n_type == "clé":
try:
valider_cle(valeur)
except ValueError:
self.pere << "|err|Colonne {} : {} n'est " \
"pas ue clé valide.".format(i + 1, valeur)
return
elif n_type == "entier":
try:
valeur = int(valeur)
except ValueError:
self.pere << "|err|Colonne {} : {} n'est " \
"pas un nombre.".format(i + 1, valeur)
return
else:
msgs[i] = valeur
elif n_type == "flottant":
try:
valeur = float(valeur.replace(",", "."))
except ValueError:
self.pere << "|err|Colonne {} : {} n'est " \
"pas un flottant.".format(i + 1, valeur)
return
else:
msgs[i] = valeur
else:
raise ValueError("Type inconnu {}".format(n_type))
elif isinstance(n_type, list):
liste = [supprimer_accents(c).lower() for c in n_type]
if liste and valeur_sa not in liste:
self.pere << "|err|Colonne {} : valeur {} " \
"invalide.|ff|".format(i + 1, valeur)
return
else:
msgs[i] = n_type[liste.index(valeur_sa)]
elif isinstance(n_type, dict):
cles = list(n_type.keys())
liste = [supprimer_accents(c).lower() for c in cles]
if liste and valeur_sa not in liste:
self.pere << "|err|Colonne {} : valeur {} " \
"invalide.|ff|".format(i + 1, valeur)
return
else:
msgs[i] = n_type[cles[liste.index(valeur_sa)]]
else:
raise ValueError("Type inconnu : {}".format(type(n_type)))
i += 1
if isinstance(objet, dict):
cle = msgs[0]
args = msgs[1:]
if len(args) == 1:
args = args[0]
objet[cle] = args
else:
objet.append(msgs)
if self.callback:
methode = getattr(self.objet, self.callback)
methode()
self.actualiser()
def interpreter(self, msg):
"""Interprétation du contexte"""
objet = getattr(self.objet, self.attribut)
if objet is None:
objet = self.nouveau
setattr(self.objet, self.attribut, objet)
msgs = msg.split(" / ")
colonnes = self.colonnes
if len(msgs) != len(colonnes):
self.pere << "|err|Le nombre d'informations précisées " \
"est invalide.\n{} colonnes attendues contre " \
"{} renseignées.|ff|".format(len(colonnes), len(msgs))
return
# On transforme maintenant chaque colonnes
i = 0
for nom, n_type in self.colonnes:
valeur = msgs[i]
valeur_sa = supprimer_accents(valeur).lower()
if isinstance(n_type, str):
if n_type == "chaîne":
pass
elif n_type == "clé":
try:
valider_cle(valeur)
except ValueError:
self.pere << "|err|Colonne {} : {} n'est " \
"pas ue clé valide.".format(i + 1, valeur)
return
elif n_type == "entier":
try:
valeur = int(valeur)
except ValueError:
self.pere << "|err|Colonne {} : {} n'est " \
"pas un nombre.".format(i + 1, valeur)
return
else:
msgs[i] = valeur
elif n_type == "flottant":
try:
valeur = float(valeur.replace(",", "."))
except ValueError:
self.pere << "|err|Colonne {} : {} n'est " \
"pas un flottant.".format(i + 1, valeur)
return
else:
msgs[i] = valeur
else:
raise ValueError("Type inconnu {}".format(n_type))
elif isinstance(n_type, list):
liste = [supprimer_accents(c).lower() for c in n_type]
if liste and valeur_sa not in liste:
self.pere << "|err|Colonne {} : valeur {} " \
"invalide.|ff|".format(i + 1, valeur)
return
else:
msgs[i] = n_type[liste.index(valeur_sa)]
elif isinstance(n_type, dict):
cles = list(n_type.keys())
liste = [supprimer_accents(c).lower() for c in cles]
if liste and valeur_sa not in liste:
self.pere << "|err|Colonne {} : valeur {} " \
"invalide.|ff|".format(i + 1, valeur)
return
else:
msgs[i] = n_type[cles[liste.index(valeur_sa)]]
else:
raise ValueError("Type inconnu : {}".format(type(n_type)))
i += 1
if isinstance(objet, dict):
cle = msgs[0]
args = msgs[1:]
if len(args) == 1:
args = args[0]
objet[cle] = args
else:
objet.append(msgs)
if self.callback:
methode = getattr(self.objet, self.callback)
methode()
self.actualiser()
def __init__(self, cle, etat_m, etat_f):
"""Constructeur du talent."""
valider_cle(cle)
self.cle = cle
self.etat_m = etat_m
self.etat_f = etat_f
def __init__(self, cle, etat_m, etat_f):
"""Constructeur du talent."""
valider_cle(cle)
self.cle = cle
self.etat_m = etat_m
self.etat_f = etat_f
def __init__(self, cle, nom):
"""Constructeur du niveau."""
valider_cle(cle)
self.cle = cle
self.nom = nom
def opt_ajouter(self, arguments):
"""Ajout d'un élément.
Syntaxe :
/a <paramètres>
"""
valeur = getattr(self.objet, self.attribut)
objet = self.callback or self.objet
colonnes = self.colonnes
ajout = self.ajout
arguments = arguments.strip().split(" / ")
if len(arguments) != len(colonnes):
self.pere << "|err|Nombre invalide d'arguments : {} " \
"attendus contre {} reçus.\nSyntaxe : |ent|".format(
len(colonnes), len(arguments)) + " / ".join(
[c[0] for c in colonnes]) + "|ff|"
return
for i, arg in enumerate(list(arguments)):
colonne = colonnes[i]
n_type = colonne[1]
if n_type == "chaîne":
pass
elif n_type == "entier":
try:
arg = int(arg)
except ValueError:
self.pere << "|err|Colonne {} ({}) : nombre entier {} " \
"invalide.|ff|".format(i + 1, colonne[0], arg)
return
else:
arguments[i] = arg
elif n_type == "flottant":
try:
arg = float(arg.replace(",", "."))
except ValueError:
self.pere << "|err|Colonne {} ({}) : nombre flottant {} " \
"invalide.|ff|".format(i + 1, colonne[0], arg)
return
else:
arguments[i] = arg
elif n_type == "clé":
try:
valider_cle(arg)
except ValueError:
self.pere << "|err|Colonne {} ({}) : clé invalide " \
"{}|ff|".format(i + 1, colonne[0], repr(arg))
return
else:
arguments[i] = arg
else:
raise ValueError("colonne {} : type inconnu ({})".format(
i + 1, repr(n_type)))
# On essaye d'ajouter l'élément
methode = getattr(objet, ajout)
try:
if self.callback:
methode(self.objet, valeur, *arguments)
else:
methode(*arguments)
except Exception as err:
self.pere << "|err|" + str(err) + ".|ff|"
return
self.actualiser()
def opt_ajouter(self, arguments):
"""Ajout d'un élément.
Syntaxe :
/a <paramètres>
"""
valeur = getattr(self.objet, self.attribut)
objet = self.callback or self.objet
colonnes = self.colonnes
ajout = self.ajout
arguments = arguments.strip().split(" / ")
if len(arguments) != len(colonnes):
self.pere << "|err|Nombre invalide d'arguments : {} " \
"attendus contre {} reçus.\nSyntaxe : |ent|".format(
len(colonnes), len(arguments)) + " / ".join(
[c[0] for c in colonnes]) + "|ff|"
return
for i, arg in enumerate(list(arguments)):
colonne = colonnes[i]
n_type = colonne[1]
if n_type == "chaîne":
pass
elif n_type == "entier":
try:
arg = int(arg)
except ValueError:
self.pere << "|err|Colonne {} ({}) : nombre entier {} " \
"invalide.|ff|".format(i + 1, colonne[0], arg)
return
else:
arguments[i] = arg
elif n_type == "flottant":
try:
arg = float(arg.replace(",", "."))
except ValueError:
self.pere << "|err|Colonne {} ({}) : nombre flottant {} " \
"invalide.|ff|".format(i + 1, colonne[0], arg)
return
else:
arguments[i] = arg
elif n_type == "clé":
try:
valider_cle(arg)
except ValueError:
self.pere << "|err|Colonne {} ({}) : clé invalide " \
"{}|ff|".format(i + 1, colonne[0], repr(arg))
return
else:
arguments[i] = arg
else:
raise ValueError("colonne {} : type inconnu ({})".format(
i + 1, repr(n_type)))
# On essaye d'ajouter l'élément
methode = getattr(objet, ajout)
try:
if self.callback:
methode(self.objet, valeur, *arguments)
else:
methode(*arguments)
except Exception as err:
self.pere << "|err|" + str(err) + ".|ff|"
return
self.actualiser()
