Extensions/parametre_eval.py

   1 # -*- coding: utf-8 -*-
   2 # Copyright (C) 2007-2021   EDF R&D
   3 #
   4 # This library is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU Lesser General Public
   6 # License as published by the Free Software Foundation; either
   7 # version 2.1 of the License.
   8 #
   9 # This library is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 # Lesser General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public
  15 # License along with this library; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20 """
  21 Ce module contient la classe PARAMETRE_EVAL qui sert a definir
  22 des objets parametres qui sont comprehensibles et donc affichables
  23 par EFICAS.
  24 Ces objets sont crees a partir de la modification du fichier de commandes
  25 de l'utilisateur par le parseur de fichiers Python
  26 """
  27 # import de modules Python
  28 from __future__ import absolute_import
  29 from __future__ import print_function
  30 import types,re
  31 import traceback
  32
  33 # import modules Eficas
  34 from . import interpreteur_formule
  35 from Noyau.N_CR import CR
  36 from Extensions.i18n import tr
  37 from . import parametre
  38
  39 pattern_eval       = re.compile(r'^(EVAL)([ \t\r\f\v]*)\(([\w\W]*)')
  40
  41 class PARAMETRE_EVAL(parametre.PARAMETRE) :
  42     """
  43     Cette classe permet de creer des objets de type PARAMETRE_EVAL
  44     cad des affectations directes evaluees dans le jeu de commandes (ex: a=EVAL('''10.*SQRT(25)'''))
  45     qui sont interpretees par le parseur de fichiers Python.
  46     Les objets ainsi crees constituent des parametres evalues pour le jdc
  47     """
  48     nature = 'PARAMETRE_EVAL'
  49     idracine='param_eval'
  50
  51     def __init__(self,nom,valeur=None):
  52         # parent ne peut etre qu'un objet de type JDC
  53         import Accas
  54         self.Accas_EVAL=Accas.EVAL
  55         self.valeur = self.interpreteValeur(valeur)
  56         self.val    = valeur
  57         self.nom = nom
  58         self.jdc = self.parent = CONTEXT.getCurrentStep()
  59         self.definition=self
  60         self.niveau = self.parent.niveau
  61         self.actif=1
  62         self.state='undetermined'
  63         # Ceci est-il indispensable ???
  64         #self.appel = N_utils.calleeWhere(niveau=2)
  65         self.register()
  66
  67     def __repr__(self):
  68         """
  69             Donne un echo de self sous la forme nom = valeur
  70         """
  71         return self.nom+' = '+ repr(self.valeur)
  72
  73     def __str__(self):
  74         """
  75             Retourne le nom du parametre evalue comme representation de self
  76         """
  77         return self.nom
  78
  79     def interpreteValeur(self,val):
  80         """
  81         Essaie d'interpreter val (chaine de caracteres ou None) comme :
  82         une instance de Accas.EVAL
  83         Retourne la valeur interpretee
  84         """
  85         if not val : return None
  86         d={}
  87         val = val.strip()
  88         if val[-1] == ';' : val = val[0:-1]
  89         d['EVAL'] = self.Accas_EVAL
  90         try:
  91             valeur = eval(val,{},d)
  92             return valeur
  93         except:
  94             traceback.print_exc()
  95             print(("Le texte %s n'est pas celui d'un parametre evalue" %val))
  96             return None
  97
  98     def setValeur(self,new_valeur):
  99         """
 100         Remplace la valeur de self par new_valeur interpretee.
 101         """
 102         self.valeur = self.interpreteValeur(new_valeur)
 103         self.val = new_valeur
 104         self.initModif()
 105
 106     def getNom(self) :
 107         """
 108         Retourne le nom du parametre
 109         """
 110         return self.nom
 111
 112     def getValeur(self):
 113         """
 114         Retourne la valeur de self, cad le texte de l'objet class_eval.EVAL
 115         """
 116         if self.valeur :
 117             return self.valeur.valeur
 118         else:
 119             return ''
 120
 121     def verifEval(self,exp_eval=None,cr='non'):
 122         """
 123         Cette methode a pour but de verifier si l'expression EVAL
 124         est syntaxiquement correcte.
 125         Retourne :
 126             - un booleen, qui vaut 1 si licite, 0 sinon
 127             - un message d'erreurs ('' si illicite)
 128         """
 129         if not exp_eval:
 130             if self.valeur :
 131                 exp_eval = self.valeur.valeur[3:-3] # on enleve les triples guillemets
 132             else:
 133                 exp_eval = None
 134         if exp_eval :
 135             # on construit un interpreteur de formule
 136             formule=(self.nom,'',None,exp_eval)
 137             # on recupere la liste des constantes et des autres fonctions predefinies
 138             # et qui peuvent etre utilisees dans le corps de la formule courante
 139             l_ctes,l_form = self.jdc.getParametresFonctionsAvantEtape(self)
 140             # on cree un objet verificateur
 141             verificateur = interpreteur_formule.Interpreteur_Formule(formule=formule,
 142                                                                      constantes = l_ctes,
 143                                                                      fonctions = l_form)
 144             if cr == 'oui' :
 145                 if not verificateur.cr.estvide():
 146                     self.cr.fatal(verificateur.cr.getMessFatal())
 147             return verificateur.isValid(),''.join(verificateur.cr.crfatal)
 148         else:
 149             # pas d'expression EVAL --> self non valide
 150             if cr == 'oui' :
 151                 self.cr.fatal(tr("Le parametre EVAL %s ne peut valoir None") , self.nom)
 152             return 0,tr("Le parametre EVAL ne peut valoir None")
 153
 154     def verifNom(self,nom=None,cr='non'):
 155         """
 156         Verifie si le nom passe en argument (si aucun prend le nom courant)
 157         est un nom valide pour un parametre EVAL
 158         Retourne :
 159             - un booleen, qui vaut 1 si nom licite, 0 sinon
 160             - un message d'erreurs ('' si illicite)
 161         """
 162         if not nom :
 163             nom = self.nom
 164         if nom == "" :
 165             if cr == 'oui' : self.cr.fatal(tr("Pas de nom donne au parametre EVAL"))
 166             return 0,"Pas de nom donne au parametre EVAL"
 167         if len(nom) > 8 :
 168             if cr == 'oui' : self.cr.fatal(tr("Un nom de parametre ne peut depasser 8 caracteres"))
 169             return 0,"Un nom de parametre ne peut depasser 8 caracteres"
 170         sd = self.parent.getSdAutourEtape(nom,self)
 171         if sd :
 172             if cr == 'oui' : self.cr.fatal(tr("Un concept de nom %s existe deja !"), nom)
 173             return 0,"Un concept de nom %s existe deja !" %nom
 174         return 1,''
 175
 176     def verifParametreEval(self,param=None,cr='non'):
 177         """
 178         Verifie la validite du parametre EVAL passe en argument.
 179         Ce nouveau parametre est passe sous la forme d'un tuple : (nom,valeur)
 180         Si aucun tuple passe, prend les valeurs courantes de l'objet
 181         Retourne :
 182                 - un booleen, qui vaut 1 si EVAL licite, 0 sinon
 183                 - un message d'erreurs ('' si illicite)
 184         """
 185         if not param :
 186             if self.valeur :
 187                 param = (self.nom,self.valeur.valeur)
 188             else:
 189                 param = (self.nom,None)
 190         test_nom,erreur_nom   = self.verifNom(param[0],cr=cr)
 191         test_eval,erreur_eval = self.verifEval(param[1],cr=cr)
 192         # test global = produit des tests partiels
 193         test = test_nom*test_eval
 194         # message d'erreurs global = concatenation des messages partiels
 195         erreur = ''
 196         if not test :
 197             for mess in (erreur_nom,erreur_eval):
 198                 erreur = erreur+(len(mess) > 0)*'\n'+mess
 199         return test,erreur
 200
 201     def update(self,param):
 202         """
 203         Methode externe.
 204         Met a jour les champs nom, valeur de self
 205         par les nouvelles valeurs passees dans le tuple formule.
 206         On stocke les valeurs SANS verifications.
 207         """
 208         self.initModif()
 209         self.setNom(param[0])
 210         self.setValeur('EVAL("""'+param[1]+'""")')
 211
 212     def isValid(self,cr='non'):
 213         """
 214         Retourne 1 si self est valide, 0 sinon
 215         Un parametre evalue est considere comme valide si :
 216           - il a un nom
 217           - il a une valeur qui est interpretable par l'interpreteur de FORMULEs
 218         """
 219         resu,erreur= self.verifParametreEval(cr=cr)
 220         return resu
 221
 222     def report(self):
 223         """
 224             Genere l'objet rapport (classe CR)
 225         """
 226         self.cr = CR()
 227         self.isValid(cr='oui')
 228         return self.cr
 229
 230     def setNom(self,new_nom):
 231         """
 232         Remplace le nom de self par new_nom
 233         """
 234         self.nom = new_nom