#
# 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+)(.*)')
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',
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}
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 :
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))
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
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
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:
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:
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]
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)
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
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]==')':
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])
texte = reste
return operateur,reste
else:
- # aucun opérateur unaire trouvé
+ # aucun operateur unaire trouve
return None,texte
def cherche_operateur_unaire(self,texte):
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,
# 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 = '-'
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)
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,
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
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)
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()
# 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
"""
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'
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()
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
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)
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):
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)
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:
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)
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
"""
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
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
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:
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)
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
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
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
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
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 []
# 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
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)
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={}
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
def get_nom(self) :
"""
- Retourne le nom du paramètre
+ Retourne le nom du parametre
"""
return self.nom
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)
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 :
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):
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])
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')
