1 # -*- coding: iso-8859-1 -*-
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
25 import traceback,types,string
28 from Extensions.i18n import tr
29 from Extensions.eficas_exception import EficasException
35 from Noyau.N_ASSD import ASSD
36 from Noyau import N__F
38 from Extensions import param2
40 # import rajoutes suite a l'ajout de Build_sd --> a resorber
41 import Noyau, Validation.V_MACRO_ETAPE
42 from Noyau import N_Exception
43 from Noyau.N_Exception import AsException
44 import Accas # attention aux imports circulaires
45 # fin import a resorber
47 class MACRO_ETAPE(I_ETAPE.ETAPE):
51 #indique si le jeu de commande inclus a pu etre analyse par convert
52 #pour etre editable (0=NON, 1=OUI)
55 self.recorded_units={}
57 def get_sdprods(self,nom_sd):
59 Fonction : retourne le concept produit par l etape de nom nom_sd
60 s il existe sinon None
62 if self.sd and self.sd.nom == nom_sd :return self.sd
63 for co in self.sdprods:
64 if co.nom == nom_sd:return co
65 if type(self.definition.op_init) == types.FunctionType:
67 apply(self.definition.op_init,(self,d))
68 return d.get(nom_sd,None)
71 def get_contexte_jdc(self,fichier,text):
73 Interprete text comme un texte de jdc et retourne le contexte final.
75 Le contexte final est le dictionnaire des sd disponibles a la derniere etape.
76 Si text n'est pas un texte de jdc valide, retourne None
78 --> utilisee par ops.POURSUITE et INCLUDE
80 #print "get_contexte_jdc",self,self.nom
81 # On recupere l'etape courante
82 step=CONTEXT.get_current_step()
84 # on essaie de creer un objet JDC auxiliaire avec un contexte initial
85 # Attention get_contexte_avant retourne un dictionnaire qui contient
86 # le contexte courant. Ce dictionnaire est reactualise regulierement.
87 # Si on veut garder l'etat du contexte fige, il faut en faire une copie.
88 context_ini = self.parent.get_contexte_avant(self).copy()
89 #print "get_contexte_jdc",context_ini.keys()
91 # Indispensable avant de creer un nouveau JDC
92 CONTEXT.unset_current_step()
95 if hasattr(self,'prefix'):
96 prefix_include=self.prefix
97 # ATTENTION : le dictionnaire recorded_units sert a memoriser les unites des
98 # fichiers inclus. Il est preferable de garder le meme dictionnaire pendant
99 # tout le traitement et de ne pas le reinitialiser brutalement (utiliser
100 # clear plutot) si on ne veut pas perdre la memoire des unites.
101 # En principe si la memorisation est faite au bon moment il n'est pas necessaire
102 # de prendre cette precaution mais ce n'est pas vrai partout.
103 old_recorded_units=self.recorded_units.copy()
105 # on supprime l'ancien jdc_aux s'il existe
106 if hasattr(self,'jdc_aux') and self.jdc_aux:
107 self.jdc_aux.supprime_aux()
109 if fichier is None:fichier="SansNom"
111 # Il faut convertir le texte inclus en fonction du format
112 # sauf les INCLUDE_MATERIAU
113 self.text_converted=0
115 if self.nom != "INCLUDE_MATERIAU":
116 if self.parent.appli.ihm == "QT" :
117 format=self.parent.appli.appliEficas.format_fichier
119 format=self.jdc.appli.format_fichier.get()
120 #on force a python pour Carmel
121 if format=="CARMEL3D" : format="python"
122 if convert.plugins.has_key(format):
123 # Le convertisseur existe on l'utilise
124 p=convert.plugins[format]()
126 text=p.convert('exec',self.jdc.appli)
127 #Si le fichier ne peut pas etre converti, le cr n'est pas vide
128 #et le texte est retourne tel que
129 if not p.cr.estvide():
130 self.text_converted=0
131 self.text_error=str(p.cr)
133 self.text_converted=1
136 j=self.JdC_aux( procedure=text, nom=fichier,
137 appli=self.jdc.appli,
139 cata_ord_dico=self.jdc.cata_ordonne_dico,
140 context_ini = context_ini,
141 jdc_pere=self.jdc,etape_include=self,
142 prefix_include=prefix_include,
143 recorded_units=self.recorded_units,
144 old_recorded_units=old_recorded_units,**args)
147 # On recupere les etapes internes (pour validation)
150 self.jdc.jdcDict=self.jdc_aux
153 traceback.print_exc()
154 # On retablit l'etape courante step
155 CONTEXT.unset_current_step()
156 CONTEXT.set_current_step(step)
159 if not j.cr.estvide():
160 # Erreurs dans l'INCLUDE. On garde la memoire du fichier
161 # mais on n'insere pas les concepts
162 # On retablit l'etape courante step
165 CONTEXT.unset_current_step()
166 CONTEXT.set_current_step(step)
167 raise exceptions.Exception(tr("Impossible de relire le fichier %s \n ")+ unicode(j.cr))
171 # L'INCLUDE n'est pas valide.
172 # on produit un rapport d'erreurs
174 # On retablit l'etape courante step
175 CONTEXT.unset_current_step()
176 CONTEXT.set_current_step(step)
177 self.jdc.cr.fatal("Le fichier include contient des erreurs ")
178 raise EficasException(tr("Le fichier include contient des erreurs "))
181 # Si aucune erreur rencontree
182 # On recupere le contexte de l'include verifie
184 j_context=j.get_verif_contexte()
185 #print j_context.keys()
186 #print j.g_context.keys()
188 # On retablit l'etape courante step
189 CONTEXT.unset_current_step()
190 CONTEXT.set_current_step(step)
191 raise EficasException(" ")
193 # Si on est arrive ici, le texte du fichier inclus (INCLUDE, POURSUITE, ...)
194 # est valide et inserable dans le JDC
196 # On remplit le dictionnaire des concepts produits inclus
197 # en retirant les concepts presents dans le contexte initial
198 # On ajoute egalement le concept produit dans le sds_dict du parent
199 # sans verification car on est sur (verification integree) que
200 # le nommage est possible
201 self.g_context.clear()
202 for k,v in j_context.items():
203 if not context_ini.has_key(k) or context_ini[k] != v:
205 self.parent.sds_dict[k]=v
207 #Ce traitement n'est realise que dans les cas suivants:
208 # - si convert n'a pas pu convertir le jeu de commandes
209 # - et ce n'est pas un INCLUDE_MATERIAU
210 #On collecte les variables Python qui ne sont pas dans le contexte initial
211 #et dans le contexte valide et on en fait un pseudo-parametre (Variable)
212 if self.text_converted == 0 and self.nom != "INCLUDE_MATERIAU":
213 for k,v in j.g_context.items():
214 if k in context_ini:continue
215 if k in j_context:continue
216 if isinstance(v,ASSD):continue
217 if isinstance(v,I_ENTITE.ENTITE):continue
218 if isinstance(v,I_OBJECT.OBJECT):continue
219 if callable(v):continue
220 self.g_context[k]=param2.Variable(k,v)
222 # On recupere le contexte courant
223 self.current_context=j.current_context
224 self.index_etape_courante=j.index_etape_courante
227 # On retablit l'etape courante step
228 CONTEXT.unset_current_step()
229 CONTEXT.set_current_step(step)
233 def reevalue_sd_jdc(self):
235 Avec la liste des SD qui ont ete supprimees, propage la
236 disparition de ces SD dans toutes les etapes et descendants
238 #print "reevalue_sd_jdc"
239 l_sd_supp,l_sd_repl = self.diff_contextes()
241 self.parent.delete_concept_after_etape(self,sd)
242 for old_sd,sd in l_sd_repl:
243 self.parent.replace_concept_after_etape(self,old_sd,sd)
245 def diff_contextes(self):
247 Realise la difference entre les 2 contextes
248 old_contexte_fichier_init et contexte_fichier_init
249 cad retourne la liste des sd qui ont disparu ou ne derivent pas
250 de la meme classe et des sd qui ont ete remplacees
252 if not hasattr(self,'old_contexte_fichier_init'):return [],[]
255 for old_key in self.old_contexte_fichier_init.keys():
256 if not self.contexte_fichier_init.has_key(old_key):
257 if isinstance(self.old_contexte_fichier_init[old_key],ASSD):
258 l_sd_suppressed.append(self.old_contexte_fichier_init[old_key])
260 if isinstance(self.old_contexte_fichier_init[old_key],ASSD):
261 # Un concept de meme nom existe
262 old_class=self.old_contexte_fichier_init[old_key].__class__
263 if not isinstance(self.contexte_fichier_init[old_key],old_class):
264 # S'il n'est pas d'une classe derivee, on le supprime
265 l_sd_suppressed.append(self.old_contexte_fichier_init[old_key])
267 l_sd_replaced.append((self.old_contexte_fichier_init[old_key],self.contexte_fichier_init[old_key]))
268 return l_sd_suppressed,l_sd_replaced
270 def control_sdprods(self,d):
272 Cette methode doit verifier que les concepts produits par la
273 commande ne sont pas incompatibles avec le contexte fourni (d).
274 Si c'est le cas, le concept produit doit etre supprime
275 Si la macro a elle meme des etapes, elle doit propager
276 le traitement (voir methode control_jdc_context_apres de I_JDC)
278 #print "I_MACRO_ETAPE.control_sdprods",d.keys(),self.nom,self.sd and self.sd.nom
280 if d.has_key(self.sd.nom):
281 # Le concept est deja defini
282 if self.reuse and self.reuse is d[self.sd.nom]:
283 # Le concept est reutilise : situation normale
286 # Redefinition du concept, on l'annule
287 #XXX on pourrait simplement annuler son nom pour conserver les objets
288 # l'utilisateur n'aurait alors qu'a renommer le concept (faisable??)
291 self.sd=self.reuse=self.sdnom=None
292 self.parent.delete_concept_after_etape(self,sd)
295 # On verifie les concepts a droite du signe =
297 sdprods=self.sdprods[:]
300 if d.has_key(co.nom) and co is not d[co.nom] :
301 #nettoie les mots cles de l'etape qui ont comme valeur co
302 self.delete_concept(co)
303 #supprime les references a co dans les etapes suivantes
304 self.parent.delete_concept_after_etape(self,co)
306 self.sdprods.append(co)
309 for e in self.etapes:
313 def supprime_sdprod(self,sd):
315 Supprime le concept produit sd s'il est produit par l'etape
317 if sd in self.sdprods:
319 self.parent.del_sdprod(sd)
320 self.sdprods.remove(sd)
322 self.parent.delete_concept(sd)
325 if sd is not self.sd :return
326 if self.sd is not None :
328 self.parent.del_sdprod(sd)
331 self.parent.delete_concept(sd)
333 def supprime_sdprods(self):
335 Fonction: Lors de la destruction de la macro-etape, detruit tous les concepts produits
336 Un operateur n a qu un concept produit
337 Une procedure n'en a aucun
338 Une macro en a en general plus d'un
340 #print "supprime_sdprods"
341 if self.reuse is not self.sd :
342 # l'etape n'est pas reentrante
343 # le concept retourne par l'etape est a supprimer car il etait
346 self.parent.del_sdprod(self.sd)
347 self.parent.delete_concept(self.sd)
348 # On detruit les concepts a droite du signe =
349 for co in self.sdprods:
350 self.parent.del_sdprod(co)
351 self.parent.delete_concept(co)
352 # Si la macro a des etapes et des concepts inclus, on les detruit
353 for nom_sd,co in self.g_context.items():
354 if not isinstance(co,ASSD):continue
355 self.parent.del_sdprod(co)
356 self.parent.delete_concept(co)
357 # On met g_context a blanc
362 if hasattr(self,"jdc_aux") and self.jdc_aux:
363 # La macro a un jdc auxiliaire inclus. On demande sa fermeture
366 def reset_context(self):
367 if hasattr(self,"jdc_aux") and self.jdc_aux:
368 # La macro a un jdc auxiliaire inclus. On demande la reinitialisation du contexte
369 self.jdc_aux.reset_context()
371 def update_concept(self,sd):
372 I_ETAPE.ETAPE.update_concept(self,sd)
373 for etape in self.etapes:
374 etape.update_concept(sd)
376 def delete_concept(self,sd):
378 Fonction : Mettre a jour les mots cles de l etape et eventuellement
379 le concept produit si reuse suite a la disparition du concept sd
380 Seuls les mots cles simples MCSIMP font un traitement autre
381 que de transmettre aux fils
383 #print "delete_concept",sd
384 I_ETAPE.ETAPE.delete_concept(self,sd)
385 for etape in self.etapes:
386 etape.delete_concept(sd)
388 def replace_concept(self,old_sd,sd):
390 Fonction : Mettre a jour les mots cles de l etape et le concept produit si reuse
391 suite au remplacement du concept old_sd par sd
393 #print "replace_concept",old_sd,sd
394 I_ETAPE.ETAPE.replace_concept(self,old_sd,sd)
395 for etape in self.etapes:
396 etape.replace_concept(old_sd,sd)
398 def change_fichier_init(self,new_fic,text):
400 Tente de changer le fichier include. Le precedent include est conserve
403 if not hasattr(self,'fichier_ini'):
404 self.fichier_ini=None
405 self.fichier_text=None
406 self.fichier_err="Le fichier n'est pas defini"
407 self.contexte_fichier_init={}
408 self.recorded_units={}
410 self.fichier_unite="PasDefini"
411 import Extensions.jdc_include
412 self.JdC_aux=Extensions.jdc_include.JdC_include
414 self.old_fic = self.fichier_ini
415 self.old_text = self.fichier_text
416 self.old_err = self.fichier_err
417 self.old_context=self.contexte_fichier_init
418 self.old_units=self.recorded_units
419 self.old_etapes=self.etapes
420 self.old_jdc_aux=self.jdc_aux
422 self.fichier_ini = new_fic
423 self.fichier_text=text
426 self.make_contexte_include(new_fic,text)
428 l=traceback.format_exception_only(tr("Fichier invalide %s", sys.exc_info()[1]))
429 self.fichier_err=string.join(l)
430 raise EficasException(self.fichier_err)
432 # L'evaluation de text dans un JDC auxiliaire s'est bien passe
433 # on peut poursuivre le traitement
435 self.state="undetermined"
436 self.fichier_err=None
437 # On enregistre la modification de fichier
439 # Le contexte du parent doit etre reinitialise car les concepts produits ont change
440 self.parent.reset_context()
442 # Si des concepts ont disparu lors du changement de fichier, on demande leur suppression
443 self.old_contexte_fichier_init=self.old_context
444 self.reevalue_sd_jdc()
448 self.old_jdc_aux.close()
450 def restore_fichier_init(self):
452 Restaure le fichier init enregistre dans old_xxx
454 self.fichier_ini=self.old_fic
455 self.fichier_text=self.old_text
456 self.fichier_err=self.old_err
457 self.contexte_fichier_init=self.old_context
458 self.recorded_units=self.old_units
459 self.etapes=self.old_etapes
460 self.jdc_aux=self.old_jdc_aux
462 def force_fichier_init(self):
464 Force le remplacement du fichier init meme si le remplacant est en erreur
466 # Reinitialisation complete du compte-rendu d'erreurs
467 self.jdc_aux.cr=self.jdc_aux.CR()
468 # On remplit le dictionnaire des concepts produits inclus
469 # en retirant les concepts presents dans le contexte initial
470 # On ajoute egalement le concept produit dans le sds_dict du parent
471 # sans verification car on est sur (verification integree) que
472 # le nommage est possible
473 j_context=self.jdc_aux.get_contexte_avant(None)
474 self.g_context.clear()
475 context_ini=self.jdc_aux.context_ini
476 for k,v in j_context.items():
477 if not context_ini.has_key(k) or context_ini[k] != v:
479 self.parent.sds_dict[k]=v
480 # On recupere le contexte courant
481 self.current_context=self.jdc_aux.current_context
482 self.index_etape_courante=self.jdc_aux.index_etape_courante
483 self.contexte_fichier_init = j_context
484 self.fichier_err = None
486 # On enregistre la modification de fichier
488 self.state="undetermined"
490 # Le contexte du parent doit etre reinitialise car les concepts produits ont change
491 self.parent.reset_context()
493 # On remplace les anciens concepts par les nouveaux (y compris ajouts
494 # et suppression) et on propage les modifications aux etapes precedentes et suivantes
495 # reevalue_sd_jdc construit la liste des differences entre les contextes contexte_fichier_init
496 # et old_contexte_fichier_init et effectue les destructions et remplacements de concept
498 self.old_contexte_fichier_init=self.old_context
499 self.reevalue_sd_jdc()
502 self.old_jdc_aux.close()
504 self.jdc_aux.force_contexte(self.g_context)
506 def build_include(self,fichier,text):
507 import Extensions.jdc_include
508 self.JdC_aux=Extensions.jdc_include.JdC_include
509 # un include partage la table des unites avec son parent (jdc)
510 self.recorded_units=self.parent.recorded_units
511 self.build_jdcaux(fichier,text)
513 def build_poursuite(self,fichier,text):
514 import Extensions.jdc_include
515 self.JdC_aux=Extensions.jdc_include.JdC_poursuite
516 # une poursuite a sa propre table d'unites
517 self.recorded_units={}
518 self.build_jdcaux(fichier,text)
522 def build_includeInclude(self,text):
523 import Extensions.jdc_include
524 self.JdC_aux=Extensions.jdc_include.JdC_include
525 # un include partage la table des unites avec son parent (jdc)
526 self.build_jdcauxInclude(text)
529 def build_jdcauxInclude(self,text):
532 contexte = self.get_contexte_jdc(None,text)
533 except EficasException:
535 index=self.jdc.etapes.index(self)
536 for e in self.etapes:
538 self.jdc.etapes=self.jdc.etapes[:index+1]+self.etapes+self.jdc.etapes[index+1:]
542 CONTEXT.unset_current_step()
544 def build_jdcaux(self,fichier,text):
546 Cree un jdc auxiliaire initialise avec text.
547 Initialise le nom du fichier associe avec fichier
548 N'enregistre pas d'association unite <-> fichier
550 self.fichier_ini = fichier
551 self.fichier_text= text
552 self.fichier_unite=None
553 self.fichier_err = None
555 contexte = self.get_contexte_jdc(fichier,text)
556 if contexte is None :
557 # Impossible de construire le jdc auxiliaire (sortie par None)
558 # On simule une sortie par exception
559 raise EficasException(tr("Impossible de construire le jeu de commandes correspondant au fichier"))
561 # La construction du jdc auxiliaire est allee au bout
562 self.contexte_fichier_init = contexte
566 # Impossible de construire le jdc auxiliaire (sortie par exception)
567 l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
568 if self.jdc.appli is not None:
569 self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
570 message= tr("Ce fichier ne sera pas pris en compte\n %s",string.join(l)))
575 self.fichier_err = string.join(l)
576 self.contexte_fichier_init={}
579 raise EficasException(" ")
581 def make_contexte_include(self,fichier,text):
583 Cette methode sert a craer un contexte en interpratant un texte source Python.
585 #print "make_contexte_include",fichier
586 # on recupere le contexte d'un nouveau jdc dans lequel on interprete text
587 contexte = self.get_contexte_jdc(fichier,text)
588 if contexte == None :
589 raise EficasException("Impossible de construire le jeu de commandes correspondant au fichier")
591 # Pour les macros de type include : INCLUDE, INCLUDE_MATERIAU et POURSUITE
592 # l'attribut g_context est un dictionnaire qui contient les concepts produits par inclusion
593 # l'attribut contexte_fichier_init est un dictionnaire qui contient les concepts produits
594 # en sortie de macro. g_context est obtenu en retirant de contexte_fichier_init les concepts
595 # existants en debut de macro contenus dans context_ini (dans get_contexte_jdc)
596 # g_context est utilise pour avoir les concepts produits par la macro
597 # contexte_fichier_init est utilise pour avoir les concepts supprimes par la macro
598 self.contexte_fichier_init = contexte
599 #print "fin make_contexte_include",fichier
601 def reevalue_fichier_init_OBSOLETE(self):
602 """Recalcule les concepts produits par le fichier enregistre"""
603 #print "reevalue_fichier_init"
604 old_context=self.contexte_fichier_init
606 self.make_contexte_include(self.fichier_ini ,self.fichier_text)
608 l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
609 self.fichier_err = string.join(l)
613 self.old_contexte_fichier_init=old_context
614 self.contexte_fichier_init={}
615 self.reevalue_sd_jdc()
618 # L'evaluation s'est bien passee
619 self.fichier_err = None
620 self.old_contexte_fichier_init=old_context
621 self.reevalue_sd_jdc()
623 def update_fichier_init(self,unite):
624 """Reevalue le fichier init sans demander (dans la mesure du possible) a l'utilisateur
625 les noms des fichiers
626 Ceci suppose que les relations entre unites et noms ont ete memorisees prealablement
627 L'include a ete initialise precedemment. Le jdc auxiliaire existe.
629 #print "update_fichier_init",unite,self.fichier_unite
630 self.old_contexte_fichier_init=self.contexte_fichier_init
631 old_fichier_ini=self.fichier_ini
632 if not hasattr(self,"jdc_aux"):self.jdc_aux=None
633 old_jdc_aux=self.jdc_aux
635 #print "update_fichier_init",self,self.parent,self.parent.recorded_units
637 if self.fichier_unite is None:
638 # L'unite n'etait pas definie precedemment. On ne change que l'unite
639 #print "update_fichier_init","pas de changement dans include"
640 self.fichier_unite=unite
642 elif unite == self.fichier_unite :
643 # L'unite n'a pas change
644 #print "update_fichier_init","pas de changement dans include 3"
646 elif unite != self.fichier_unite :
647 # L'unite etait definie precedemment. On remplace l'include
649 f,text=self.get_file_memo(unite=unite,fic_origine=self.parent.nom)
651 # Le fichier associe n'a pas pu etre defini
652 # on change l'unite associee mais pas l'include
653 #print "update_fichier_init","pas de changement dans include 2"
654 self.fichier_unite=unite
658 self.fichier_text=text
659 self.fichier_unite=unite
660 #print "update_fichier_init",self.recorded_units
662 #print "update_fichier_init",self.fichier_ini,self.fichier_text,self.fichier_unite
664 if old_fichier_ini == self.fichier_ini:
665 # Le fichier inclus n'a pas change. On ne recree pas le contexte
666 # mais on enregistre le changement d'association unite <-> fichier
667 #print "update_fichier_init.fichier inchange",self.jdc_aux.context_ini
668 self.parent.record_unit(unite,self)
672 self.fichier_err=None
673 self.make_contexte_include(self.fichier_ini,self.fichier_text)
674 # Les 3 attributs fichier_ini fichier_text recorded_units doivent etre corrects
675 # avant d'appeler change_unit
677 # Erreurs lors de l'evaluation de text dans un JDC auxiliaire
678 l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
679 # On conserve la memoire du nouveau fichier
680 # mais on n'utilise pas les concepts crees par ce fichier
681 # on met l'etape en erreur : fichier_err=string.join(l)
682 self.fichier_err=string.join(l)
686 self.contexte_fichier_init={}
690 self.parent.record_unit(unite,self)
691 # Le contexte du parent doit etre reinitialise car les concepts
692 # produits ont change
693 self.parent.reset_context()
694 # Si des concepts ont disparu lors du changement de fichier, on
695 # demande leur suppression
696 self.reevalue_sd_jdc()
697 #print "update_fichier_init",self.jdc_aux.context_ini.keys()
699 def record_unite(self):
700 #print "record_unite",self.nom
701 if self.nom == "POURSUITE":
702 self.parent.record_unit(None,self)
704 if hasattr(self,'fichier_unite') :
705 self.parent.record_unit(self.fichier_unite,self)
707 def get_file_memo(self, unite=None, fname=None, fic_origine=''):
708 """Retourne le nom du fichier et le source correspondant a l'unite unite
709 Initialise en plus recorded_units
711 #print "get_file_memo",unite,fic_origine,self,self.parent
712 #print self.parent.recorded_units
714 # On est dans le cas d'une poursuite. On ne reutilise aucune unite de parent
717 # On est dans le cas d'un include. On reutilise toutes les unites de parent
718 units=self.parent.recorded_units
720 if self.parent.recorded_units.has_key(unite):
721 f,text,units=self.parent.recorded_units[unite]
724 if not osp.exists(fname):
725 raise AsException(fname + tr(" n'est pas un fichier existant"))
727 text = open(fname, 'rb').read()
729 f,text=self.jdc.get_file(unite=unite, fic_origine=fic_origine)
733 self.recorded_units=units
734 if f is None and self.jdc.appli:
735 self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
736 message= tr("Ce fichier ne sera pas pris en compte\nLe fichier associe n'est pas defini"))
739 def update_context(self,d):
741 Met a jour le contexte contenu dans le dictionnaire d
742 Une MACRO_ETAPE peut ajouter plusieurs concepts dans le contexte
743 Une fonction enregistree dans op_init peut egalement modifier le contexte
745 #print "update_context",self,self.nom,d.keys()
746 if hasattr(self,"jdc_aux") and self.jdc_aux:
747 #ATTENTION: update_context NE DOIT PAS appeler reset_context
748 # car il appelle directement ou indirectement update_context
749 # equivalent a reset_context. Evite les recursions
750 self.jdc_aux.context_ini=d.copy()
751 self.jdc_aux.current_context={}
752 self.jdc_aux.index_etape_courante=0
753 #ATTENTION: il ne faut pas utiliser self.jdc_aux.get_contexte_avant
754 #car cet appel conduit a des remontees multiples incoherentes dans le
756 #get_context_avant appelle update_context qui NE DOIT PAS appeler get_contexte_avant
757 #On n'a besoin que d'un update local connaissant
758 # le contexte amont : d qui sert a reinitialiser self.context_ini
759 for e in self.etapes:
763 if type(self.definition.op_init) == types.FunctionType:
764 apply(self.definition.op_init,(self,d))
765 if self.sd != None:d[self.sd.nom]=self.sd
766 for co in self.sdprods:
768 #print "update_context.fin",d.keys()
770 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
772 etape=Noyau.N_MACRO_ETAPE.MACRO_ETAPE.copy(self)
773 if hasattr(etape,"etapes") :etape.etapes=[]
774 if hasattr(etape,"jdc_aux") :
776 del etape.fichier_ini
780 #print "supprime",self
781 if hasattr(self,"jdc_aux") and self.jdc_aux:
782 self.jdc_aux.supprime_aux()
784 Noyau.N_MACRO_ETAPE.MACRO_ETAPE.supprime(self)
786 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
787 def get_file(self,unite=None,fic_origine=''):
788 """Retourne le nom du fichier et le source correspondant a l'unite unite
791 f,text=self.jdc.get_file(unite=unite,fic_origine=fic_origine)
797 def make_include3(self,fichier=None):
798 self.make_includeCarmel(fichier)
801 def make_includeCND(self,fichier=None):
803 if fichier==None : return
804 if hasattr(self,'fichier_ini') : print (self.fichier_ini)
805 if hasattr(self,'fichier_ini') : return
806 self.fichier_ini=fichier
807 from acquiertGroupes import getGroupes
808 erreur,listeGroupes=getGroupes(fichier)
809 if erreur != "" : print ("a traiter")
814 for groupe in listeGroupes :
815 if groupe[0:8]=='CURRENT_': texteSources +=groupe[8:]+"=SOURCE();\n"
816 if groupe[0:5]=='COND_': texteCond +=groupe[5:]+"=CONDUCTEUR();\n"
817 if groupe[0:7]=='NOCOND_': texteNoCond +=groupe[7:]+"=NOCOND();\n"
818 #if groupe[0:5]=='VCUT_': texteVcut +=groupe[5:]+"=VCUT();\n"
819 if groupe[0:5]=='VCUT_': texteVcut +='V_'+groupe[5:]+"=VCUT();\n"
820 texte=texteSources+texteCond+texteNoCond+texteVcut
822 self.build_includeInclude(texte)
823 if CONTEXT.get_current_step()==None : CONTEXT.set_current_step(self)
826 def make_includeCarmel(self,fichier=None):
828 #print "je suis dans make_includeCarmel"
830 if hasattr(self,'fichier_ini') : return
832 if hasattr(self,'old_context_fichier_init' ):
834 for concept in self.old_context_fichier_init.values():
835 self.jdc.delete_concept(concept)
837 fichier=str(self.jdc.appli.get_file_dictDonnees())
838 if fichier == str("") :
839 self.fichier_ini="badfile"
841 self.fichier_err=tr("Le fichier n est pas defini")
842 self.parent.record_unit(999,self)
844 MCFils=self.get_child('FileName')
845 MCFils.set_valeur(None)
848 raise EficasException(self.fichier_err)
849 self.fichier_ini = fichier
850 f=open(self.fichier_ini,'r')
851 self.fichier_text=f.read()
854 self.contexte_fichier_init={}
855 self.fichier_unite=999
856 self.fichier_err=None
860 import Extensions.jdc_include
861 self.JdC_aux=Extensions.jdc_include.JdC_include
864 traceback.print_exc()
865 self.make_incl2_except()
866 raise EficasException(" ")
870 self.make_contexte_include(self.fichier_ini ,self.fichier_text)
871 self.old_context_fichier_init=self.contexte_fichier_init
872 self.parent.record_unit(unite,self)
874 MCFils=self.get_child('FileName')
875 #MCFils.set_valeur(fichier)
876 #on appelle pas set_valeur qui modifie le contexte ce qui fout le bazar
877 #pas de modification de bloc
878 MCFils.valeur=fichier
884 self.make_incl2_except()
885 # Cette P*** de ligne suivante ne fonctionne que pour Aster
886 # si quelqu un a une idee merci de m en parler
887 #CONTEXT.set_current_step(self)
889 def make_include2(self,fichier=None):
891 # gestion de l unicite SVP
894 if hasattr(self,'fichier_ini') : return
896 if hasattr(self,'old_context_fichier_init' ):
898 for concept in self.old_context_fichier_init.values():
899 self.jdc.delete_concept(concept)
902 fichier=str(self.jdc.appli.get_file_variable())
903 if fichier == str("") :
904 self.fichier_ini="badfile"
906 self.fichier_err=tr("Le fichier n est pas defini")
907 self.parent.record_unit(999,self)
909 MCFils=self.get_child('FileName')
910 MCFils.set_valeur(None)
913 raise EficasException(self.fichier_err)
915 self.fichier_ini = fichier
916 self.fichier_text = ""
917 self.contexte_fichier_init={}
918 self.fichier_unite=999
919 self.fichier_err=None
922 from openturns import WrapperFile
923 monWrapper=WrapperFile(fichier)
924 data=monWrapper.getWrapperData()
925 maVariableListe=data.getVariableList()
926 nbVariables=maVariableListe.getSize()
927 for i in range(nbVariables) :
928 nom=maVariableListe[i].id_
929 type=maVariableListe[i].type_
931 #ligneTexte="%s=DETERMINISTICVARIABLE(N='%s',T='out',R=%d);\n" % (nom, nom, i)
933 nbVariableOut=nbVariableOut+1
935 ligneTexte="%s=DETERMINISTICVARIABLE(N='%s',T='in',R=%d);\n" % (nom, nom, i)
936 self.fichier_text = self.fichier_text + ligneTexte
938 self.make_incl2_except()
939 raise EficasException(" ")
941 if nbVariableOut != 1 :
942 print (nbVariableOut ,"nbVariableOut")
943 self.make_incl2_except(mess=tr("le fichier doit contenir une unique variable de sortie"))
944 raise EficasException(" ")
947 import Extensions.jdc_include
948 self.JdC_aux=Extensions.jdc_include.JdC_include
950 traceback.print_exc()
951 self.make_incl2_except()
952 raise EficasException(" ")
955 print (self.fichier_ini ,self.fichier_text)
956 self.make_contexte_include(self.fichier_ini ,self.fichier_text)
957 self.old_context_fichier_init=self.contexte_fichier_init
958 self.parent.record_unit(unite,self)
960 MCFils=self.get_child('FileName')
961 MCFils.set_valeur(fichier)
965 self.make_incl2_except()
967 # recalcul validite pour la matrice eventuelle
969 for e in self.jdc.etapes:
970 if e.nom == "VARIABLE" :
973 mc=e.get_child('ModelVariable')
977 if e.nom == "CORRELATION" :
980 mc=e.get_child('Matrix')
982 mcFeuille=mc.get_child('CorrelationMatrix')
983 mcFeuille.state="modified"
988 def make_incl2_except(self,mess=None):
989 l=traceback.format_exception_only(tr("Fichier invalide"),sys.exc_info()[1])
990 if self.jdc.appli is not None:
992 self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
993 message= tr("Le contenu de ce fichier ne sera pas pris en compte\n %s",\
997 self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
999 #self.parent.record_unit(unite,self)
1003 self.fichier_err = string.join(l)
1004 self.contexte_fichier_init={}
1006 MCFils=self.get_child('FileName')
1007 MCFils.set_valeur(None)
1012 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
1013 def make_include(self, unite=None, fname=None):
1015 Inclut un fichier dont l'unite logique est unite
1016 Cette methode est appelee par la fonction sd_prod de la macro INCLUDE
1017 Si l'INCLUDE est invalide, la methode doit produire une exception
1018 Sinon on retourne None. Les concepts produits par l'INCLUDE sont
1019 pris en compte par le JDC parent lors du calcul du contexte (appel de ???)
1021 #print "make_include",unite
1022 # On supprime l'attribut unite qui bloque l'evaluation du source de l'INCLUDE
1023 # car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini
1024 # Si unite n'a pas de valeur, l'etape est forcement invalide. On peut retourner None
1025 if not unite and not fname:
1028 if not hasattr(self,'fichier_ini') :
1029 # Si le fichier n'est pas defini on le demande
1030 f,text=self.get_file_memo(unite=unite, fname=fname, fic_origine=self.parent.nom)
1031 # On memorise le fichier retourne
1032 self.fichier_ini = f
1033 self.fichier_text = text
1034 self.contexte_fichier_init={}
1035 self.fichier_unite=unite
1036 self.fichier_err=None
1038 import Extensions.jdc_include
1040 traceback.print_exc()
1041 raise EficasException("pb import Extensions")
1042 self.JdC_aux=Extensions.jdc_include.JdC_include
1044 #print "make_include",self.fichier_ini,self.fichier_text
1045 if f is None and not text:
1046 self.fichier_err=tr("Le fichier INCLUDE n est pas defini")
1047 self.parent.record_unit(unite,self)
1048 raise EficasException(self.fichier_err)
1051 self.make_contexte_include(self.fichier_ini ,self.fichier_text)
1052 self.parent.record_unit(unite,self)
1054 l=traceback.format_exception_only(tr("Fichier invalide %s",sys.exc_info()[1]))
1056 self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
1057 message=tr("Le contenu de ce fichier ne sera pas pris en compte\n"+string.join(l)))
1058 self.parent.record_unit(unite,self)
1062 self.fichier_err = string.join(l)
1063 self.contexte_fichier_init={}
1064 raise EficasException(" ")
1067 # Si le fichier est deja defini on ne reevalue pas le fichier
1068 # et on leve une exception si une erreur a ete enregistree
1069 self.update_fichier_init(unite)
1070 self.fichier_unite=unite
1071 if self.fichier_err is not None: raise EficasException(self.fichier_err)
1074 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
1075 def make_contexte(self,fichier,text):
1077 Cette methode sert a creer un contexte pour INCLUDE_MATERIAU
1078 en interpretant un texte source Python
1079 Elle est appelee par la fonction sd_prod d'INCLUDE_MATERIAU
1081 #print "make_contexte",fichier
1082 # On supprime l'attribut mat qui bloque l'evaluation du source de l'INCLUDE_MATERIAU
1083 # car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini
1084 if hasattr(self,'mat'):del self.mat
1085 if not hasattr(self,'fichier_ini') or self.fichier_ini != fichier or self.fichier_mater != self.nom_mater:
1086 # le fichier est nouveau ou change
1087 self.fichier_ini =fichier
1088 self.fichier_unite =fichier
1089 self.fichier_mater=self.nom_mater
1090 self.fichier_text=text
1091 self.fichier_err=None
1092 self.contexte_fichier_init={}
1093 # On specifie la classe a utiliser pour le JDC auxiliaire
1095 import Extensions.jdc_include
1096 self.JdC_aux=Extensions.jdc_include.JdC_include
1098 raise EficasException(" ")
1100 self.make_contexte_include(self.fichier_ini ,self.fichier_text)
1101 if not self.g_context.has_key(self.nom_mater):
1102 #Pour permettre de lire un jeu de commandes avec des INCLUDE_MATERIAU errones
1103 self.g_context[self.nom_mater]=None
1104 if self.parent: self.parent.g_context[self.nom_mater]=None
1106 l=traceback.format_exception_only(tr("Fichier invalide %s",sys.exc_info()[1]))
1107 self.fichier_err = string.join(l)
1109 #Pour permettre de lire un jeu de commandes avec des INCLUDE_MATERIAU errones
1111 self.parent.g_context[self.nom_mater]=None
1112 self.g_context[self.nom_mater]=None
1116 self.contexte_fichier_init={}
1117 raise EficasException(" ")
1119 # le fichier est le meme on ne le reevalue pas
1120 # et on leve une exception si une erreur a ete enregistree
1121 if self.fichier_err is not None: raise EficasException(self.fichier_err)
1123 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
1124 def update_sdprod(self,cr='non'):
1125 # Cette methode peut etre appelee dans EFICAS avec des mots cles de
1126 # la commande modifies. Ceci peut conduire a la construction ou
1127 # a la reconstruction d'etapes dans le cas d'INCLUDE ou d'INCLUDE_MATERIAU
1128 # Il faut donc positionner le current_step avant l'appel
1129 CONTEXT.unset_current_step()
1130 CONTEXT.set_current_step(self)
1131 valid=Validation.V_MACRO_ETAPE.MACRO_ETAPE.update_sdprod(self,cr=cr)
1132 CONTEXT.unset_current_step()
1135 #ATTENTION SURCHARGE: cette methode surcharge celle de Noyau a garder en synchro
1136 def Build_sd(self,nom):
1138 Methode de Noyau surchargee pour poursuivre malgre tout
1139 si une erreur se produit pendant la creation du concept produit
1142 sd=Noyau.N_MACRO_ETAPE.MACRO_ETAPE.Build_sd(self,nom)
1145 #except AsException,e:
1146 # Une erreur s'est produite lors de la construction du concept
1147 # Comme on est dans EFICAS, on essaie de poursuivre quand meme
1148 # Si on poursuit, on a le choix entre deux possibilites :
1149 # 1. on annule la sd associee a self
1150 # 2. on la conserve mais il faut la retourner
1151 # On choisit de l'annuler
1152 # En plus il faut rendre coherents sdnom et sd.nom
1155 self.state="unchanged"
1160 #ATTENTION SURCHARGE: cette methode surcharge celle de Noyau a garder en synchro
1161 def make_poursuite(self):
1162 """ Cette methode est appelee par la fonction sd_prod de la macro POURSUITE
1164 #print "make_poursuite"
1165 if not hasattr(self,'fichier_ini') :
1166 # Si le fichier n'est pas defini on le demande
1167 f,text=self.get_file_memo(fic_origine=self.parent.nom)
1168 # On memorise le fichier retourne
1169 self.fichier_ini = f
1170 self.fichier_unite = None
1171 self.fichier_text = text
1172 self.fichier_err=None
1174 import Extensions.jdc_include
1176 traceback.print_exc()
1177 raise EficasException(" ")
1178 self.JdC_aux=Extensions.jdc_include.JdC_poursuite
1179 self.contexte_fichier_init={}
1180 #print "make_poursuite",self.fichier_ini,self.fichier_text
1183 self.fichier_err="Le fichier POURSUITE n'est pas defini"
1185 self.parent.record_unit(None,self)
1186 raise EficasException(self.fichier_err)
1189 self.make_contexte_include(self.fichier_ini,self.fichier_text)
1190 self.parent.record_unit(None,self)
1192 l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
1194 self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier poursuite"),
1195 message=tr("Ce fichier ne sera pas pris en compte\n %s",string.join(l)))
1196 self.parent.record_unit(None,self)
1200 self.fichier_err = string.join(l)
1201 self.contexte_fichier_init={}
1202 raise EficasException(" ")
1205 # Si le fichier est deja defini on ne reevalue pas le fichier
1206 # et on leve une exception si une erreur a ete enregistree
1207 self.update_fichier_init(None)
1208 if self.fichier_err is not None: raise EficasException(self.fichier_err)