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