Extensions/parametre.py

   1 """
   2     Ce module contient la classe PARAMETRE qui sert à définir
   3     des objets paramètres qui sont compréhensibles et donc affichables
   4     par EFICAS.
   5     Ces objets sont créés à partir de la modification du fichier de commandes
   6     de l'utilisateur par le parseur de fichiers Python
   7 """
   8
   9 # import de modules Python
  10 import string,types
  11
  12 # import de modules Eficas
  13 from Noyau.N_CR import CR
  14
  15 class PARAMETRE :
  16   """
  17      Cette classe permet de créer des objets de type PARAMETRE
  18      cad des affectations directes dans le jeu de commandes (ex: a=10.)
  19      qui sont interprétées par le parseur de fichiers Python.
  20      Les objets ainsi créés constituent des paramètres pour le jdc
  21   """
  22
  23   nature = 'PARAMETRE'
  24   idracine = 'param'
  25
  26   def __init__(self,nom,valeur=None):
  27     # parent ne peut être qu'un objet de type JDC
  28     self.valeur = self.interprete_valeur(valeur)
  29     self.val=valeur
  30     self.nom = nom
  31     # La classe PARAMETRE n'a pas de définition : on utilise self pour
  32     # complétude
  33     self.definition=self
  34     self.jdc = self.parent = CONTEXT.get_current_step()
  35     self.niveau=self.parent.niveau
  36     self.actif=1
  37     self.register()
  38
  39   def interprete_valeur(self,val):
  40     """
  41     Essaie d'interpréter val (chaîne de caractères)comme :
  42     - un entier
  43     - un réel
  44     - une chaîne de caractères
  45     - une liste d'items d'un type qui précède
  46     Retourne la valeur interprétée
  47     """
  48     if not val : return None
  49     valeur = None
  50     #  on vérifie si val est un entier
  51     try :
  52         valeur = string.atoi(val)       # on a un entier
  53         return valeur
  54     except :
  55         pass
  56     #  on vérifie si val est un réel
  57     try:
  58         valeur = string.atof(val)   # on a un réel
  59         return valeur
  60     except :
  61         pass
  62     # on vérifie si val est un tuple
  63     try :
  64         valeur = eval(val)
  65     except:
  66         pass
  67     if valeur != None :
  68         if type(valeur) == types.TupleType:
  69             l_new_val = []
  70             typ = None
  71             for v in valeur :
  72                 if not typ:
  73                     typ = type(v)
  74                 else:
  75                     if type(v) != typ :
  76                         # la liste est hétérogène --> on refuse d'interpréter
  77                         #  self comme une liste
  78                         # on retourne la string initiale
  79                         print 'liste hétérogène ',val
  80                         return val
  81                 l_new_val.append(v)
  82             return tuple(l_new_val)
  83         else:
  84             # on a réussi à évaluer val en autre chose qu'un tuple ...
  85             print "on a réussi à évaluer %s en autre chose qu'un tuple ..." %val
  86             print 'on trouve : ',str(valeur),' de type : ',type(valeur)
  87     # on retourne val comme une string car on n'a pas su l'interpréter
  88     return val
  89
  90   def set_valeur(self,new_valeur):
  91     """
  92     Remplace la valeur de self par new_valeur interprétée
  93     """
  94     self.valeur = self.interprete_valeur(new_valeur)
  95     self.init_modif()
  96
  97   def init_modif(self):
  98     """
  99     Méthode qui déclare l'objet courant comme modifié et propage
 100     cet état modifié à ses ascendants
 101     """
 102     self.state = 'modified'
 103     if self.parent:
 104       self.parent.init_modif()
 105
 106   def register(self):
 107     """
 108     Enregistre le paramètre dans la liste des étapes de son parent (JDC)
 109     """
 110     self.parent.register_parametre(self)
 111     self.parent.register(self)
 112
 113   def isvalid(self,cr='non'):
 114     """
 115     Retourne 1 si self est valide, 0 sinon
 116     Un paramètre est considéré comme valide si :
 117     - il a un nom
 118     - il a une valeur
 119     """
 120     if self.nom == '' :
 121         if cr == 'oui':
 122            self.cr.fatal("Pas de nom donné au paramètre ")
 123         return 0
 124     else:
 125         if self.valeur == None :
 126             if cr == 'oui' :
 127                self.cr.fatal("Le paramètre %s ne peut valoir None" % self.nom)
 128             return 0
 129     return 1
 130
 131   def isoblig(self):
 132     """
 133     Indique si self est obligatoire ou non : retourne toujours 0
 134     """
 135     return 0
 136
 137   def isrepetable(self):
 138     """
 139     Indique si self est répétable ou non : retourne toujours 1
 140     """
 141     return 1
 142
 143   def liste_mc_presents(self):
 144     return []
 145
 146   def supprime(self):
 147     """
 148     Méthode qui supprime toutes les boucles de références afin que
 149     l'objet puisse être correctement détruit par le garbage collector
 150     """
 151     self.parent = None
 152     self.jdc = None
 153     self.definition=None
 154
 155   def active(self):
 156     """
 157     Rend l'etape courante active.
 158     Il faut ajouter le paramètre au contexte global du JDC
 159     """
 160     self.actif = 1
 161     try:
 162         self.jdc.append_param(self)
 163     except:
 164         pass
 165
 166   def inactive(self):
 167     """
 168     Rend l'etape courante inactive
 169     Il faut supprimer le paramètre du contexte global du JDC
 170     """
 171     self.actif = 0
 172     self.jdc.del_param(self)
 173     self.jdc.delete_concept_after_etape(self,self)
 174
 175   def isactif(self):
 176     """
 177     Booléenne qui retourne 1 si self est actif, 0 sinon
 178     """
 179     return self.actif
 180
 181   def set_attribut(self,nom_attr,new_valeur):
 182     """
 183     Remplace la valeur de self.nom_attr par new_valeur)
 184     """
 185     if hasattr(self,nom_attr):
 186       setattr(self,nom_attr,new_valeur)
 187       self.init_modif()
 188
 189   def supprime_sdprods(self):
 190     """
 191     Il faut supprimer le paramètre qui a été entré dans la liste des
 192     paramètres du JDC
 193     """
 194     self.jdc.delete_param(self)
 195
 196   def update_context(self,d):
 197     """
 198     Update le dictionnaire d avec le paramètre que produit self
 199     """
 200     d[self.nom]=self
 201
 202   def __repr__(self):
 203     """
 204         Donne un echo de self sous la forme nom = valeur
 205     """
 206     return self.nom+' = '+str(self.valeur)+'\n'
 207
 208   def __str__(self):
 209     """
 210         Retourne le nom du paramètre comme représentation de self
 211     """
 212     return self.nom
 213
 214   def get_sdprods(self,nom_sd):
 215      """
 216          Retourne les concepts produits par la commande
 217      """
 218      return None
 219
 220   def report(self):
 221     """ Génère l'objet rapport (classe CR) """
 222     self.cr=CR()
 223     self.isvalid(cr='oui')
 224     return self.cr
 225
 226   def ident(self):
 227     """
 228     Retourne le nom interne associé à self
 229     Ce nom n'est jamais vu par l'utilisateur dans EFICAS
 230     """
 231     return self.nom
 232
 233   def delete_concept(self,sd):
 234     pass
 235
 236   def verif_condition_bloc(self):
 237     """
 238         Evalue les conditions de tous les blocs fils possibles
 239         (en fonction du catalogue donc de la définition) de self et
 240         retourne deux listes :
 241         - la première contient les noms des blocs à rajouter
 242         - la seconde contient les noms des blocs à supprimer
 243     """
 244     return [],[]
 245
 246   def verif_condition_regles(self,liste_presents):
 247     """
 248         Retourne la liste des mots-clés à rajouter pour satisfaire les règles
 249         en fonction de la liste des mots-clés présents
 250     """
 251     return []
 252
 253
 254
 255
 256
 257