Extensions/parametre.py

   1 # -*- coding: utf-8 -*-
   2 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   3 # ======================================================================
   4 # COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
   5 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
   6 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
   7 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
   8 # (AT YOUR OPTION) ANY LATER VERSION.
   9 #
  10 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
  11 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
  12 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
  13 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
  14 #
  15 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
  16 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
  17 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
  18 #
  19 #
  20 # ======================================================================
  21 """
  22     Ce module contient la classe PARAMETRE qui sert à définir
  23     des objets paramètres qui sont compréhensibles et donc affichables
  24     par EFICAS.
  25     Ces objets sont créés à partir de la modification du fichier de commandes
  26     de l'utilisateur par le parseur de fichiers Python
  27 """
  28
  29 # import de modules Python
  30 import string,types
  31 from math import *
  32 import traceback
  33
  34 # import de modules Eficas
  35 from Noyau.N_CR import CR
  36 from Noyau import N_OBJECT
  37 from Ihm import I_OBJECT
  38 from param2 import *
  39 from Ihm import CONNECTOR
  40
  41 class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) :
  42   """
  43      Cette classe permet de créer des objets de type PARAMETRE
  44      cad des affectations directes dans le jeu de commandes (ex: a=10.)
  45      qui sont interprétées par le parseur de fichiers Python.
  46      Les objets ainsi créés constituent des paramètres pour le jdc
  47   """
  48
  49   nature = 'PARAMETRE'
  50   idracine = 'param'
  51
  52   def __init__(self,nom,valeur=None):
  53     self.nom = nom
  54     # La classe PARAMETRE n'a pas de définition : on utilise self pour
  55     # complétude
  56     self.definition=self
  57     # parent ne peut être qu'un objet de type JDC
  58     self.jdc = self.parent = CONTEXT.get_current_step()
  59     self.niveau=self.parent.niveau
  60     self.actif=1
  61     self.state='undetermined'
  62     self.register()
  63     self.dict_valeur=[]
  64     #self.valeur = self.interprete_valeur(valeur)
  65     #self.val=valeur
  66     self.valeur = valeur
  67     self.val=repr(valeur)
  68
  69   def interprete_valeur(self,val):
  70     """
  71     Essaie d'interpréter val (chaîne de caractères)comme :
  72     - un entier
  73     - un réel
  74     - une chaîne de caractères
  75     - une liste d'items d'un type qui précède
  76     Retourne la valeur interprétée
  77     """
  78     #if not val : return None
  79     valeur = None
  80
  81     if type(val) == types.StringType:
  82        # on tente l'evaluation dans un contexte fourni par le parent s'il existe
  83        if self.parent:
  84           valeur=self.parent.eval_in_context(val,self)
  85        else:
  86           try :
  87               valeur = eval(val)
  88           except:
  89               #traceback.print_exc()
  90               pass
  91     #PN je n ose pas modifier je rajoute
  92     # refus des listes heterogenes : ne dvrait pas etre la
  93     if valeur != None :
  94         if type(valeur) == types.TupleType:
  95             l_new_val = []
  96             typ = None
  97             for v in valeur :
  98                 if not typ:
  99                     typ = type(v)
 100                 else:
 101                     if type(v) != typ :
 102                         # la liste est hétérogène --> on refuse d'interpréter
 103                         #  self comme une liste
 104                         # on retourne la string initiale
 105                         print 'liste hétérogène ',val
 106                         return val
 107                 l_new_val.append(v)
 108             return tuple(l_new_val)
 109
 110     if valeur != None :
 111        if type(valeur).__name__ == 'list':
 112           self.dict_valeur=[]
 113           for i in range(len(valeur)):
 114              self.dict_valeur.append(valeur[i])
 115        return valeur
 116     # on retourne val comme une string car on n'a pas su l'interpréter
 117     return val
 118
 119   def get_valeurs(self):
 120     valeurretour=[]
 121     if self.dict_valeur != []:
 122        for val in self.dict_valeur:
 123            valeurretour.append(val)
 124     else:
 125         valeurretour.append(self.valeur)
 126     return valeurretour
 127
 128   def set_valeur(self,new_valeur):
 129     """
 130     Remplace la valeur de self par new_valeur interprétée
 131     """
 132     self.valeur = self.interprete_valeur(new_valeur)
 133     self.parent.update_concept_after_etape(self,self)
 134     self.init_modif()
 135
 136   def set_nom(self,new_nom):
 137     """
 138     Change le nom du parametre
 139     """
 140     self.init_modif()
 141     self.nom=new_nom
 142     self.fin_modif()
 143
 144   def init_modif(self):
 145     """
 146     Méthode qui déclare l'objet courant comme modifié et propage
 147     cet état modifié à ses ascendants
 148     """
 149     self.state = 'modified'
 150     if self.parent:
 151       self.parent.init_modif()
 152
 153   def get_jdc_root(self):
 154     if self.parent:
 155       return self.parent.get_jdc_root()
 156     else:
 157       return self
 158
 159   def register(self):
 160     """
 161     Enregistre le paramètre dans la liste des étapes de son parent (JDC)
 162     """
 163     self.parent.register_parametre(self)
 164     self.parent.register(self)
 165
 166   def isvalid(self,cr='non'):
 167     """
 168     Retourne 1 si self est valide, 0 sinon
 169     Un paramètre est considéré comme valide si :
 170       - il a un nom
 171       - il a une valeur
 172     """
 173     if self.nom == '' :
 174         if cr == 'oui':
 175            self.cr.fatal("Pas de nom donné au paramètre ")
 176         return 0
 177     else:
 178         if self.valeur == None :
 179             if cr == 'oui' :
 180                self.cr.fatal("Le paramètre %s ne peut valoir None" % self.nom)
 181             return 0
 182     return 1
 183
 184   def isoblig(self):
 185     """
 186     Indique si self est obligatoire ou non : retourne toujours 0
 187     """
 188     return 0
 189
 190   def isrepetable(self):
 191     """
 192     Indique si self est répétable ou non : retourne toujours 1
 193     """
 194     return 1
 195
 196   def liste_mc_presents(self):
 197     return []
 198
 199   def supprime(self):
 200     """
 201     Méthode qui supprime toutes les boucles de références afin que
 202     l'objet puisse être correctement détruit par le garbage collector
 203     """
 204     self.parent = None
 205     self.jdc = None
 206     self.definition=None
 207     self.niveau=None
 208
 209   def active(self):
 210     """
 211     Rend l'etape courante active.
 212     Il faut ajouter le paramètre au contexte global du JDC
 213     """
 214     self.actif = 1
 215     try:
 216         self.jdc.append_param(self)
 217     except:
 218         pass
 219     CONNECTOR.Emit(self,"add",None)
 220     CONNECTOR.Emit(self,"valid")
 221
 222   def inactive(self):
 223     """
 224     Rend l'etape courante inactive
 225     Il faut supprimer le paramètre du contexte global du JDC
 226     """
 227     self.actif = 0
 228     self.jdc.del_param(self)
 229     self.jdc.delete_concept_after_etape(self,self)
 230     CONNECTOR.Emit(self,"supp",None)
 231     CONNECTOR.Emit(self,"valid")
 232
 233   def isactif(self):
 234     """
 235     Booléenne qui retourne 1 si self est actif, 0 sinon
 236     """
 237     return self.actif
 238
 239   def set_attribut(self,nom_attr,new_valeur):
 240     """
 241     Remplace la valeur de self.nom_attr par new_valeur)
 242     """
 243     if hasattr(self,nom_attr):
 244       setattr(self,nom_attr,new_valeur)
 245       self.init_modif()
 246
 247   def supprime_sdprods(self):
 248     """
 249     Il faut supprimer le paramètre qui a été entré dans la liste des
 250     paramètres du JDC
 251     """
 252     self.jdc.delete_param(self)
 253     self.parent.delete_concept(self)
 254
 255   def update_context(self,d):
 256     """
 257     Update le dictionnaire d avec le paramètre que produit self
 258     """
 259     d[self.nom]=self
 260
 261   def __repr__(self):
 262     """
 263         Donne un echo de self sous la forme nom = valeur
 264     """
 265     if type(self.valeur) == types.StringType:
 266          if self.valeur.find('\n') == -1:
 267             # pas de retour chariot, on utilise repr
 268             return self.nom+' = '+ repr(self.valeur)
 269          elif self.valeur.find('"""') == -1:
 270             # retour chariot mais pas de triple ", on formatte
 271             return self.nom+' = """'+self.valeur+'"""'
 272          else:
 273             return self.nom+' = '+ repr(self.valeur)
 274     else:
 275        return self.nom+' = '+ str(self.valeur)
 276
 277   def __str__(self):
 278     """
 279         Retourne le nom du paramètre comme représentation de self
 280     """
 281     return self.nom
 282
 283   def get_sdprods(self,nom_sd):
 284      """
 285          Retourne les concepts produits par la commande
 286      """
 287      return None
 288
 289   def report(self):
 290     """ Génère l'objet rapport (classe CR) """
 291     self.cr=CR()
 292     self.isvalid(cr='oui')
 293     return self.cr
 294
 295   def ident(self):
 296     """
 297     Retourne le nom interne associé à self
 298     Ce nom n'est jamais vu par l'utilisateur dans EFICAS
 299     """
 300     return self.nom
 301
 302   def delete_concept(self,sd):
 303     pass
 304
 305   def replace_concept(self,old_sd,sd):
 306     pass
 307
 308   def verif_condition_bloc(self):
 309     """
 310         Evalue les conditions de tous les blocs fils possibles
 311         (en fonction du catalogue donc de la définition) de self et
 312         retourne deux listes :
 313           - la première contient les noms des blocs à rajouter
 314           - la seconde contient les noms des blocs à supprimer
 315     """
 316     return [],[]
 317
 318   def verif_condition_regles(self,liste_presents):
 319     """
 320         Retourne la liste des mots-clés à rajouter pour satisfaire les règles
 321         en fonction de la liste des mots-clés présents
 322     """
 323     return []
 324
 325   def verif_existence_sd(self):
 326      pass
 327
 328   def control_sdprods(self,d):
 329       """sans objet """
 330       pass
 331
 332   def close(self):
 333       pass
 334
 335   def reset_context(self):
 336       pass
 337
 338   def eval(self):
 339       if isinstance(self.valeur,Formula):
 340          return self.valeur.eval()
 341       else:
 342          return self.valeur
 343
 344   def __adapt__(self,validator):
 345       return validator.adapt(self.eval())
 346
 347 class COMBI_PARAMETRE :
 348   def __init__(self,chainevaleur,valeur):
 349       self.chainevaleur=chainevaleur
 350       self.valeur=valeur
 351
 352   def __repr__(self):
 353       return self.chainevaleur
 354
 355   def isvalid(self):
 356       if self.valeur and self.chainevaleur:
 357          return 1
 358
 359 class ITEM_PARAMETRE :
 360   def __init__(self,param_pere,item=None):
 361       self.param_pere = param_pere
 362       self.item = item
 363
 364
 365   def __repr__(self):
 366     return self.param_pere.nom+'['+str(self.item)+']'
 367
 368
 369   def isvalid(self):
 370       isvalid = 1
 371       if self.item < 0:
 372          isvalid =  0
 373       try:
 374          longueur= len(self.param_pere.dict_valeur) - 1
 375       except:
 376          longueur=0
 377       if self.item > longueur :
 378          isvalid= 0
 379       return isvalid