1 # -*- coding: utf-8 -*-
2 # Copyright (C) 2007-2013 EDF R&D
4 # This library is free software; you can redistribute it and/or
5 # modify it under the terms of the GNU Lesser General Public
6 # License as published by the Free Software Foundation; either
7 # version 2.1 of the License.
9 # This library is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 # Lesser General Public License for more details.
14 # You should have received a copy of the GNU Lesser General Public
15 # License along with this library; if not, write to the Free Software
16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 Ce module contient la classe PARAMETRE qui sert a definir
22 des objets parametres qui sont comprehensibles et donc affichables
24 Ces objets sont crees a partir de la modification du fichier de commandes
25 de l'utilisateur par le parseur de fichiers Python
28 # import de modules Python
29 from __future__ import absolute_import
30 from __future__ import print_function
32 from builtins import str
33 from builtins import range
34 from builtins import object
41 # import de modules Eficas
42 from Noyau.N_CR import CR
43 from Noyau import N_OBJECT
44 from Ihm import I_OBJECT
46 from Ihm import CONNECTOR
47 from Extensions.i18n import tr
48 from six.moves import range
50 class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) :
52 Cette classe permet de creer des objets de type PARAMETRE
53 cad des affectations directes dans le jeu de commandes (ex: a=10.)
54 qui sont interpretees par le parseur de fichiers Python.
55 Les objets ainsi crees constituent des parametres pour le jdc
61 def __init__(self,nom,valeur=None):
63 # La classe PARAMETRE n'a pas de definition : on utilise self pour
66 # parent ne peut etre qu'un objet de type JDC
67 self.jdc = self.parent = CONTEXT.get_current_step()
68 self.niveau=self.parent.niveau
70 self.state='undetermined'
73 #self.valeur = self.interprete_valeur(valeur)
78 def interprete_valeur(self,val):
80 Essaie d'interpreter val (chaine de caracteres)comme :
83 - une chaine de caracteres
84 - une liste d'items d'un type qui precede
85 Retourne la valeur interpretee
87 #if not val : return None
91 # Un premier traitement a ete fait lors de la saisie
92 # permet de tester les parametres qui sont des listes
102 if type(val) == bytes:
103 # on tente l'evaluation dans un contexte fourni par le parent s'il existe
105 valeur=self.parent.eval_in_context(val,self)
110 #traceback.print_exc()
112 #PN je n ose pas modifier je rajoute
113 # refus des listes heterogenes : ne dvrait pas etre la
115 if type(valeur) == tuple:
123 # la liste est heterogene --> on refuse d'interpreter
124 # self comme une liste
125 # on retourne la string initiale
126 print(('liste heterogene ',val))
129 return tuple(l_new_val)
132 if type(valeur).__name__ == 'list':
134 for i in range(len(valeur)):
135 self.dict_valeur.append(valeur[i])
137 # on retourne val comme une string car on n'a pas su l'interpreter
140 def get_valeurs(self):
142 if self.dict_valeur != []:
143 for val in self.dict_valeur:
144 valeurretour.append(val)
146 valeurretour.append(self.valeur)
149 def set_valeur(self,new_valeur):
151 Remplace la valeur de self par new_valeur interpretee
153 self.valeur = self.interprete_valeur(new_valeur)
154 self.val=repr(self.valeur)
155 self.parent.update_concept_after_etape(self,self)
158 def set_nom(self,new_nom):
160 Change le nom du parametre
166 def init_modif(self):
168 Methode qui declare l'objet courant comme modifie et propage
169 cet etat modifie a ses ascendants
171 self.state = 'modified'
173 self.parent.init_modif()
175 def get_jdc_root(self):
177 return self.parent.get_jdc_root()
183 Enregistre le parametre dans la liste des etapes de son parent (JDC)
185 self.parent.register_parametre(self)
186 self.parent.register(self)
188 def isvalid(self,cr='non'):
190 Retourne 1 si self est valide, 0 sinon
191 Un parametre est considere comme valide si :
197 self.cr.fatal(tr("Pas de nom donne au parametre "))
200 if self.valeur == None :
202 self.cr.fatal(tr("Le parametre %s ne peut valoir None" , self.nom))
208 Indique si self est obligatoire ou non : retourne toujours 0
212 def isrepetable(self):
214 Indique si self est repetable ou non : retourne toujours 1
218 def liste_mc_presents(self):
223 Methode qui supprime toutes les boucles de references afin que
224 l'objet puisse etre correctement detruit par le garbage collector
233 Rend l'etape courante active.
234 Il faut ajouter le parametre au contexte global du JDC
238 self.jdc.append_param(self)
241 CONNECTOR.Emit(self,"add",None)
242 CONNECTOR.Emit(self,"valid")
246 Rend l'etape courante inactive
247 Il faut supprimer le parametre du contexte global du JDC
250 self.jdc.del_param(self)
251 self.jdc.delete_concept_after_etape(self,self)
252 CONNECTOR.Emit(self,"supp",None)
253 CONNECTOR.Emit(self,"valid")
257 Booleenne qui retourne 1 si self est actif, 0 sinon
261 def set_attribut(self,nom_attr,new_valeur):
263 Remplace la valeur de self.nom_attr par new_valeur)
265 if hasattr(self,nom_attr):
266 setattr(self,nom_attr,new_valeur)
269 def supprime_sdprods(self):
271 Il faut supprimer le parametre qui a ete entre dans la liste des
274 self.jdc.delete_param(self)
275 self.parent.delete_concept(self)
277 def update_context(self,d):
279 Update le dictionnaire d avec le parametre que produit self
285 Donne un echo de self sous la forme nom = valeur
287 if type(self.valeur) == bytes:
288 if self.valeur.find('\n') == -1:
289 # pas de retour chariot, on utilise repr
290 return self.nom+' = '+ repr(self.valeur)
291 elif self.valeur.find('"""') == -1:
292 # retour chariot mais pas de triple ", on formatte
293 return self.nom+' = """'+self.valeur+'"""'
295 return self.nom+' = '+ repr(self.valeur)
297 if type(self.valeur) == list :
298 aRetourner=self.nom+' = ['
299 for l in self.valeur :
300 aRetourner=aRetourner+str(l) +","
301 aRetourner=aRetourner[0:-1]+']'
303 return self.nom+' = '+ str(self.valeur)
307 Retourne le nom du parametre comme representation de self
311 def get_sdprods(self,nom_sd):
313 Retourne les concepts produits par la commande
318 """ Genere l'objet rapport (classe CR) """
320 self.isvalid(cr='oui')
325 Retourne le nom interne associe a self
326 Ce nom n'est jamais vu par l'utilisateur dans EFICAS
330 def delete_concept(self,sd):
333 def replace_concept(self,old_sd,sd):
336 def verif_condition_bloc(self):
338 Evalue les conditions de tous les blocs fils possibles
339 (en fonction du catalogue donc de la definition) de self et
340 retourne deux listes :
341 - la premiere contient les noms des blocs a rajouter
342 - la seconde contient les noms des blocs a supprimer
346 def verif_condition_regles(self,liste_presents):
348 Retourne la liste des mots-cles a rajouter pour satisfaire les regles
349 en fonction de la liste des mots-cles presents
353 def verif_existence_sd(self):
356 def control_sdprods(self,d):
363 def reset_context(self):
367 if isinstance(self.valeur,Formula):
368 return self.valeur.eval()
372 def __adapt__(self,validator):
373 return validator.adapt(self.eval())
375 class COMBI_PARAMETRE(object) :
376 def __init__(self,chainevaleur,valeur):
377 self.chainevaleur=chainevaleur
381 return self.chainevaleur
384 if self.valeur and self.chainevaleur:
387 class ITEM_PARAMETRE(object) :
388 def __init__(self,param_pere,item=None):
389 self.param_pere = param_pere
394 return self.param_pere.nom+'['+str(self.item)+']'
402 longueur= len(self.param_pere.dict_valeur) - 1
405 if self.item > longueur :