From 2cd5ce1bbe86b4515bda482202b4d10a31d8039f Mon Sep 17 00:00:00 2001 From: "pascale.noyret" Date: Thu, 9 Feb 2017 18:01:12 +0100 Subject: [PATCH] print et except --- Extensions/commande_comm.py | 4 +- Extensions/interpreteur_formule.py | 224 +++++++++++++++-------------- Extensions/localisation.py | 8 +- Extensions/parametre.py | 76 +++++----- Extensions/parametre_eval.py | 80 +++++------ Extensions/translationQT5.py | 3 +- 6 files changed, 200 insertions(+), 195 deletions(-) diff --git a/Extensions/commande_comm.py b/Extensions/commande_comm.py index 42b2c754..ec974970 100644 --- a/Extensions/commande_comm.py +++ b/Extensions/commande_comm.py @@ -188,14 +188,14 @@ class COMMANDE_COMM(N_OBJECT.OBJECT,I_OBJECT.OBJECT) : context_ini = context_ini, ) J.analyse() - except Exception,e: + except Exception as e: traceback.print_exc() #self.jdc.set_context() raise AsException(tr("Erreur"),e.__str__()) if len(J.cr.crfatal)>0 : # des erreurs fatales ont été rencontrées #self.jdc.set_context() - print 'erreurs fatales !!!' + print ('erreurs fatales !!!') raise AsException(tr("Erreurs fatales"),string.join(J.cr.crfatal)) if not J.etapes : # des erreurs ont été rencontrées diff --git a/Extensions/interpreteur_formule.py b/Extensions/interpreteur_formule.py index a62c543b..f6c64f20 100644 --- a/Extensions/interpreteur_formule.py +++ b/Extensions/interpreteur_formule.py @@ -17,21 +17,24 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # -import string,re,sys,exceptions,types +import string,re,sys,types from Noyau.N_CR import CR from Extensions.i18n import tr -def group(*choices): return '(' + string.join(choices, '|') + ')' -def any(*choices): return apply(group, choices) + '*' -def maybe(*choices): return apply(group, choices) + '?' +#def group(*choices): return '(' + string.join(choices, '|') + ')' +#def any(*choices): return apply(group, choices) + '*' +#def maybe(*choices): return apply(group, choices) + '?' Intnumber = r'[1-9]\d*' Exponent = r'[eEdD][-+]?\d+' -Pointfloat = group(r'\d+\.\d*', r'\.\d+') + maybe(Exponent) Expfloat = r'[1-9]\d*' + Exponent -Floatnumber = group(Pointfloat, Expfloat) +#Pointfloat = group(r'\d+\.\d*', r'\.\d+') + maybe(Exponent) +#Floatnumber = group(Pointfloat, Expfloat) +Pointfloat=r'(\d+\.\d*|\.\d+)([eEdD][-+]?\d+)?' +Floatnumber=r'((\d+\.\d*|\.\d+)([eEdD][-+]?\d+)?|[1-9]\d*[eEdD][-+]?\d+)' + pat_number = re.compile(r'^([+-]?)([0-9]+)(\.\d*)?(.*)') pat_number_complet = re.compile(r'^([+-]?)([0-9]+)(\.\d*)?([eEdD][+-]?\d+)(.*)') @@ -50,19 +53,19 @@ def cmp_function(arg1,arg2): else: return 1 -class InterpreteurException(exceptions.Exception): +class InterpreteurException(Exception): """ - Classe servant à définir les exceptions levées par l'interpréteur de formule + Classe servant a definir les exceptions levees par l'interpreteur de formule """ def __init__(self,args=None): self.args = args def __str__(self): - return self.args + return str(self.args) class Interpreteur_Formule: """ - Cette classe sert à construire un interpréteur de formules Aster + Cette classe sert a construire un interpreteur de formules Aster """ l_fonctions_binaires = ['+','-','*','/','**','=','MOD','MIN','MAX','ATAN2'] l_fonctions_unaires = ['+','-','INT','REAL','AIMAG','ABS','SQRT','EXP','LOG', @@ -72,7 +75,7 @@ class Interpreteur_Formule: def __init__(self,formule=None,constantes=[],fonctions=[],parent=None): """ - Constructeur d'interpréteurs de formule Aster + Constructeur d'interpreteurs de formule Aster - formule = tuple (nom,type,arguments,corps) - constantes = liste des noms de constantes externes - fonctions_unaires = dictionnaire {nom_fonction externe : nb arguments de cette fonction} @@ -91,18 +94,19 @@ class Interpreteur_Formule: def set_formule(self,formule): """ Stocke formule (tuple) dans l'attribut t_formule - Méthode externe + Methode externe """ - if type(formule) != types.TupleType: - raise InterpreteurException,tr("La formule passee a l'interpreteur doit etre sous forme de tuple") + #if type(formule) != types.TupleType: + if type(formule) != types.tuple: + raise InterpreteurException(tr("La formule passee a l'interpreteur doit etre sous forme de tuple")) self.t_formule = formule - self.init_cr() + #self.init_cr() self.modify_listes() self.ordonne_listes() def init_cr(self): """ - Initialise le cr,cad valorise les chaînes debut et fin + Initialise le cr,cad valorise les chaines debut et fin """ nom = self.t_formule[0] if nom : @@ -112,12 +116,12 @@ class Interpreteur_Formule: def str(self): """ - Retourne une liste de chaînes de caractères représentant la formule + Retourne une liste de chaines de caracteres representant la formule """ l_txt = [] l_txt.append(self.t_formule[0]) for oper in self.l_operateurs: - # oper est ici une liste décrivant oper + # oper est ici une liste decrivant oper txt = [] for elem in oper: txt.append(str(elem)) @@ -133,15 +137,15 @@ class Interpreteur_Formule: def enregistre(self,fils): """ - Enregistre un opérateur fils dans la liste des children + Enregistre un operateur fils dans la liste des children """ self.l_children.append(fils) self.cr.add(fils.cr) def isvalid(self): """ - Booléenne qui retourne 1 si la formule est valide, 0 sinon - Méthode externe + Booleenne qui retourne 1 si la formule est valide, 0 sinon + Methode externe """ self.l_operateurs = [] self.cr.purge() # on vide le cr @@ -151,7 +155,7 @@ class Interpreteur_Formule: def interprete_formule(self): """ - Réalise l'interprétation du corps de la formule + Realise l'interpretation du corps de la formule """ texte = self.t_formule[3] if not texte : return @@ -163,25 +167,25 @@ class Interpreteur_Formule: text_arg = string.replace(text_arg,' ','') try: self.l_operateurs.append(self.split_operateurs(text_arg)) - except InterpreteurException,e: + except InterpreteurException as e: self.cr.fatal(e.__str__()) def modify_listes(self): """ - Modifie la liste des constantes en lui ajoutant le nom des paramètres - de la fonction à interpréter + Modifie la liste des constantes en lui ajoutant le nom des parametres + de la fonction a interpreter """ args = self.t_formule[2] - # l'interpréteur de formule sert aussi à évaluer les EVAL + # l'interpreteur de formule sert aussi a evaluer les EVAL # dans ce cas il n'y a pas d'arguments puisque pas de fonction ... if args : - args = args[1:-1] # on enlève les parenthèses ouvrante et fermante + args = args[1:-1] # on enleve les parentheses ouvrante et fermante l_args = string.split(args,',') for arg in l_args: typ,nom = string.split(arg,':') nom = string.strip(nom) self.l_constantes.append(nom) - # on considère que les fonctions unaires de base sont toutes à un seul argument : + # on considere que les fonctions unaires de base sont toutes a un seul argument : l_f = [] self.d_fonctions_unaires = {} for fct in self.l_fonctions_unaires: @@ -206,60 +210,60 @@ class Interpreteur_Formule: def split_operateurs(self,texte): """ - Splite le texte passé en argument en opérateurs plus élémentaires. - N'analyse pas l'intérieur des opérateurs (ne fait qu'une passe) + Splite le texte passe en argument en operateurs plus elementaires. + N'analyse pas l'interieur des operateurs (ne fait qu'une passe) """ l_operateurs = [] texte = string.strip(texte) - # on recherche un nombre en début de texte + # on recherche un nombre en debut de texte try: oper,reste = self.cherche_nombre(texte) - except InterpreteurException,e: - raise InterpreteurException,e.__str__() + except InterpreteurException as e: + raise InterpreteurException (e.__str__()) if not oper : - # on recherche une constante en début de texte + # on recherche une constante en debut de texte try: oper,reste = self.cherche_constante(texte) - except InterpreteurException,e: - raise InterpreteurException,e.__str__() + except InterpreteurException as e: + raise InterpreteurException (e.__str__()) if not oper : - # on recherche une expression entre parenthèses... + # on recherche une expression entre parentheses... try: oper,reste = self.cherche_expression_entre_parentheses(texte) - except InterpreteurException,e: - raise InterpreteurException,e.__str__() + except InterpreteurException as e: + raise InterpreteurException(e.__str__()) if not oper : - # on recherche le début d'un opérateur unaire en début de texte + # on recherche le debut d'un operateur unaire en debut de texte try: oper,reste = self.cherche_operateur_unaire(texte) - except InterpreteurException,e: - raise InterpreteurException,e.__str__() + except InterpreteurException as e: + raise InterpreteurException(e.__str__()) if not oper : type_objet,nom_objet = self.get_type(texte) if type_objet == 'constante': - raise InterpreteurException, "Constante %s inconnue" %nom_objet + raise InterpreteurException( "Constante %s inconnue" %nom_objet) elif type_objet == 'fonction': - raise InterpreteurException, "Fonction %s inconnue dans %s" %(nom_objet,texte) + raise InterpreteurException( "Fonction %s inconnue dans %s" %(nom_objet,texte)) else: - raise InterpreteurException, "Impossible d'interpréter : %s" %texte - # on a trouvé un opérateur (nombre, constante ou unaire) - # il faut encore vérifier que l'on est en fin de texte ou qu'il est bien suivi - # d'un opérateur binaire + raise InterpreteurException( "Impossible d'interpreter : %s" %texte) + # on a trouve un operateur (nombre, constante ou unaire) + # il faut encore verifier que l'on est en fin de texte ou qu'il est bien suivi + # d'un operateur binaire l_operateurs.append(oper) if reste : texte = string.strip(reste) oper,reste = self.cherche_operateur_binaire(texte) if not oper : - # on a un reste et pas d'opérateur binaire --> erreur - raise InterpreteurException,"L'opérateur %s doit être suivi d'un opérateur binaire" %l_operateurs[-1] + # on a un reste et pas d'operateur binaire --> erreur + raise InterpreteurException("L'operateur %s doit etre suivi d'un operateur binaire" %l_operateurs[-1]) else: - # on a bien trouvé un opérateur binaire: + # on a bien trouve un operateur binaire: l_operateurs.append(oper) # il faut recommencer l'analyse du reste par split_operateurs ... try: l_op = self.split_operateurs(reste) - except InterpreteurException,e: - raise InterpreteurException,e.__str__() + except InterpreteurException as e: + raise InterpreteurException(e.__str__()) l_operateurs.extend(l_op) return l_operateurs else: @@ -268,14 +272,14 @@ class Interpreteur_Formule: def cherche_nombre(self,texte): """ - Cherche un nombre en début de texte + Cherche un nombre en debut de texte Retourne ce nombre et le reste ou None et le texte initial - Peut lever une InterpreteurException dans le cas où le nombre n'est pas valide + Peut lever une InterpreteurException dans le cas ou le nombre n'est pas valide """ texte = string.strip(texte) m = pat_number_complet.match(texte) if m: - # on a trouvé un nombre avec exposant + # on a trouve un nombre avec exposant l_groups = m.groups() sgn = l_groups[0] nb = l_groups[1] @@ -288,36 +292,36 @@ class Interpreteur_Formule: else: m = pat_number.match(texte) if m : - # on a trouvé un nombre sans exposant + # on a trouve un nombre sans exposant l_groups = m.groups() sgn = l_groups[0] nb = l_groups[1] if l_groups[2]: nb = nb+l_groups[2] nombre = sgn+nb - # il faut vérifier si ce nombre n'est pas suivi d'un exposant incomplet ... + # il faut verifier si ce nombre n'est pas suivi d'un exposant incomplet ... reste = string.strip(l_groups[3]) if reste == '': return nombre,l_groups[3] if reste[0] in ('e','E','d','D') : - raise InterpreteurException,"La syntaxe de l'exposant de %s est erronée " %nb + raise InterpreteurException("La syntaxe de l'exposant de %s est erronee " %nb) else: return nombre,l_groups[3] else: - # on n'a pas trouvé de nombre + # on n'a pas trouve de nombre return None,texte def cherche_constante_old(self,texte): """ - Recherche une constante en début de texte parmi la liste des constantes. - Retourne le texte représentant la constante et le reste du texte ou - Retourne None,texte si aucune constante trouvée + Recherche une constante en debut de texte parmi la liste des constantes. + Retourne le texte representant la constante et le reste du texte ou + Retourne None,texte si aucune constante trouvee """ txt = None texte = string.strip(texte) for cte in self.l_constantes: index = string.find(texte,cte) - #if index == 0 : print 'on a trouvé %s dans %s en %d' %(cte,texte,index) + #if index == 0 : print 'on a trouve %s dans %s en %d' %(cte,texte,index) if index == 0 : txt = cte zz,reste = string.split(texte,cte,1) @@ -325,41 +329,41 @@ class Interpreteur_Formule: if txt : return txt,reste else: - # aucune constante trouvée + # aucune constante trouvee return None,texte def cherche_constante(self,texte): """ - Recherche une constante en début de texte parmi la liste des constantes. - Retourne le texte représentant la constante et le reste du texte ou - Retourne None,texte si aucune constante trouvée + Recherche une constante en debut de texte parmi la liste des constantes. + Retourne le texte representant la constante et le reste du texte ou + Retourne None,texte si aucune constante trouvee """ txt = None texte = string.strip(texte) m = pat_constante.match(texte) if m : - # on a trouvé un identificateur en début de texte + # on a trouve un identificateur en debut de texte l_groups = m.groups() sgn = l_groups[0] identificateur = string.strip(l_groups[1]) reste = l_groups[2] - # il faut vérifier qu'il ne s'agit pas d'un appel à une fonction + # il faut verifier qu'il ne s'agit pas d'un appel a une fonction if reste : if reste[0] == '(' : # --> appel de fonction return None,texte - # il faut encore vérifier qu'elle est bien dans la liste des constantes... + # il faut encore verifier qu'elle est bien dans la liste des constantes... if identificateur not in self.l_constantes : - raise InterpreteurException,"La constante %s est inconnue dans %s" %(identificateur,texte) + raise InterpreteurException("La constante %s est inconnue dans %s" %(identificateur,texte)) else: return sgn+identificateur,reste else: - # aucune constante trouvée + # aucune constante trouvee return None,texte def cherche_args(self,texte): """ - Cherche au début de texte une liste d'arguments entre parenthèses + Cherche au debut de texte une liste d'arguments entre parentheses """ if texte[0]!='(': return None,texte @@ -369,8 +373,8 @@ class Interpreteur_Formule: while cpt != 0: n=n+1 if n>= len(texte): - # on a atteint la fin de texte sans avoir trouvé la parenthèse fermante --> erreur - raise InterpreteurException,"Manque parenthèse fermante dans %s" %texte + # on a atteint la fin de texte sans avoir trouve la parenthese fermante --> erreur + raise InterpreteurException("Manque parenthese fermante dans %s" %texte) if texte[n] == '(': cpt=cpt+1 elif texte[n]==')': @@ -394,16 +398,16 @@ class Interpreteur_Formule: zz,reste = string.split(texte,oper,1) break if txt : - #print 'on a trouvé :',txt + #print 'on a trouve :',txt operateur = txt texte = reste try: args,reste = self.cherche_args(texte) - except InterpreteurException,e: - raise InterpreteurException,e.__str__() + except InterpreteurException as e: + raise InterpreteurException(e.__str__()) if not args : - # opérateur unaire sans arguments - raise InterpreteurException,'opérateur unaire %s sans arguments' %operateur + # operateur unaire sans arguments + raise InterpreteurException('operateur unaire %s sans arguments' %operateur) else: #operateur = operateur+args args = self.split_args(txt,args,self.d_fonctions_unaires[operateur]) @@ -416,7 +420,7 @@ class Interpreteur_Formule: texte = reste return operateur,reste else: - # aucun opérateur unaire trouvé + # aucun operateur unaire trouve return None,texte def cherche_operateur_unaire(self,texte): @@ -427,24 +431,24 @@ class Interpreteur_Formule: texte = string.strip(texte) m = pat_constante.match(texte) if m : - # on a trouvé un identificateur en début de texte - # il faut encore vérifier que l'on a bien à faire à un appel de fonction ... + # on a trouve un identificateur en debut de texte + # il faut encore verifier que l'on a bien a faire a un appel de fonction ... l_groups = m.groups() sgn = l_groups[0] identificateur = string.strip(l_groups[1]) reste = l_groups[2] try: args,reste = self.cherche_args(reste) - except InterpreteurException,e: - raise InterpreteurException,e.__str__() + except InterpreteurException as e: + raise InterpreteurException (e.__str__()) if not args : - # opérateur unaire sans arguments - # en principe on ne doit jamais être dans ce cas car il est déjà trappé par cherche_constante ... - raise InterpreteurException,'Fonction %s sans arguments !' %identificateur + # operateur unaire sans arguments + # en principe on ne doit jamais etre dans ce cas car il est deja trappe par cherche_constante ... + raise InterpreteurException ('Fonction %s sans arguments !' %identificateur) else: - # il faut encore vérifier que l'on a bien à faire à une fonction connue + # il faut encore verifier que l'on a bien a faire a une fonction connue if identificateur not in self.l_fonctions_unaires: - raise InterpreteurException,'Fonction %s inconnue dans %s !' %(identificateur,texte) + raise InterpreteurException ('Fonction %s inconnue dans %s !' %(identificateur,texte)) args = self.split_args(identificateur,args,self.d_fonctions_unaires[identificateur]) formule_operateur = (sgn+identificateur,'',self.t_formule[2],args) operateur = Interpreteur_Formule(formule = formule_operateur, @@ -458,10 +462,10 @@ class Interpreteur_Formule: # Il faut pouvoir trapper les expressions du type exp(-(x+1)) ... try : args,reste = self.cherche_args(texte[1:]) - except InterpreteurException,e: - raise InterpreteurException,e.__str__() + except InterpreteurException as e: + raise InterpreteurException (e.__str__()) if not args : - # Il ne s'agit pas de '-' comme opérateur unaire --> on retourne None + # Il ne s'agit pas de '-' comme operateur unaire --> on retourne None return None,texte else: identificateur = '-' @@ -485,7 +489,7 @@ class Interpreteur_Formule: texte = string.strip(texte) for oper in self.l_fonctions_binaires: index = string.find(texte,oper) - #if index != -1 : print 'on a trouvé %s dans %s en %d' %(oper,texte,index) + #if index != -1 : print 'on a trouve %s dans %s en %d' %(oper,texte,index) if index == 0 : txt = oper zz,reste = string.split(texte,oper,1) @@ -493,18 +497,18 @@ class Interpreteur_Formule: if txt : return txt,reste else: - # aucun opérateur unaire trouvé + # aucun operateur unaire trouve return None,texte def cherche_expression_entre_parentheses(self,texte): """ - Cherche en début de texte une expression entre parentheses + Cherche en debut de texte une expression entre parentheses """ args,reste = self.cherche_args(string.strip(texte)) if not args : return None,texte else: - # on a trouvé une expression entre parenthèses en début de texte + # on a trouve une expression entre parentheses en debut de texte # --> on retourne un objet Interpreteur_Formule formule_operateur = ('','',self.t_formule[2],args[1:-1]) operateur = Interpreteur_Formule(formule = formule_operateur, @@ -517,20 +521,20 @@ class Interpreteur_Formule: def split_args(self,nom_fonction,args,nb_args): """ - Tente de partager args en nb_args éléments - Retourne une liste de chaînes de caractères (liste de longueur nb_args) + Tente de partager args en nb_args elements + Retourne une liste de chaines de caracteres (liste de longueur nb_args) """ - args = args[1:-1] # on enlève les parenthèses ouvrante et fermante + args = args[1:-1] # on enleve les parentheses ouvrante et fermante if nb_args == 1 : return args l_args = string.split(args,',') if len(l_args) != nb_args: - raise InterpreteurException,"La fonction %s requiert %d arguments : %d fourni(s)" %(nom_fonction,nb_args,len(l_args)) + raise InterpreteurException ("La fonction %s requiert %d arguments : %d fourni(s)" %(nom_fonction,nb_args,len(l_args))) else: return l_args def get_type(self,texte): """ - Retourne le type de l'objet défini dans texte, à savoir: + Retourne le type de l'objet defini dans texte, a savoir: - constante - fonction - unknown @@ -546,9 +550,9 @@ class Interpreteur_Formule: def get_nb_args(self,formule): """ - Retourne le nombre d'arguments dans la définition de formule (sous forme de tuple) + Retourne le nombre d'arguments dans la definition de formule (sous forme de tuple) """ - args = formule[2][1:-1] # on enlève les parenthèses ouvrante et fermante + args = formule[2][1:-1] # on enleve les parentheses ouvrante et fermante l_args = string.split(args,',') return len(l_args) @@ -570,8 +574,8 @@ if __name__ == '__main__': constantes = constantes, fonctions = fonctions_unaires) txt = i.str() - print '\nformule %s = %s' %(str(formule),txt) - if i.isvalid() : - print "\n\tPas d'erreur !" - else: - print i.report() + print ('\nformule %s = %s' %(str(formule),txt)) + #if i.isvalid() : + # print "\n\tPas d'erreur !" + #else: + # print i.report() diff --git a/Extensions/localisation.py b/Extensions/localisation.py index e7cab01e..5ef3a493 100644 --- a/Extensions/localisation.py +++ b/Extensions/localisation.py @@ -50,15 +50,15 @@ def localise(application, locale=None,file=None ): if locale=="ang" : locale="en" if file != None : - print 'chargement de ', file,monPath - print eficas_translator.load(file,monPath) - print QApplication.installTranslator(eficas_translator) + print ('chargement de ', file,monPath) + print (eficas_translator.load(file,monPath)) + print (QApplication.installTranslator(eficas_translator)) return if eficas_translator.load("eficas_" + locale, monPath): QApplication.installTranslator(eficas_translator) else: - print "Unable to load Eficas translator!" + print ("Unable to load Eficas translator!") if __name__ == "__main__": diff --git a/Extensions/parametre.py b/Extensions/parametre.py index 3d391245..bd55a9d1 100644 --- a/Extensions/parametre.py +++ b/Extensions/parametre.py @@ -18,10 +18,10 @@ # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # """ - Ce module contient la classe PARAMETRE qui sert à définir - des objets paramètres qui sont compréhensibles et donc affichables + Ce module contient la classe PARAMETRE qui sert a definir + des objets parametres qui sont comprehensibles et donc affichables par EFICAS. - Ces objets sont créés à partir de la modification du fichier de commandes + Ces objets sont crees a partir de la modification du fichier de commandes de l'utilisateur par le parseur de fichiers Python """ @@ -40,10 +40,10 @@ from Extensions.i18n import tr class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) : """ - Cette classe permet de créer des objets de type PARAMETRE + Cette classe permet de creer des objets de type PARAMETRE cad des affectations directes dans le jeu de commandes (ex: a=10.) - qui sont interprétées par le parseur de fichiers Python. - Les objets ainsi créés constituent des paramètres pour le jdc + qui sont interpretees par le parseur de fichiers Python. + Les objets ainsi crees constituent des parametres pour le jdc """ nature = 'PARAMETRE' @@ -51,8 +51,8 @@ class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) : def __init__(self,nom,valeur=None): self.nom = nom - # La classe PARAMETRE n'a pas de définition : on utilise self pour - # complétude + # La classe PARAMETRE n'a pas de definition : on utilise self pour + # completude self.definition=self # parent ne peut être qu'un objet de type JDC self.jdc = self.parent = CONTEXT.get_current_step() @@ -68,12 +68,12 @@ class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) : def interprete_valeur(self,val): """ - Essaie d'interpréter val (chaîne de caractères)comme : + Essaie d'interpreter val (chaîne de caracteres)comme : - un entier - - un réel - - une chaîne de caractères - - une liste d'items d'un type qui précède - Retourne la valeur interprétée + - un reel + - une chaîne de caracteres + - une liste d'items d'un type qui precede + Retourne la valeur interpretee """ #if not val : return None valeur = None @@ -111,10 +111,10 @@ class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) : typ = type(v) else: if type(v) != typ : - # la liste est hétérogène --> on refuse d'interpréter + # la liste est heterogene --> on refuse d'interpreter # self comme une liste # on retourne la string initiale - print 'liste hétérogène ',val + print ('liste heterogene ',val) return val l_new_val.append(v) return tuple(l_new_val) @@ -125,7 +125,7 @@ class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) : for i in range(len(valeur)): self.dict_valeur.append(valeur[i]) return valeur - # on retourne val comme une string car on n'a pas su l'interpréter + # on retourne val comme une string car on n'a pas su l'interpreter return val def get_valeurs(self): @@ -139,7 +139,7 @@ class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) : def set_valeur(self,new_valeur): """ - Remplace la valeur de self par new_valeur interprétée + Remplace la valeur de self par new_valeur interpretee """ self.valeur = self.interprete_valeur(new_valeur) self.val=repr(self.valeur) @@ -156,8 +156,8 @@ class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) : def init_modif(self): """ - Méthode qui déclare l'objet courant comme modifié et propage - cet état modifié à ses ascendants + Methode qui declare l'objet courant comme modifie et propage + cet etat modifie a ses ascendants """ self.state = 'modified' if self.parent: @@ -171,7 +171,7 @@ class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) : def register(self): """ - Enregistre le paramètre dans la liste des étapes de son parent (JDC) + Enregistre le parametre dans la liste des etapes de son parent (JDC) """ self.parent.register_parametre(self) self.parent.register(self) @@ -179,7 +179,7 @@ class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) : def isvalid(self,cr='non'): """ Retourne 1 si self est valide, 0 sinon - Un paramètre est considéré comme valide si : + Un parametre est considere comme valide si : - il a un nom - il a une valeur """ @@ -202,7 +202,7 @@ class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) : def isrepetable(self): """ - Indique si self est répétable ou non : retourne toujours 1 + Indique si self est repetable ou non : retourne toujours 1 """ return 1 @@ -211,8 +211,8 @@ class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) : def supprime(self): """ - Méthode qui supprime toutes les boucles de références afin que - l'objet puisse être correctement détruit par le garbage collector + Methode qui supprime toutes les boucles de references afin que + l'objet puisse être correctement detruit par le garbage collector """ self.parent = None self.jdc = None @@ -222,7 +222,7 @@ class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) : def active(self): """ Rend l'etape courante active. - Il faut ajouter le paramètre au contexte global du JDC + Il faut ajouter le parametre au contexte global du JDC """ self.actif = 1 try: @@ -235,7 +235,7 @@ class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) : def inactive(self): """ Rend l'etape courante inactive - Il faut supprimer le paramètre du contexte global du JDC + Il faut supprimer le parametre du contexte global du JDC """ self.actif = 0 self.jdc.del_param(self) @@ -245,7 +245,7 @@ class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) : def isactif(self): """ - Booléenne qui retourne 1 si self est actif, 0 sinon + Booleenne qui retourne 1 si self est actif, 0 sinon """ return self.actif @@ -259,15 +259,15 @@ class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) : def supprime_sdprods(self): """ - Il faut supprimer le paramètre qui a été entré dans la liste des - paramètres du JDC + Il faut supprimer le parametre qui a ete entre dans la liste des + parametres du JDC """ self.jdc.delete_param(self) self.parent.delete_concept(self) def update_context(self,d): """ - Update le dictionnaire d avec le paramètre que produit self + Update le dictionnaire d avec le parametre que produit self """ d[self.nom]=self @@ -295,7 +295,7 @@ class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) : def __str__(self): """ - Retourne le nom du paramètre comme représentation de self + Retourne le nom du parametre comme representation de self """ return self.nom @@ -306,14 +306,14 @@ class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) : return None def report(self): - """ Génère l'objet rapport (classe CR) """ + """ Genere l'objet rapport (classe CR) """ self.cr=CR() self.isvalid(cr='oui') return self.cr def ident(self): """ - Retourne le nom interne associé à self + Retourne le nom interne associe a self Ce nom n'est jamais vu par l'utilisateur dans EFICAS """ return self.nom @@ -327,17 +327,17 @@ class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) : def verif_condition_bloc(self): """ Evalue les conditions de tous les blocs fils possibles - (en fonction du catalogue donc de la définition) de self et + (en fonction du catalogue donc de la definition) de self et retourne deux listes : - - la première contient les noms des blocs à rajouter - - la seconde contient les noms des blocs à supprimer + - la premiere contient les noms des blocs a rajouter + - la seconde contient les noms des blocs a supprimer """ return [],[] def verif_condition_regles(self,liste_presents): """ - Retourne la liste des mots-clés à rajouter pour satisfaire les règles - en fonction de la liste des mots-clés présents + Retourne la liste des mots-cles a rajouter pour satisfaire les regles + en fonction de la liste des mots-cles presents """ return [] diff --git a/Extensions/parametre_eval.py b/Extensions/parametre_eval.py index ece9fed0..1ae13082 100644 --- a/Extensions/parametre_eval.py +++ b/Extensions/parametre_eval.py @@ -18,10 +18,10 @@ # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # """ -Ce module contient la classe PARAMETRE_EVAL qui sert à définir -des objets paramètres qui sont compréhensibles et donc affichables +Ce module contient la classe PARAMETRE_EVAL qui sert a definir +des objets parametres qui sont comprehensibles et donc affichables par EFICAS. -Ces objets sont créés à partir de la modification du fichier de commandes +Ces objets sont crees a partir de la modification du fichier de commandes de l'utilisateur par le parseur de fichiers Python """ # import de modules Python @@ -38,16 +38,16 @@ pattern_eval = re.compile(r'^(EVAL)([ \t\r\f\v]*)\(([\w\W]*)') class PARAMETRE_EVAL(parametre.PARAMETRE) : """ - Cette classe permet de créer des objets de type PARAMETRE_EVAL - cad des affectations directes évaluées dans le jeu de commandes (ex: a=EVAL('''10.*SQRT(25)''')) - qui sont interprétées par le parseur de fichiers Python. - Les objets ainsi créés constituent des paramètres évalués pour le jdc + Cette classe permet de creer des objets de type PARAMETRE_EVAL + cad des affectations directes evaluees dans le jeu de commandes (ex: a=EVAL('''10.*SQRT(25)''')) + qui sont interpretees par le parseur de fichiers Python. + Les objets ainsi crees constituent des parametres evalues pour le jdc """ nature = 'PARAMETRE_EVAL' idracine='param_eval' def __init__(self,nom,valeur=None): - # parent ne peut être qu'un objet de type JDC + # parent ne peut etre qu'un objet de type JDC import Accas self.Accas_EVAL=Accas.EVAL self.valeur = self.interprete_valeur(valeur) @@ -70,15 +70,15 @@ class PARAMETRE_EVAL(parametre.PARAMETRE) : def __str__(self): """ - Retourne le nom du paramètre évalué comme représentation de self + Retourne le nom du parametre evalue comme representation de self """ return self.nom def interprete_valeur(self,val): """ - Essaie d'interpréter val (chaîne de caractères ou None) comme : + Essaie d'interpreter val (chaîne de caracteres ou None) comme : une instance de Accas.EVAL - Retourne la valeur interprétée + Retourne la valeur interpretee """ if not val : return None d={} @@ -90,12 +90,12 @@ class PARAMETRE_EVAL(parametre.PARAMETRE) : return valeur except: traceback.print_exc() - print "Le texte %s n'est pas celui d'un paramètre évalué" %val + print ("Le texte %s n'est pas celui d'un parametre evalue" %val) return None def set_valeur(self,new_valeur): """ - Remplace la valeur de self par new_valeur interprétée. + Remplace la valeur de self par new_valeur interpretee. """ self.valeur = self.interprete_valeur(new_valeur) self.val = new_valeur @@ -103,7 +103,7 @@ class PARAMETRE_EVAL(parametre.PARAMETRE) : def get_nom(self) : """ - Retourne le nom du paramètre + Retourne le nom du parametre """ return self.nom @@ -118,24 +118,24 @@ class PARAMETRE_EVAL(parametre.PARAMETRE) : def verif_eval(self,exp_eval=None,cr='non'): """ - Cette méthode a pour but de vérifier si l'expression EVAL + Cette methode a pour but de verifier si l'expression EVAL est syntaxiquement correcte. Retourne : - - un booléen, qui vaut 1 si licite, 0 sinon + - un booleen, qui vaut 1 si licite, 0 sinon - un message d'erreurs ('' si illicite) """ if not exp_eval: if self.valeur : - exp_eval = self.valeur.valeur[3:-3] # on enlève les triples guillemets + exp_eval = self.valeur.valeur[3:-3] # on enleve les triples guillemets else: exp_eval = None if exp_eval : - # on construit un interpréteur de formule + # on construit un interpreteur de formule formule=(self.nom,'',None,exp_eval) - # on récupère la liste des constantes et des autres fonctions prédéfinies - # et qui peuvent être utilisées dans le corps de la formule courante + # on recupere la liste des constantes et des autres fonctions predefinies + # et qui peuvent etre utilisees dans le corps de la formule courante l_ctes,l_form = self.jdc.get_parametres_fonctions_avant_etape(self) - # on crée un objet vérificateur + # on cree un objet verificateur verificateur = interpreteur_formule.Interpreteur_Formule(formule=formule, constantes = l_ctes, fonctions = l_form) @@ -151,33 +151,33 @@ class PARAMETRE_EVAL(parametre.PARAMETRE) : def verif_nom(self,nom=None,cr='non'): """ - Vérifie si le nom passé en argument (si aucun prend le nom courant) - est un nom valide pour un paramètre EVAL + Verifie si le nom passe en argument (si aucun prend le nom courant) + est un nom valide pour un parametre EVAL Retourne : - - un booléen, qui vaut 1 si nom licite, 0 sinon + - un booleen, qui vaut 1 si nom licite, 0 sinon - un message d'erreurs ('' si illicite) """ if not nom : nom = self.nom if nom == "" : if cr == 'oui' : self.cr.fatal(tr("Pas de nom donne au parametre EVAL")) - return 0,"Pas de nom donné au paramètre EVAL" + return 0,"Pas de nom donne au parametre EVAL" if len(nom) > 8 : if cr == 'oui' : self.cr.fatal(tr("Un nom de parametre ne peut depasser 8 caracteres")) - return 0,"Un nom de parametre ne peut dépasser 8 caracteres" + return 0,"Un nom de parametre ne peut depasser 8 caracteres" sd = self.parent.get_sd_autour_etape(nom,self) if sd : - if cr == 'oui' : self.cr.fatal(tr("Un concept de nom %s existe déjà !"), nom) - return 0,"Un concept de nom %s existe déjà !" %nom + if cr == 'oui' : self.cr.fatal(tr("Un concept de nom %s existe deja !"), nom) + return 0,"Un concept de nom %s existe deja !" %nom return 1,'' def verif_parametre_eval(self,param=None,cr='non'): """ - Vérifie la validité du paramètre EVAL passé en argument. - Ce nouveau paramètre est passé sous la forme d'un tuple : (nom,valeur) - Si aucun tuple passé, prend les valeurs courantes de l'objet + Verifie la validite du parametre EVAL passe en argument. + Ce nouveau parametre est passe sous la forme d'un tuple : (nom,valeur) + Si aucun tuple passe, prend les valeurs courantes de l'objet Retourne : - - un booléen, qui vaut 1 si EVAL licite, 0 sinon + - un booleen, qui vaut 1 si EVAL licite, 0 sinon - un message d'erreurs ('' si illicite) """ if not param : @@ -189,7 +189,7 @@ class PARAMETRE_EVAL(parametre.PARAMETRE) : test_eval,erreur_eval = self.verif_eval(param[1],cr=cr) # test global = produit des tests partiels test = test_nom*test_eval - # message d'erreurs global = concaténation des messages partiels + # message d'erreurs global = concatenation des messages partiels erreur = '' if not test : for mess in (erreur_nom,erreur_eval): @@ -198,10 +198,10 @@ class PARAMETRE_EVAL(parametre.PARAMETRE) : def update(self,param): """ - Méthode externe. - Met à jour les champs nom, valeur de self - par les nouvelles valeurs passées dans le tuple formule. - On stocke les valeurs SANS vérifications. + Methode externe. + Met a jour les champs nom, valeur de self + par les nouvelles valeurs passees dans le tuple formule. + On stocke les valeurs SANS verifications. """ self.init_modif() self.set_nom(param[0]) @@ -210,16 +210,16 @@ class PARAMETRE_EVAL(parametre.PARAMETRE) : def isvalid(self,cr='non'): """ Retourne 1 si self est valide, 0 sinon - Un paramètre évalué est considéré comme valide si : + Un parametre evalue est considere comme valide si : - il a un nom - - il a une valeur qui est interprétable par l'interpréteur de FORMULEs + - il a une valeur qui est interpretable par l'interpreteur de FORMULEs """ resu,erreur= self.verif_parametre_eval(cr=cr) return resu def report(self): """ - Génère l'objet rapport (classe CR) + Genere l'objet rapport (classe CR) """ self.cr = CR() self.isvalid(cr='oui') diff --git a/Extensions/translationQT5.py b/Extensions/translationQT5.py index 565cec79..fbaab2d1 100644 --- a/Extensions/translationQT5.py +++ b/Extensions/translationQT5.py @@ -22,7 +22,8 @@ tuples, or atoms. ``PyQt4`` is currently supported. """ -from Extensions.eficas_exception import EficasException +from eficas_exception import EficasException +#from Extensions.eficas_exception import EficasException import re regex=re.compile(r"% *[0-9]+") -- 2.39.2