Extensions/parametre.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 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
  28 # import de modules Python
  29 from __future__ import absolute_import
  30 from __future__ import print_function
  31 try :
  32    from builtins import str
  33    from builtins import object
  34 except : pass
  35
  36 import types
  37 from math import *
  38 import traceback
  39
  40 # import de modules Eficas
  41 from Noyau.N_CR import CR
  42 from Noyau.N_UserASSD import UserASSD
  43 from Noyau import N_OBJECT
  44 from Ihm import I_OBJECT
  45 from .param2 import *
  46 from Ihm import CONNECTOR
  47 from Extensions.i18n import tr
  48
  49
  50 class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) :
  51   """
  52      Cette classe permet de creer des objets de type PARAMETRE
  53      cad des affectations directes dans le jeu de commandes (ex: a=10.)
  54      qui sont interpretees par le parseur de fichiers Python.
  55      Les objets ainsi crees constituent des parametres pour le jdc
  56   """
  57
  58   nature = 'PARAMETRE'
  59   idracine = 'param'
  60
  61   def __new__(cls,nom,valeur=None):
  62     # on est en relecture du .comm: l objet a ete detecte comme parametre par le parsing
  63     # mais il  s agit d une reference, une UserASDD
  64      if (issubclass(valeur.__class__, UserASSD)):
  65         valeur.initialiseNom(nom)
  66         return valeur
  67      try :
  68         return super(PARAMETRE, cls).__new__(cls,*args,**kwargs)
  69      except :
  70         return super(PARAMETRE, cls).__new__(cls)
  71
  72
  73   def __init__(self,nom,valeur=None):
  74     #print ('__init__ de parametre pour', nom,valeur)
  75     self.nom = nom
  76     # La classe PARAMETRE n'a pas de definition : on utilise self pour
  77     # completude
  78     self.definition=self
  79     # parent ne peut etre qu'un objet de type JDC
  80     self.jdc = self.parent = CONTEXT.getCurrentStep()
  81     self.niveau=self.parent.niveau
  82     self.actif=1
  83     self.state='undetermined'
  84     self.register()
  85     self.dict_valeur=[]
  86     #self.valeur = self.interpreteValeur(valeur)
  87     #self.val=valeur
  88     self.valeur = valeur
  89     self.val=repr(valeur)
  90     self.fenetreIhm=None
  91
  92   def interpreteValeur(self,val):
  93     """
  94     Essaie d'interpreter val (chaine de caracteres)comme :
  95     - un entier
  96     - un reel
  97     - une chaine de caracteres
  98     - une liste d'items d'un type qui precede
  99     Retourne la valeur interpretee
 100     """
 101     #if not val : return None
 102     valeur = None
 103
 104     if type(val) == list:
 105     # Un premier traitement a ete fait lors de la saisie
 106     # permet de tester les parametres qui sont des listes
 107        l_new_val = []
 108        for v in val :
 109            try :
 110                valeur=eval(str(v))
 111                l_new_val.append(v)
 112            except :
 113                return None
 114        return l_new_val
 115
 116     if type(val) == bytes or  type(val) == str:
 117        # on tente l'evaluation dans un contexte fourni par le parent s'il existe
 118        if self.parent:
 119           valeur=self.parent.evalInContext(val,self)
 120        else:
 121           try :
 122               valeur = eval(val)
 123           except:
 124               #traceback.print_exc()
 125               pass
 126     #PN je n ose pas modifier je rajoute
 127     # refus des listes heterogenes : ne dvrait pas etre la
 128     if valeur != None :
 129         if type(valeur) == tuple:
 130             l_new_val = []
 131             typ = None
 132             for v in valeur :
 133                 if not typ:
 134                     typ = type(v)
 135                 else:
 136                     if type(v) != typ :
 137                         # la liste est heterogene --> on refuse d'interpreter
 138                         #  self comme une liste
 139                         # on retourne la string initiale
 140                         print(('liste heterogene ',val))
 141                         return val
 142                 l_new_val.append(v)
 143             return tuple(l_new_val)
 144
 145     if valeur != None :
 146        if type(valeur).__name__ == 'list':
 147           self.dict_valeur=[]
 148           for i in range(len(valeur)):
 149              self.dict_valeur.append(valeur[i])
 150        return valeur
 151     # on retourne val comme une string car on n'a pas su l'interpreter
 152     return val
 153
 154   def getValeurs(self):
 155     valeurretour=[]
 156     if self.dict_valeur != []:
 157        for val in self.dict_valeur:
 158            valeurretour.append(val)
 159     else:
 160         valeurretour.append(self.valeur)
 161     return valeurretour
 162
 163   def setValeur(self,new_valeur):
 164     """
 165     Remplace la valeur de self par new_valeur interpretee
 166     """
 167     self.valeur = self.interpreteValeur(new_valeur)
 168     self.val=repr(self.valeur)
 169     self.parent.updateConceptAfterEtape(self,self)
 170     self.initModif()
 171
 172   def setNom(self,new_nom):
 173     """
 174     Change le nom du parametre
 175     """
 176     self.initModif()
 177     self.nom=new_nom
 178     self.finModif()
 179
 180   def initModif(self):
 181     """
 182     Methode qui declare l'objet courant comme modifie et propage
 183     cet etat modifie a ses ascendants
 184     """
 185     self.state = 'modified'
 186     if self.parent:
 187       self.parent.initModif()
 188
 189   def getJdcRoot(self):
 190     if self.parent:
 191       return self.parent.getJdcRoot()
 192     else:
 193       return self
 194
 195   def register(self):
 196     """
 197     Enregistre le parametre dans la liste des etapes de son parent (JDC)
 198     """
 199     self.parent.registerParametre(self)
 200     self.parent.register(self)
 201
 202   def isValid(self,cr='non'):
 203     """
 204     Retourne 1 si self est valide, 0 sinon
 205     Un parametre est considere comme valide si :
 206       - il a un nom
 207       - il a une valeur
 208     """
 209     if self.nom == '' :
 210         if cr == 'oui':
 211            self.cr.fatal(tr("Pas de nom donne au parametre "))
 212         return 0
 213     else:
 214         if self.valeur == None :
 215             if cr == 'oui' :
 216                self.cr.fatal(tr("Le parametre %s ne peut valoir None" , self.nom))
 217             return 0
 218     return 1
 219
 220   def isOblig(self):
 221     """
 222     Indique si self est obligatoire ou non : retourne toujours 0
 223     """
 224     return 0
 225
 226   def isRepetable(self):
 227     """
 228     Indique si self est repetable ou non : retourne toujours 1
 229     """
 230     return 1
 231
 232   def listeMcPresents(self):
 233     return []
 234
 235   def supprime(self):
 236     """
 237     Methode qui supprime toutes les boucles de references afin que
 238     l'objet puisse etre correctement detruit par le garbage collector
 239     """
 240     self.parent = None
 241     self.jdc = None
 242     self.definition=None
 243     self.niveau=None
 244
 245   def active(self):
 246     """
 247     Rend l'etape courante active.
 248     Il faut ajouter le parametre au contexte global du JDC
 249     """
 250     self.actif = 1
 251     try:
 252         self.jdc.appendParam(self)
 253     except:
 254         pass
 255     CONNECTOR.Emit(self,"add",None)
 256     CONNECTOR.Emit(self,"valid")
 257
 258   def inactive(self):
 259     """
 260     Rend l'etape courante inactive
 261     Il faut supprimer le parametre du contexte global du JDC
 262     """
 263     self.actif = 0
 264     self.jdc.delParam(self)
 265     self.jdc.deleteConceptAfterEtape(self,self)
 266     CONNECTOR.Emit(self,"supp",None)
 267     CONNECTOR.Emit(self,"valid")
 268
 269   def isActif(self):
 270     """
 271     Booleenne qui retourne 1 si self est actif, 0 sinon
 272     """
 273     return self.actif
 274
 275   def setAttribut(self,nom_attr,new_valeur):
 276     """
 277     Remplace la valeur de self.nom_attr par new_valeur)
 278     """
 279     if hasattr(self,nom_attr):
 280       setattr(self,nom_attr,new_valeur)
 281       self.initModif()
 282
 283   def supprimeSdProds(self):
 284     """
 285     Il faut supprimer le parametre qui a ete entre dans la liste des
 286     parametres du JDC
 287     """
 288     self.jdc.deleteParam(self)
 289     self.parent.deleteConcept(self)
 290
 291   def updateContext(self,d):
 292     """
 293     Update le dictionnaire d avec le parametre que produit self
 294     """
 295     d[self.nom]=self
 296
 297   def __repr__(self):
 298     """
 299         Donne un echo de self sous la forme nom = valeur
 300     """
 301     if type(self.valeur) == bytes or  type(self.valeur) == str :
 302          if self.valeur.find('\n') == -1:
 303             # pas de retour chariot, on utilise repr
 304             return self.nom+' = '+ repr(self.valeur)
 305          elif self.valeur.find('"""') == -1:
 306             # retour chariot mais pas de triple ", on formatte
 307             return self.nom+' = """'+self.valeur+'"""'
 308          else:
 309             return self.nom+' = '+ repr(self.valeur)
 310     else:
 311        if type(self.valeur) == list :
 312           aRetourner=self.nom+' = ['
 313           for l in self.valeur :
 314             aRetourner=aRetourner+str(l) +","
 315           aRetourner=aRetourner[0:-1]+']'
 316           return aRetourner
 317        return self.nom+' = '+ str(self.valeur)
 318
 319   def __str__(self):
 320     """
 321         Retourne le nom du parametre comme representation de self
 322     """
 323     return self.nom
 324
 325   def getSdprods(self,nom_sd):
 326      """
 327          Retourne les concepts produits par la commande
 328      """
 329      return None
 330
 331   def report(self):
 332     """ Genere l'objet rapport (classe CR) """
 333     self.cr=CR()
 334     self.isValid(cr='oui')
 335     return self.cr
 336
 337   def ident(self):
 338     """
 339     Retourne le nom interne associe a self
 340     Ce nom n'est jamais vu par l'utilisateur dans EFICAS
 341     """
 342     return self.nom
 343
 344   def deleteConcept(self,sd):
 345     pass
 346
 347   def replaceConcept(self,old_sd,sd):
 348     pass
 349
 350   def verifConditionBloc(self):
 351     """
 352         Evalue les conditions de tous les blocs fils possibles
 353         (en fonction du catalogue donc de la definition) de self et
 354         retourne deux listes :
 355           - la premiere contient les noms des blocs a rajouter
 356           - la seconde contient les noms des blocs a supprimer
 357     """
 358     return [],[]
 359
 360   def verifConditionRegles(self,liste_presents):
 361     """
 362         Retourne la liste des mots-cles a rajouter pour satisfaire les regles
 363         en fonction de la liste des mots-cles presents
 364     """
 365     return []
 366
 367   def verifExistenceSd(self):
 368      pass
 369
 370   def controlSdprods(self,d):
 371       """sans objet """
 372       pass
 373
 374   def close(self):
 375       pass
 376
 377   def resetContext(self):
 378       pass
 379
 380   def eval(self):
 381       if isinstance(self.valeur,Formula):
 382          return self.valeur.eval()
 383       else:
 384          return self.valeur
 385
 386   def __adapt__(self,validator):
 387       return validator.adapt(self.eval())
 388
 389 class COMBI_PARAMETRE(object) :
 390   def __init__(self,chainevaleur,valeur):
 391       self.chainevaleur=chainevaleur
 392       self.valeur=valeur
 393
 394   def __repr__(self):
 395       return self.chainevaleur
 396
 397   def isValid(self):
 398       if self.valeur and self.chainevaleur:
 399          return 1
 400
 401 class ITEM_PARAMETRE(object) :
 402   def __init__(self,param_pere,item=None):
 403       self.param_pere = param_pere
 404       self.item = item
 405
 406
 407   def __repr__(self):
 408     return self.param_pere.nom+'['+str(self.item)+']'
 409
 410
 411   def isValid(self):
 412       isValid = 1
 413       if self.item < 0:
 414          isValid =  0
 415       try:
 416          longueur= len(self.param_pere.dict_valeur) - 1
 417       except:
 418          longueur=0
 419       if self.item > longueur :
 420          isValid= 0
 421       return isValid