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