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