Extensions/parametre.py

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