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