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.
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.
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.
20 # ======================================================================
25 import traceback,types,string
32 from Noyau.N_ASSD import ASSD
33 from Noyau import N__F
35 from Extensions import param2
37 # import rajoutés suite à l'ajout de Build_sd --> à résorber
38 import Noyau, Validation.V_MACRO_ETAPE
39 from Noyau import N_Exception
40 from Noyau.N_Exception import AsException
41 import Accas # attention aux imports circulaires
42 # fin import à résorber
44 class MACRO_ETAPE(I_ETAPE.ETAPE):
48 #indique si le jeu de commande inclus a pu etre analysé par convert
49 #pour etre editable (0=NON, 1=OUI)
52 self.recorded_units={}
54 def get_sdprods(self,nom_sd):
56 Fonction : retourne le concept produit par l etape de nom nom_sd
57 s il existe sinon None
59 if self.sd and self.sd.nom == nom_sd :return self.sd
60 for co in self.sdprods:
61 if co.nom == nom_sd:return co
62 if type(self.definition.op_init) == types.FunctionType:
64 apply(self.definition.op_init,(self,d))
65 return d.get(nom_sd,None)
68 def get_contexte_jdc(self,fichier,text):
70 Interprète text comme un texte de jdc et retourne le contexte final.
72 Le contexte final est le dictionnaire des sd disponibles à la dernière étape.
73 Si text n'est pas un texte de jdc valide, retourne None
75 --> utilisée par ops.POURSUITE et INCLUDE
77 #print "get_contexte_jdc",self,self.nom
78 # On recupere l'etape courante
79 step=CONTEXT.get_current_step()
81 # on essaie de créer un objet JDC auxiliaire avec un contexte initial
82 # Attention get_contexte_avant retourne un dictionnaire qui contient
83 # le contexte courant. Ce dictionnaire est reactualise regulierement.
84 # Si on veut garder l'etat du contexte fige, il faut en faire une copie.
85 context_ini = self.parent.get_contexte_avant(self).copy()
86 #print "get_contexte_jdc",context_ini.keys()
88 # Indispensable avant de creer un nouveau JDC
89 CONTEXT.unset_current_step()
92 if hasattr(self,'prefix'):
93 prefix_include=self.prefix
94 # ATTENTION : le dictionnaire recorded_units sert à memoriser les unites des
95 # fichiers inclus. Il est preferable de garder le meme dictionnaire pendant
96 # tout le traitement et de ne pas le reinitialiser brutalement (utiliser
97 # clear plutot) si on ne veut pas perdre la memoire des unites.
98 # En principe si la memorisation est faite au bon moment il n'est pas necessaire
99 # de prendre cette precaution mais ce n'est pas vrai partout.
100 old_recorded_units=self.recorded_units.copy()
102 # on supprime l'ancien jdc_aux s'il existe
103 if hasattr(self,'jdc_aux') and self.jdc_aux:
104 self.jdc_aux.supprime_aux()
106 if fichier is None:fichier="SansNom"
108 # Il faut convertir le texte inclus en fonction du format
109 # sauf les INCLUDE_MATERIAU
110 self.text_converted=0
112 if self.nom != "INCLUDE_MATERIAU":
113 if self.parent.appli.ihm == "QT" :
114 format=self.parent.appli.appliEficas.format_fichier
116 format=self.jdc.appli.format_fichier.get()
117 if convert.plugins.has_key(format):
118 # Le convertisseur existe on l'utilise
119 p=convert.plugins[format]()
121 text=p.convert('exec',self.jdc.appli)
122 #Si le fichier ne peut pas etre converti, le cr n'est pas vide
123 #et le texte est retourné tel que
124 if not p.cr.estvide():
125 self.text_converted=0
126 self.text_error=str(p.cr)
128 self.text_converted=1
131 j=self.JdC_aux( procedure=text, nom=fichier,
132 appli=self.jdc.appli,
134 cata_ord_dico=self.jdc.cata_ordonne_dico,
135 context_ini = context_ini,
136 jdc_pere=self.jdc,etape_include=self,
137 prefix_include=prefix_include,
138 recorded_units=self.recorded_units,
139 old_recorded_units=old_recorded_units,**args)
142 # On récupère les étapes internes (pour validation)
146 traceback.print_exc()
147 # On retablit l'etape courante step
148 CONTEXT.unset_current_step()
149 CONTEXT.set_current_step(step)
152 if not j.cr.estvide():
153 # Erreurs dans l'INCLUDE. On garde la memoire du fichier
154 # mais on n'insere pas les concepts
155 # On retablit l'etape courante step
157 CONTEXT.unset_current_step()
158 CONTEXT.set_current_step(step)
159 raise Exception("Impossible de relire le fichier\n"+str(j.cr))
162 # L'INCLUDE n'est pas valide.
163 # on produit un rapport d'erreurs
166 # On retablit l'etape courante step
167 CONTEXT.unset_current_step()
168 CONTEXT.set_current_step(step)
169 raise Exception("Le fichier include contient des erreurs\n"+str(cr))
171 # Si aucune erreur rencontrée
172 # On recupere le contexte de l'include verifie
174 j_context=j.get_verif_contexte()
175 #print j_context.keys()
176 #print j.g_context.keys()
178 # On retablit l'etape courante step
179 CONTEXT.unset_current_step()
180 CONTEXT.set_current_step(step)
183 # Si on est arrivé ici, le texte du fichier inclus (INCLUDE, POURSUITE, ...)
184 # est valide et insérable dans le JDC
186 # On remplit le dictionnaire des concepts produits inclus
187 # en retirant les concepts présents dans le contexte initial
188 # On ajoute egalement le concept produit dans le sds_dict du parent
189 # sans verification car on est sur (verification integrée) que
190 # le nommage est possible
191 self.g_context.clear()
192 for k,v in j_context.items():
193 if not context_ini.has_key(k) or context_ini[k] != v:
195 self.parent.sds_dict[k]=v
197 #Ce traitement n'est réalisé que dans les cas suivants:
198 # - si convert n'a pas pu convertir le jeu de commandes
199 # - et ce n'est pas un INCLUDE_MATERIAU
200 #On collecte les variables Python qui ne sont pas dans le contexte initial
201 #et dans le contexte validé et on en fait un pseudo-parametre (Variable)
202 if self.text_converted == 0 and self.nom != "INCLUDE_MATERIAU":
203 for k,v in j.g_context.items():
204 if k in context_ini:continue
205 if k in j_context:continue
206 if isinstance(v,ASSD):continue
207 if isinstance(v,I_ENTITE.ENTITE):continue
208 if isinstance(v,I_OBJECT.OBJECT):continue
209 if callable(v):continue
210 self.g_context[k]=param2.Variable(k,v)
212 # On recupere le contexte courant
213 self.current_context=j.current_context
214 self.index_etape_courante=j.index_etape_courante
217 # On retablit l'etape courante step
218 CONTEXT.unset_current_step()
219 CONTEXT.set_current_step(step)
223 def reevalue_sd_jdc(self):
225 Avec la liste des SD qui ont été supprimées, propage la
226 disparition de ces SD dans toutes les étapes et descendants
228 #print "reevalue_sd_jdc"
229 l_sd_supp,l_sd_repl = self.diff_contextes()
231 self.parent.delete_concept_after_etape(self,sd)
232 for old_sd,sd in l_sd_repl:
233 self.parent.replace_concept_after_etape(self,old_sd,sd)
235 def diff_contextes(self):
237 Réalise la différence entre les 2 contextes
238 old_contexte_fichier_init et contexte_fichier_init
239 cad retourne la liste des sd qui ont disparu ou ne derivent pas
240 de la meme classe et des sd qui ont ete remplacees
242 if not hasattr(self,'old_contexte_fichier_init'):return [],[]
245 for old_key in self.old_contexte_fichier_init.keys():
246 if not self.contexte_fichier_init.has_key(old_key):
247 if isinstance(self.old_contexte_fichier_init[old_key],ASSD):
248 l_sd_suppressed.append(self.old_contexte_fichier_init[old_key])
250 if isinstance(self.old_contexte_fichier_init[old_key],ASSD):
251 # Un concept de meme nom existe
252 old_class=self.old_contexte_fichier_init[old_key].__class__
253 if not isinstance(self.contexte_fichier_init[old_key],old_class):
254 # S'il n'est pas d'une classe derivee, on le supprime
255 l_sd_suppressed.append(self.old_contexte_fichier_init[old_key])
257 l_sd_replaced.append((self.old_contexte_fichier_init[old_key],self.contexte_fichier_init[old_key]))
258 return l_sd_suppressed,l_sd_replaced
260 def control_sdprods(self,d):
262 Cette methode doit verifier que les concepts produits par la
263 commande ne sont pas incompatibles avec le contexte fourni (d).
264 Si c'est le cas, le concept produit doit etre supprime
265 Si la macro a elle meme des etapes, elle doit propager
266 le traitement (voir methode control_jdc_context_apres de I_JDC)
268 #print "I_MACRO_ETAPE.control_sdprods",d.keys(),self.nom,self.sd and self.sd.nom
270 if d.has_key(self.sd.nom):
271 # Le concept est deja defini
272 if self.reuse and self.reuse is d[self.sd.nom]:
273 # Le concept est reutilise : situation normale
276 # Redefinition du concept, on l'annule
277 #XXX on pourrait simplement annuler son nom pour conserver les objets
278 # l'utilisateur n'aurait alors qu'a renommer le concept (faisable??)
281 self.sd=self.reuse=self.sdnom=None
282 self.parent.delete_concept_after_etape(self,sd)
285 # On verifie les concepts a droite du signe =
287 sdprods=self.sdprods[:]
290 if d.has_key(co.nom) and co is not d[co.nom] :
291 #nettoie les mots cles de l'étape qui ont comme valeur co
292 self.delete_concept(co)
293 #supprime les references a co dans les etapes suivantes
294 self.parent.delete_concept_after_etape(self,co)
296 self.sdprods.append(co)
299 for e in self.etapes:
303 def supprime_sdprod(self,sd):
305 Supprime le concept produit sd s'il est produit par l'etape
307 if sd in self.sdprods:
309 self.parent.del_sdprod(sd)
310 self.sdprods.remove(sd)
312 self.parent.delete_concept(sd)
315 if sd is not self.sd :return
316 if self.sd is not None :
318 self.parent.del_sdprod(sd)
321 self.parent.delete_concept(sd)
323 def supprime_sdprods(self):
325 Fonction: Lors de la destruction de la macro-etape, detruit tous les concepts produits
326 Un opérateur n a qu un concept produit
327 Une procedure n'en a aucun
328 Une macro en a en général plus d'un
330 #print "supprime_sdprods"
331 if self.reuse is not self.sd :
332 # l'étape n'est pas réentrante
333 # le concept retourné par l'étape est à supprimer car il était
336 self.parent.del_sdprod(self.sd)
337 self.parent.delete_concept(self.sd)
338 # On détruit les concepts à droite du signe =
339 for co in self.sdprods:
340 self.parent.del_sdprod(co)
341 self.parent.delete_concept(co)
342 # Si la macro a des etapes et des concepts inclus, on les detruit
343 for nom_sd,co in self.g_context.items():
344 if not isinstance(co,ASSD):continue
345 self.parent.del_sdprod(co)
346 self.parent.delete_concept(co)
347 # On met g_context à blanc
352 if hasattr(self,"jdc_aux") and self.jdc_aux:
353 # La macro a un jdc auxiliaire inclus. On demande sa fermeture
356 def reset_context(self):
357 if hasattr(self,"jdc_aux") and self.jdc_aux:
358 # La macro a un jdc auxiliaire inclus. On demande la reinitialisation du contexte
359 self.jdc_aux.reset_context()
361 def update_concept(self,sd):
362 I_ETAPE.ETAPE.update_concept(self,sd)
363 for etape in self.etapes:
364 etape.update_concept(sd)
366 def delete_concept(self,sd):
368 Fonction : Mettre a jour les mots cles de l etape et eventuellement
369 le concept produit si reuse suite à la disparition du concept sd
370 Seuls les mots cles simples MCSIMP font un traitement autre
371 que de transmettre aux fils
373 #print "delete_concept",sd
374 I_ETAPE.ETAPE.delete_concept(self,sd)
375 for etape in self.etapes:
376 etape.delete_concept(sd)
378 def replace_concept(self,old_sd,sd):
380 Fonction : Mettre a jour les mots cles de l etape et le concept produit si reuse
381 suite au remplacement du concept old_sd par sd
383 #print "replace_concept",old_sd,sd
384 I_ETAPE.ETAPE.replace_concept(self,old_sd,sd)
385 for etape in self.etapes:
386 etape.replace_concept(old_sd,sd)
388 def change_fichier_init(self,new_fic,text):
390 Tente de changer le fichier include. Le precedent include est conservé
393 print "change_fichier_init",new_fic
394 if not hasattr(self,'fichier_ini'):
395 self.fichier_ini=None
396 self.fichier_text=None
397 self.fichier_err="Le fichier n'est pas defini"
398 self.contexte_fichier_init={}
399 self.recorded_units={}
401 self.fichier_unite="PasDefini"
402 import Extensions.jdc_include
403 self.JdC_aux=Extensions.jdc_include.JdC_include
405 self.old_fic = self.fichier_ini
407 self.old_text = self.fichier_text
409 self.old_err = self.fichier_err
410 self.old_context=self.contexte_fichier_init
411 print self.old_context
412 self.old_units=self.recorded_units
413 self.old_etapes=self.etapes
414 print self.old_etapes
415 self.old_jdc_aux=self.jdc_aux
417 self.fichier_ini = new_fic
418 self.fichier_text=text
421 self.make_contexte_include(new_fic,text)
423 l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
424 self.fichier_err=string.join(l)
427 # L'evaluation de text dans un JDC auxiliaire s'est bien passé
428 # on peut poursuivre le traitement
430 self.state="undetermined"
431 self.fichier_err=None
432 # On enregistre la modification de fichier
434 # Le contexte du parent doit etre reinitialise car les concepts produits ont changé
435 self.parent.reset_context()
437 # Si des concepts ont disparu lors du changement de fichier, on demande leur suppression
438 self.old_contexte_fichier_init=self.old_context
439 self.reevalue_sd_jdc()
443 self.old_jdc_aux.close()
445 def restore_fichier_init(self):
447 Restaure le fichier init enregistre dans old_xxx
449 self.fichier_ini=self.old_fic
450 self.fichier_text=self.old_text
451 self.fichier_err=self.old_err
452 self.contexte_fichier_init=self.old_context
453 self.recorded_units=self.old_units
454 self.etapes=self.old_etapes
455 self.jdc_aux=self.old_jdc_aux
457 def force_fichier_init(self):
459 Force le remplacement du fichier init meme si le remplacant est en erreur
461 # Reinitialisation complete du compte-rendu d'erreurs
462 self.jdc_aux.cr=self.jdc_aux.CR()
463 # On remplit le dictionnaire des concepts produits inclus
464 # en retirant les concepts présents dans le contexte initial
465 # On ajoute egalement le concept produit dans le sds_dict du parent
466 # sans verification car on est sur (verification integrée) que
467 # le nommage est possible
468 j_context=self.jdc_aux.get_contexte_avant(None)
469 self.g_context.clear()
470 context_ini=self.jdc_aux.context_ini
471 for k,v in j_context.items():
472 if not context_ini.has_key(k) or context_ini[k] != v:
474 self.parent.sds_dict[k]=v
475 # On recupere le contexte courant
476 self.current_context=self.jdc_aux.current_context
477 self.index_etape_courante=self.jdc_aux.index_etape_courante
478 self.contexte_fichier_init = j_context
479 self.fichier_err = None
481 # On enregistre la modification de fichier
483 self.state="undetermined"
485 # Le contexte du parent doit etre reinitialise car les concepts produits ont changé
486 self.parent.reset_context()
488 # On remplace les anciens concepts par les nouveaux (y compris ajouts
489 # et suppression) et on propage les modifications aux etapes precedentes et suivantes
490 # reevalue_sd_jdc construit la liste des differences entre les contextes contexte_fichier_init
491 # et old_contexte_fichier_init et effectue les destructions et remplacements de concept
493 self.old_contexte_fichier_init=self.old_context
494 self.reevalue_sd_jdc()
497 self.old_jdc_aux.close()
499 self.jdc_aux.force_contexte(self.g_context)
501 def build_include(self,fichier,text):
502 import Extensions.jdc_include
503 self.JdC_aux=Extensions.jdc_include.JdC_include
504 # un include partage la table des unites avec son parent (jdc)
505 self.recorded_units=self.parent.recorded_units
506 self.build_jdcaux(fichier,text)
508 def build_poursuite(self,fichier,text):
509 import Extensions.jdc_include
510 self.JdC_aux=Extensions.jdc_include.JdC_poursuite
511 # une poursuite a sa propre table d'unites
512 self.recorded_units={}
513 self.build_jdcaux(fichier,text)
515 def build_jdcaux(self,fichier,text):
517 Cree un jdc auxiliaire initialise avec text.
518 Initialise le nom du fichier associé avec fichier
519 N'enregistre pas d'association unite <-> fichier
521 self.fichier_ini = fichier
522 self.fichier_text= text
523 self.fichier_unite=None
524 self.fichier_err = None
526 contexte = self.get_contexte_jdc(fichier,text)
527 if contexte is None :
528 # Impossible de construire le jdc auxiliaire (sortie par None)
529 # On simule une sortie par exception
530 raise Exception("Impossible de construire le jeu de commandes correspondant au fichier")
532 # La construction du jdc auxiliaire est allée au bout
533 self.contexte_fichier_init = contexte
537 # Impossible de construire le jdc auxiliaire (sortie par exception)
538 l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
540 self.jdc.appli.affiche_alerte("Erreur lors de l'evaluation du fichier inclus",
541 message="Ce fichier ne sera pas pris en compte\n"+string.join(l)
546 self.fichier_err = string.join(l)
547 self.contexte_fichier_init={}
552 def make_contexte_include(self,fichier,text):
554 Cette méthode sert à créer un contexte en interprétant un texte source Python.
556 #print "make_contexte_include",fichier
557 # on récupère le contexte d'un nouveau jdc dans lequel on interprete text
558 contexte = self.get_contexte_jdc(fichier,text)
559 if contexte == None :
560 raise Exception("Impossible de construire le jeu de commandes correspondant au fichier")
562 # Pour les macros de type include : INCLUDE, INCLUDE_MATERIAU et POURSUITE
563 # l'attribut g_context est un dictionnaire qui contient les concepts produits par inclusion
564 # l'attribut contexte_fichier_init est un dictionnaire qui contient les concepts produits
565 # en sortie de macro. g_context est obtenu en retirant de contexte_fichier_init les concepts
566 # existants en debut de macro contenus dans context_ini (dans get_contexte_jdc)
567 # g_context est utilisé pour avoir les concepts produits par la macro
568 # contexte_fichier_init est utilisé pour avoir les concepts supprimés par la macro
569 self.contexte_fichier_init = contexte
571 def reevalue_fichier_init_OBSOLETE(self):
572 """Recalcule les concepts produits par le fichier enregistre"""
573 #print "reevalue_fichier_init"
574 old_context=self.contexte_fichier_init
576 self.make_contexte_include(self.fichier_ini ,self.fichier_text)
578 l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
579 self.fichier_err = string.join(l)
583 self.old_contexte_fichier_init=old_context
584 self.contexte_fichier_init={}
585 self.reevalue_sd_jdc()
588 # L'evaluation s'est bien passee
589 self.fichier_err = None
590 self.old_contexte_fichier_init=old_context
591 self.reevalue_sd_jdc()
593 def update_fichier_init(self,unite):
594 """Reevalue le fichier init sans demander (dans la mesure du possible) a l'utilisateur
595 les noms des fichiers
596 Ceci suppose que les relations entre unites et noms ont été memorisees préalablement
597 L'include a été initialisé précédemment. Le jdc auxiliaire existe.
599 #print "update_fichier_init",unite,self.fichier_unite
600 self.old_contexte_fichier_init=self.contexte_fichier_init
601 old_fichier_ini=self.fichier_ini
602 if not hasattr(self,"jdc_aux"):self.jdc_aux=None
603 old_jdc_aux=self.jdc_aux
605 #print "update_fichier_init",self,self.parent,self.parent.recorded_units
607 if self.fichier_unite is None:
608 # L'unité n'était pas définie précédemment. On ne change que l'unite
609 #print "update_fichier_init","pas de changement dans include"
610 self.fichier_unite=unite
612 elif unite == self.fichier_unite :
613 # L'unité n'a pas changé
614 #print "update_fichier_init","pas de changement dans include 3"
616 elif unite != self.fichier_unite :
617 # L'unité était définie précédemment. On remplace l'include
619 f,text=self.get_file_memo(unite=unite,fic_origine=self.parent.nom)
621 # Le fichier associé n'a pas pu etre defini
622 # on change l'unite associée mais pas l'include
623 #print "update_fichier_init","pas de changement dans include 2"
624 self.fichier_unite=unite
628 self.fichier_text=text
629 self.fichier_unite=unite
630 #print "update_fichier_init",self.recorded_units
632 #print "update_fichier_init",self.fichier_ini,self.fichier_text,self.fichier_unite
634 if old_fichier_ini == self.fichier_ini:
635 # Le fichier inclus n'a pas changé. On ne recrée pas le contexte
636 # mais on enregistre le changement d'association unite <-> fichier
637 #print "update_fichier_init.fichier inchange",self.jdc_aux.context_ini
638 self.parent.record_unit(unite,self)
642 self.fichier_err=None
643 self.make_contexte_include(self.fichier_ini,self.fichier_text)
644 # Les 3 attributs fichier_ini fichier_text recorded_units doivent etre corrects
645 # avant d'appeler change_unit
647 # Erreurs lors de l'evaluation de text dans un JDC auxiliaire
648 l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
649 # On conserve la memoire du nouveau fichier
650 # mais on n'utilise pas les concepts crees par ce fichier
651 # on met l'etape en erreur : fichier_err=string.join(l)
652 self.fichier_err=string.join(l)
656 self.contexte_fichier_init={}
660 self.parent.record_unit(unite,self)
661 # Le contexte du parent doit etre reinitialise car les concepts
662 # produits ont changé
663 self.parent.reset_context()
664 # Si des concepts ont disparu lors du changement de fichier, on
665 # demande leur suppression
666 self.reevalue_sd_jdc()
667 #print "update_fichier_init",self.jdc_aux.context_ini.keys()
669 def record_unite(self):
670 #print "record_unite",self.nom
671 if self.nom == "POURSUITE":
672 self.parent.record_unit(None,self)
674 if hasattr(self,'fichier_unite') :
675 self.parent.record_unit(self.fichier_unite,self)
677 def get_file_memo(self,unite=None,fic_origine=''):
678 """Retourne le nom du fichier et le source correspondant a l'unite unite
679 Initialise en plus recorded_units
681 #print "get_file_memo",unite,fic_origine,self,self.parent
682 #print self.parent.recorded_units
684 # On est dans le cas d'une poursuite. On ne reutilise aucune unite de parent
687 # On est dans le cas d'un include. On reutilise toutes les unites de parent
688 units=self.parent.recorded_units
690 if self.parent.recorded_units.has_key(unite):
691 f,text,units=self.parent.recorded_units[unite]
693 f,text=self.jdc.get_file(unite=unite,fic_origine=fic_origine)
697 self.recorded_units=units
698 if f is None and self.jdc.appli:
699 self.jdc.appli.affiche_alerte("Erreur lors de l'evaluation du fichier inclus",
700 message="Ce fichier ne sera pas pris en compte\n"+"Le fichier associé n'est pas défini")
703 def update_context(self,d):
705 Met à jour le contexte contenu dans le dictionnaire d
706 Une MACRO_ETAPE peut ajouter plusieurs concepts dans le contexte
707 Une fonction enregistree dans op_init peut egalement modifier le contexte
709 #print "update_context",self,self.nom,d.keys()
710 if hasattr(self,"jdc_aux") and self.jdc_aux:
711 #ATTENTION: update_context NE DOIT PAS appeler reset_context
712 # car il appelle directement ou indirectement update_context
713 # equivalent a reset_context. Evite les recursions
714 self.jdc_aux.context_ini=d.copy()
715 self.jdc_aux.current_context={}
716 self.jdc_aux.index_etape_courante=0
717 #ATTENTION: il ne faut pas utiliser self.jdc_aux.get_contexte_avant
718 #car cet appel conduit a des remontées multiples incohérentes dans le
720 #get_context_avant appelle update_context qui NE DOIT PAS appeler get_contexte_avant
721 #On n'a besoin que d'un update local connaissant
722 # le contexte amont : d qui sert a reinitialiser self.context_ini
723 for e in self.etapes:
727 if type(self.definition.op_init) == types.FunctionType:
728 apply(self.definition.op_init,(self,d))
729 if self.sd != None:d[self.sd.nom]=self.sd
730 for co in self.sdprods:
732 #print "update_context.fin",d.keys()
734 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
736 etape=Noyau.N_MACRO_ETAPE.MACRO_ETAPE.copy(self)
737 if hasattr(etape,"etapes") :etape.etapes=[]
738 if hasattr(etape,"jdc_aux") :
740 del etape.fichier_ini
744 #print "supprime",self
745 if hasattr(self,"jdc_aux") and self.jdc_aux:
746 self.jdc_aux.supprime_aux()
748 Noyau.N_MACRO_ETAPE.MACRO_ETAPE.supprime(self)
749 # self.contexte_fichier_init={}
750 # self.old_contexte_fichier_init={}
752 # self.current_context={}
756 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
757 def get_file(self,unite=None,fic_origine=''):
758 """Retourne le nom du fichier et le source correspondant a l'unite unite
761 f,text=self.jdc.get_file(unite=unite,fic_origine=fic_origine)
767 def make_include2(self,fichier=None):
768 # gestion de l unicite SVP
771 if hasattr(self,'fichier_ini') : return
773 if hasattr(self,'old_context_fichier_init' ):
775 for concept in self.old_context_fichier_init.values():
776 self.jdc.delete_concept(concept)
779 fichier=str(self.jdc.appli.get_file_variable())
780 if fichier == str("") :
781 self.fichier_ini="badfile"
783 self.fichier_err="Le fichier n est pas defini"
784 self.parent.record_unit(999,self)
786 MCFils=self.get_child('FileName')
787 MCFils.set_valeur(None)
790 raise Exception(self.fichier_err)
792 self.fichier_ini = fichier
793 self.fichier_text = ""
794 self.contexte_fichier_init={}
795 self.fichier_unite=999
796 self.fichier_err=None
799 from openturns import WrapperFile
800 monWrapper=WrapperFile(fichier)
801 data=monWrapper.getWrapperData()
802 maVariableListe=data.getVariableList()
803 nbVariables=maVariableListe.getSize()
804 for i in range(nbVariables) :
805 nom=maVariableListe[i].id_
806 type=maVariableListe[i].type_
808 #ligneTexte="%s=DETERMINISTICVARIABLE(N='%s',T='out',R=%d);\n" % (nom, nom, i)
810 nbVariableOut=nbVariableOut+1
812 ligneTexte="%s=DETERMINISTICVARIABLE(N='%s',T='in',R=%d);\n" % (nom, nom, i)
813 self.fichier_text = self.fichier_text + ligneTexte
815 self.make_incl2_except()
818 if nbVariableOut != 1 :
819 print nbVariableOut ,"nbVariableOut"
820 self.make_incl2_except(mess="le fichier doit contenir une unique variable de sortie")
824 import Extensions.jdc_include
825 self.JdC_aux=Extensions.jdc_include.JdC_include
827 traceback.print_exc()
828 self.make_incl2_except()
832 self.make_contexte_include(self.fichier_ini ,self.fichier_text)
833 self.old_context_fichier_init=self.contexte_fichier_init
834 self.parent.record_unit(unite,self)
836 MCFils=self.get_child('FileName')
837 MCFils.set_valeur(fichier)
841 self.make_incl2_except()
843 # recalcul validite pour la matrice eventuelle
845 for e in self.jdc.etapes:
846 if e.nom == "VARIABLE" :
849 mc=e.get_child('ModelVariable')
853 if e.nom == "CORRELATION" :
856 mc=e.get_child('Matrix')
858 mcFeuille=mc.get_child('CorrelationMatrix')
859 mcFeuille.state="modified"
864 def make_incl2_except(self,mess=None):
865 l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
868 self.jdc.appli.affiche_alerte("Erreur lors de l'evaluation du fichier inclus",
869 message="Le contenu de ce fichier ne sera pas pris en compte\n"+string.join(l)
872 self.jdc.appli.affiche_alerte("Erreur lors de l'evaluation du fichier inclus",
874 #self.parent.record_unit(unite,self)
878 self.fichier_err = string.join(l)
879 self.contexte_fichier_init={}
881 MCFils=self.get_child('FileName')
882 MCFils.set_valeur(None)
887 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
888 def make_include(self,unite=None):
890 Inclut un fichier dont l'unite logique est unite
891 Cette methode est appelee par la fonction sd_prod de la macro INCLUDE
892 Si l'INCLUDE est invalide, la methode doit produire une exception
893 Sinon on retourne None. Les concepts produits par l'INCLUDE sont
894 pris en compte par le JDC parent lors du calcul du contexte (appel de ???)
896 #print "make_include",unite
897 # On supprime l'attribut unite qui bloque l'evaluation du source de l'INCLUDE
898 # car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini
899 # Si unite n'a pas de valeur, l'etape est forcement invalide. On peut retourner None
900 if not unite : return
902 if not hasattr(self,'fichier_ini') :
903 # Si le fichier n'est pas defini on le demande
904 f,text=self.get_file_memo(unite=unite,fic_origine=self.parent.nom)
905 # On memorise le fichier retourne
907 self.fichier_text = text
908 self.contexte_fichier_init={}
909 self.fichier_unite=unite
910 self.fichier_err=None
912 import Extensions.jdc_include
914 traceback.print_exc()
916 self.JdC_aux=Extensions.jdc_include.JdC_include
918 #print "make_include",self.fichier_ini,self.fichier_text
919 if f is None and not text:
920 self.fichier_err="Le fichier INCLUDE n est pas defini"
921 self.parent.record_unit(unite,self)
922 raise Exception(self.fichier_err)
925 self.make_contexte_include(self.fichier_ini ,self.fichier_text)
926 self.parent.record_unit(unite,self)
928 l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
930 self.jdc.appli.affiche_alerte("Erreur lors de l'evaluation du fichier inclus",
931 message="Le contenu de ce fichier ne sera pas pris en compte\n"+string.join(l)
933 self.parent.record_unit(unite,self)
937 self.fichier_err = string.join(l)
938 self.contexte_fichier_init={}
942 # Si le fichier est deja defini on ne reevalue pas le fichier
943 # et on leve une exception si une erreur a été enregistrée
944 self.update_fichier_init(unite)
945 self.fichier_unite=unite
946 if self.fichier_err is not None: raise Exception(self.fichier_err)
949 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
950 def make_contexte(self,fichier,text):
952 Cette méthode sert à créer un contexte pour INCLUDE_MATERIAU
953 en interprétant un texte source Python
954 Elle est appelee par la fonction sd_prod d'INCLUDE_MATERIAU
956 #print "make_contexte",fichier
957 # On supprime l'attribut mat qui bloque l'evaluation du source de l'INCLUDE_MATERIAU
958 # car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini
959 if hasattr(self,'mat'):del self.mat
960 if not hasattr(self,'fichier_ini') or self.fichier_ini != fichier or self.fichier_mater != self.nom_mater:
961 # le fichier est nouveau ou change
962 self.fichier_ini =fichier
963 self.fichier_unite =fichier
964 self.fichier_mater=self.nom_mater
965 self.fichier_text=text
966 self.fichier_err=None
967 self.contexte_fichier_init={}
968 # On specifie la classe a utiliser pour le JDC auxiliaire
970 import Extensions.jdc_include
971 self.JdC_aux=Extensions.jdc_include.JdC_include
975 self.make_contexte_include(self.fichier_ini ,self.fichier_text)
976 if not self.g_context.has_key(self.nom_mater):
977 #Pour permettre de lire un jeu de commandes avec des INCLUDE_MATERIAU errones
978 self.g_context[self.nom_mater]=None
979 if self.parent: self.parent.g_context[self.nom_mater]=None
981 l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
982 self.fichier_err = string.join(l)
984 #Pour permettre de lire un jeu de commandes avec des INCLUDE_MATERIAU errones
986 self.parent.g_context[self.nom_mater]=None
987 self.g_context[self.nom_mater]=None
991 self.contexte_fichier_init={}
994 # le fichier est le meme on ne le reevalue pas
995 # et on leve une exception si une erreur a été enregistrée
996 if self.fichier_err is not None: raise Exception(self.fichier_err)
998 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
999 def update_sdprod(self,cr='non'):
1000 # Cette methode peut etre appelee dans EFICAS avec des mots cles de
1001 # la commande modifies. Ceci peut conduire a la construction ou
1002 # a la reconstruction d'etapes dans le cas d'INCLUDE ou d'INCLUDE_MATERIAU
1003 # Il faut donc positionner le current_step avant l'appel
1004 CONTEXT.unset_current_step()
1005 CONTEXT.set_current_step(self)
1006 valid=Validation.V_MACRO_ETAPE.MACRO_ETAPE.update_sdprod(self,cr=cr)
1007 CONTEXT.unset_current_step()
1010 #ATTENTION SURCHARGE: cette methode surcharge celle de Noyau a garder en synchro
1011 def Build_sd(self,nom):
1013 Methode de Noyau surchargee pour poursuivre malgre tout
1014 si une erreur se produit pendant la creation du concept produit
1017 sd=Noyau.N_MACRO_ETAPE.MACRO_ETAPE.Build_sd(self,nom)
1018 except AsException,e:
1019 # Une erreur s'est produite lors de la construction du concept
1020 # Comme on est dans EFICAS, on essaie de poursuivre quand meme
1021 # Si on poursuit, on a le choix entre deux possibilités :
1022 # 1. on annule la sd associée à self
1023 # 2. on la conserve mais il faut la retourner
1024 # On choisit de l'annuler
1025 # En plus il faut rendre coherents sdnom et sd.nom
1028 self.state="unchanged"
1033 #ATTENTION SURCHARGE: cette methode surcharge celle de Noyau a garder en synchro
1034 def make_poursuite(self):
1035 """ Cette methode est appelée par la fonction sd_prod de la macro POURSUITE
1037 #print "make_poursuite"
1038 if not hasattr(self,'fichier_ini') :
1039 # Si le fichier n'est pas defini on le demande
1040 f,text=self.get_file_memo(fic_origine=self.parent.nom)
1041 # On memorise le fichier retourne
1042 self.fichier_ini = f
1043 self.fichier_unite = None
1044 self.fichier_text = text
1045 self.fichier_err=None
1047 import Extensions.jdc_include
1049 traceback.print_exc()
1051 self.JdC_aux=Extensions.jdc_include.JdC_poursuite
1052 self.contexte_fichier_init={}
1053 #print "make_poursuite",self.fichier_ini,self.fichier_text
1056 self.fichier_err="Le fichier POURSUITE n'est pas defini"
1058 self.parent.record_unit(None,self)
1059 raise Exception(self.fichier_err)
1062 self.make_contexte_include(self.fichier_ini,self.fichier_text)
1063 self.parent.record_unit(None,self)
1065 l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
1067 self.jdc.appli.affiche_alerte("Erreur lors de l'evaluation du fichier poursuite",
1068 message="Ce fichier ne sera pas pris en compte\n"+string.join(l)
1070 self.parent.record_unit(None,self)
1074 self.fichier_err = string.join(l)
1075 self.contexte_fichier_init={}
1079 # Si le fichier est deja defini on ne reevalue pas le fichier
1080 # et on leve une exception si une erreur a été enregistrée
1081 self.update_fichier_init(None)
1082 if self.fichier_err is not None: raise Exception(self.fichier_err)