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
23 from __future__ import absolute_import
24 from __future__ import print_function
27 import traceback,types
30 from Extensions.i18n import tr
31 from Extensions.eficas_exception import EficasException
33 from . import I_ENTITE
34 from . import I_OBJECT
36 from Noyau.N_ASSD import ASSD
37 from Noyau import N__F
39 from Extensions import param2
41 # import rajoutes suite a l'ajout de Build_sd --> a resorber
42 import Noyau, Validation.V_MACRO_ETAPE
43 from Noyau import N_Exception
44 from Noyau.N_Exception import AsException
45 import Accas # attention aux imports circulaires
47 from six.moves import range
48 # fin import a resorber
50 class MACRO_ETAPE(I_ETAPE.ETAPE):
54 #indique si le jeu de commande inclus a pu etre analyse par convert
55 #pour etre editable (0=NON, 1=OUI)
58 self.recorded_units={}
60 def get_sdprods(self,nom_sd):
62 Fonction : retourne le concept produit par l etape de nom nom_sd
63 s il existe sinon None
65 if self.sd and self.sd.nom == nom_sd :return self.sd
66 for co in self.sdprods:
67 if co.nom == nom_sd:return co
68 if type(self.definition.op_init) == types.FunctionType:
70 self.definition.op_init(*(self,d))
71 return d.get(nom_sd,None)
74 def get_contexte_jdc(self,fichier,text):
76 Interprete text comme un texte de jdc et retourne le contexte final.
78 Le contexte final est le dictionnaire des sd disponibles a la derniere etape.
79 Si text n'est pas un texte de jdc valide, retourne None
81 --> utilisee par ops.POURSUITE et INCLUDE
83 #print ("get_contexte_jdc",self,self.nom)
84 # On recupere l'etape courante
85 step=CONTEXT.get_current_step()
88 # on essaie de creer un objet JDC auxiliaire avec un contexte initial
89 # Attention get_contexte_avant retourne un dictionnaire qui contient
90 # le contexte courant. Ce dictionnaire est reactualise regulierement.
91 # Si on veut garder l'etat du contexte fige, il faut en faire une copie.
92 context_ini = self.parent.get_contexte_avant(self).copy()
93 #print "get_contexte_jdc",context_ini.keys()
95 # Indispensable avant de creer un nouveau JDC
96 CONTEXT.unset_current_step()
99 if hasattr(self,'prefix'):
100 prefix_include=self.prefix
101 # ATTENTION : le dictionnaire recorded_units sert a memoriser les unites des
102 # fichiers inclus. Il est preferable de garder le meme dictionnaire pendant
103 # tout le traitement et de ne pas le reinitialiser brutalement (utiliser
104 # clear plutot) si on ne veut pas perdre la memoire des unites.
105 # En principe si la memorisation est faite au bon moment il n'est pas necessaire
106 # de prendre cette precaution mais ce n'est pas vrai partout.
107 old_recorded_units=self.recorded_units.copy()
109 # on supprime l'ancien jdc_aux s'il existe
110 if hasattr(self,'jdc_aux') and self.jdc_aux:
111 self.jdc_aux.supprime_aux()
113 if fichier is None:fichier="SansNom"
115 # Il faut convertir le texte inclus en fonction du format
116 # sauf les INCLUDE_MATERIAU
117 self.text_converted=0
119 if self.nom != "INCLUDE_MATERIAU":
120 if self.parent.appli.ihm == "QT" :
121 format=self.parent.appli.appliEficas.format_fichier
123 format=self.jdc.appli.format_fichier.get()
124 #on force a python pour Carmel
125 if format=="CARMEL3D" : format="python"
126 if format in convert.plugins :
127 # Le convertisseur existe on l'utilise
128 p=convert.plugins[format]()
130 text=p.convert('exec',self.jdc.appli)
131 #Si le fichier ne peut pas etre converti, le cr n'est pas vide
132 #et le texte est retourne tel que
133 if not p.cr.estvide():
134 self.text_converted=0
135 self.text_error=str(p.cr)
137 self.text_converted=1
140 j=self.JdC_aux( procedure=text, nom=fichier,
141 appli=self.jdc.appli,
143 cata_ord_dico=self.jdc.cata_ordonne_dico,
144 context_ini = context_ini,
145 jdc_pere=self.jdc,etape_include=self,
146 prefix_include=prefix_include,
147 recorded_units=self.recorded_units,
148 old_recorded_units=old_recorded_units,**args)
151 # On recupere les etapes internes (pour validation)
154 self.jdc.jdcDict=self.jdc_aux
158 traceback.print_exc()
159 # On retablit l'etape courante step
160 CONTEXT.unset_current_step()
161 CONTEXT.set_current_step(step)
164 if not j.cr.estvide():
165 # Erreurs dans l'INCLUDE. On garde la memoire du fichier
166 # mais on n'insere pas les concepts
167 # On retablit l'etape courante step
170 CONTEXT.unset_current_step()
171 CONTEXT.set_current_step(step)
172 raise EficasException(tr("Impossible de relire le fichier %s \n ")+ six.text_type(j.cr))
176 # L'INCLUDE n'est pas valide.
177 # on produit un rapport d'erreurs
179 # On retablit l'etape courante step
180 CONTEXT.unset_current_step()
181 CONTEXT.set_current_step(step)
182 self.jdc.cr.fatal("Le fichier include contient des erreurs ")
183 raise EficasException(tr("Le fichier include contient des erreurs "))
186 # Si aucune erreur rencontree
187 # On recupere le contexte de l'include verifie
189 j_context=j.get_verif_contexte()
190 #print j_context.keys()
191 #print j.g_context.keys()
193 # On retablit l'etape courante step
194 CONTEXT.unset_current_step()
195 CONTEXT.set_current_step(step)
196 raise EficasException(" ")
198 # Si on est arrive ici, le texte du fichier inclus (INCLUDE, POURSUITE, ...)
199 # est valide et inserable dans le JDC
201 # On remplit le dictionnaire des concepts produits inclus
202 # en retirant les concepts presents dans le contexte initial
203 # On ajoute egalement le concept produit dans le sds_dict du parent
204 # sans verification car on est sur (verification integree) que
205 # le nommage est possible
206 self.g_context.clear()
207 for k,v in j_context.items():
208 if (not k in context_ini) or (context_ini[k] != v):
210 self.parent.sds_dict[k]=v
212 #Ce traitement n'est realise que dans les cas suivants:
213 # - si convert n'a pas pu convertir le jeu de commandes
214 # - et ce n'est pas un INCLUDE_MATERIAU
215 #On collecte les variables Python qui ne sont pas dans le contexte initial
216 #et dans le contexte valide et on en fait un pseudo-parametre (Variable)
217 if self.text_converted == 0 and self.nom != "INCLUDE_MATERIAU":
218 for k,v in j.g_context.items():
219 if k in context_ini:continue
220 if k in j_context:continue
221 if isinstance(v,ASSD):continue
222 if isinstance(v,I_ENTITE.ENTITE):continue
223 if isinstance(v,I_OBJECT.OBJECT):continue
224 if callable(v):continue
225 self.g_context[k]=param2.Variable(k,v)
227 # On recupere le contexte courant
228 self.current_context=j.current_context
229 self.index_etape_courante=j.index_etape_courante
232 # On retablit l'etape courante step
233 CONTEXT.unset_current_step()
234 CONTEXT.set_current_step(step)
238 def reevalue_sd_jdc(self):
240 Avec la liste des SD qui ont ete supprimees, propage la
241 disparition de ces SD dans toutes les etapes et descendants
243 #print "reevalue_sd_jdc"
244 l_sd_supp,l_sd_repl = self.diff_contextes()
246 self.parent.delete_concept_after_etape(self,sd)
247 for old_sd,sd in l_sd_repl:
248 self.parent.replace_concept_after_etape(self,old_sd,sd)
250 def diff_contextes(self):
252 Realise la difference entre les 2 contextes
253 old_contexte_fichier_init et contexte_fichier_init
254 cad retourne la liste des sd qui ont disparu ou ne derivent pas
255 de la meme classe et des sd qui ont ete remplacees
257 if not hasattr(self,'old_contexte_fichier_init'):return [],[]
260 for old_key in self.old_contexte_fichier_init:
261 if not old_key in self.contexte_fichier_init:
262 if isinstance(self.old_contexte_fichier_init[old_key],ASSD):
263 l_sd_suppressed.append(self.old_contexte_fichier_init[old_key])
265 if isinstance(self.old_contexte_fichier_init[old_key],ASSD):
266 # Un concept de meme nom existe
267 old_class=self.old_contexte_fichier_init[old_key].__class__
268 if not isinstance(self.contexte_fichier_init[old_key],old_class):
269 # S'il n'est pas d'une classe derivee, on le supprime
270 l_sd_suppressed.append(self.old_contexte_fichier_init[old_key])
272 l_sd_replaced.append((self.old_contexte_fichier_init[old_key],self.contexte_fichier_init[old_key]))
273 return l_sd_suppressed,l_sd_replaced
275 def control_sdprods(self,d):
277 Cette methode doit verifier que les concepts produits par la
278 commande ne sont pas incompatibles avec le contexte fourni (d).
279 Si c'est le cas, le concept produit doit etre supprime
280 Si la macro a elle meme des etapes, elle doit propager
281 le traitement (voir methode control_jdc_context_apres de I_JDC)
283 #print ("I_MACRO_ETAPE.control_sdprods",d.keys(),self,self.nom,self.sd and self.sd.nom)
286 # Le concept est deja defini
287 if self.reuse and self.reuse is d[self.sd.nom]:
288 # Le concept est reutilise : situation normale
291 # Redefinition du concept, on l'annule
292 #XXX on pourrait simplement annuler son nom pour conserver les objets
293 # l'utilisateur n'aurait alors qu'a renommer le concept (faisable??)
296 self.sd=self.reuse=self.sdnom=None
297 self.parent.delete_concept_after_etape(self,sd)
300 # On verifie les concepts a droite du signe =
302 sdprods=self.sdprods[:]
305 if co.nom in d and co is not d[co.nom] :
306 #nettoie les mots cles de l'etape qui ont comme valeur co
307 self.delete_concept(co)
308 #supprime les references a co dans les etapes suivantes
309 self.parent.delete_concept_after_etape(self,co)
311 self.sdprods.append(co)
314 for e in self.etapes:
318 def supprime_sdprod(self,sd):
320 Supprime le concept produit sd s'il est produit par l'etape
322 if sd in self.sdprods:
324 self.parent.del_sdprod(sd)
325 self.sdprods.remove(sd)
327 self.parent.delete_concept(sd)
330 if sd is not self.sd :return
331 if self.sd is not None :
333 self.parent.del_sdprod(sd)
336 self.parent.delete_concept(sd)
338 def supprime_sdprods(self):
340 Fonction: Lors de la destruction de la macro-etape, detruit tous les concepts produits
341 Un operateur n a qu un concept produit
342 Une procedure n'en a aucun
343 Une macro en a en general plus d'un
345 #print "supprime_sdprods"
346 if self.reuse is not self.sd :
347 # l'etape n'est pas reentrante
348 # le concept retourne par l'etape est a supprimer car il etait
351 self.parent.del_sdprod(self.sd)
352 self.parent.delete_concept(self.sd)
353 # On detruit les concepts a droite du signe =
354 for co in self.sdprods:
355 self.parent.del_sdprod(co)
356 self.parent.delete_concept(co)
357 # Si la macro a des etapes et des concepts inclus, on les detruit
358 for nom_sd,co in self.g_context.items():
359 if not isinstance(co,ASSD):continue
360 self.parent.del_sdprod(co)
361 self.parent.delete_concept(co)
362 # On met g_context a blanc
367 if hasattr(self,"jdc_aux") and self.jdc_aux:
368 # La macro a un jdc auxiliaire inclus. On demande sa fermeture
371 def reset_context(self):
372 if hasattr(self,"jdc_aux") and self.jdc_aux:
373 # La macro a un jdc auxiliaire inclus. On demande la reinitialisation du contexte
374 self.jdc_aux.reset_context()
376 def update_concept(self,sd):
377 I_ETAPE.ETAPE.update_concept(self,sd)
378 for etape in self.etapes:
379 etape.update_concept(sd)
381 def delete_concept(self,sd):
383 Fonction : Mettre a jour les mots cles de l etape et eventuellement
384 le concept produit si reuse suite a la disparition du concept sd
385 Seuls les mots cles simples MCSIMP font un traitement autre
386 que de transmettre aux fils
388 #print "delete_concept",sd
389 I_ETAPE.ETAPE.delete_concept(self,sd)
390 for etape in self.etapes:
391 etape.delete_concept(sd)
393 def replace_concept(self,old_sd,sd):
395 Fonction : Mettre a jour les mots cles de l etape et le concept produit si reuse
396 suite au remplacement du concept old_sd par sd
398 #print "replace_concept",old_sd,sd
399 I_ETAPE.ETAPE.replace_concept(self,old_sd,sd)
400 for etape in self.etapes:
401 etape.replace_concept(old_sd,sd)
403 def change_fichier_init(self,new_fic,text):
405 Tente de changer le fichier include. Le precedent include est conserve
408 if not hasattr(self,'fichier_ini'):
409 self.fichier_ini=None
410 self.fichier_text=None
411 self.fichier_err="Le fichier n'est pas defini"
412 self.contexte_fichier_init={}
413 self.recorded_units={}
415 self.fichier_unite="PasDefini"
416 import Extensions.jdc_include
417 self.JdC_aux=Extensions.jdc_include.JdC_include
419 self.old_fic = self.fichier_ini
420 self.old_text = self.fichier_text
421 self.old_err = self.fichier_err
422 self.old_context=self.contexte_fichier_init
423 self.old_units=self.recorded_units
424 self.old_etapes=self.etapes
425 self.old_jdc_aux=self.jdc_aux
427 self.fichier_ini = new_fic
428 self.fichier_text=text
431 self.make_contexte_include(new_fic,text)
433 l=traceback.format_exception_only(tr("Fichier invalide %s", sys.exc_info()[1]))
434 self.fichier_err=''.join(l)
435 raise EficasException(self.fichier_err)
437 # L'evaluation de text dans un JDC auxiliaire s'est bien passe
438 # on peut poursuivre le traitement
440 self.state="undetermined"
441 self.fichier_err=None
442 # On enregistre la modification de fichier
444 # Le contexte du parent doit etre reinitialise car les concepts produits ont change
445 self.parent.reset_context()
447 # Si des concepts ont disparu lors du changement de fichier, on demande leur suppression
448 self.old_contexte_fichier_init=self.old_context
449 self.reevalue_sd_jdc()
453 self.old_jdc_aux.close()
455 def restore_fichier_init(self):
457 Restaure le fichier init enregistre dans old_xxx
459 self.fichier_ini=self.old_fic
460 self.fichier_text=self.old_text
461 self.fichier_err=self.old_err
462 self.contexte_fichier_init=self.old_context
463 self.recorded_units=self.old_units
464 self.etapes=self.old_etapes
465 self.jdc_aux=self.old_jdc_aux
467 def force_fichier_init(self):
469 Force le remplacement du fichier init meme si le remplacant est en erreur
471 # Reinitialisation complete du compte-rendu d'erreurs
472 self.jdc_aux.cr=self.jdc_aux.CR()
473 # On remplit le dictionnaire des concepts produits inclus
474 # en retirant les concepts presents dans le contexte initial
475 # On ajoute egalement le concept produit dans le sds_dict du parent
476 # sans verification car on est sur (verification integree) que
477 # le nommage est possible
478 j_context=self.jdc_aux.get_contexte_avant(None)
479 self.g_context.clear()
480 context_ini=self.jdc_aux.context_ini
481 for k,v in j_context.items():
482 if not k in context_ini or context_ini[k] != v:
484 self.parent.sds_dict[k]=v
485 # On recupere le contexte courant
486 self.current_context=self.jdc_aux.current_context
487 self.index_etape_courante=self.jdc_aux.index_etape_courante
488 self.contexte_fichier_init = j_context
489 self.fichier_err = None
491 # On enregistre la modification de fichier
493 self.state="undetermined"
495 # Le contexte du parent doit etre reinitialise car les concepts produits ont change
496 self.parent.reset_context()
498 # On remplace les anciens concepts par les nouveaux (y compris ajouts
499 # et suppression) et on propage les modifications aux etapes precedentes et suivantes
500 # reevalue_sd_jdc construit la liste des differences entre les contextes contexte_fichier_init
501 # et old_contexte_fichier_init et effectue les destructions et remplacements de concept
503 self.old_contexte_fichier_init=self.old_context
504 self.reevalue_sd_jdc()
507 self.old_jdc_aux.close()
509 self.jdc_aux.force_contexte(self.g_context)
511 def build_include(self,fichier,text):
512 import Extensions.jdc_include
513 self.JdC_aux=Extensions.jdc_include.JdC_include
514 # un include partage la table des unites avec son parent (jdc)
515 self.recorded_units=self.parent.recorded_units
516 self.build_jdcaux(fichier,text)
518 def build_poursuite(self,fichier,text):
519 import Extensions.jdc_include
520 self.JdC_aux=Extensions.jdc_include.JdC_poursuite
521 # une poursuite a sa propre table d'unites
522 self.recorded_units={}
523 self.build_jdcaux(fichier,text)
526 def build_includeInclude(self,text):
527 import Extensions.jdc_include
528 self.JdC_aux=Extensions.jdc_include.JdC_include
529 # un include partage la table des unites avec son parent (jdc)
530 self.build_jdcauxInclude(text)
534 def build_includeEtape(self,text):
535 import Extensions.jdc_include
536 self.JdC_aux=Extensions.jdc_include.JdC_include
537 # un include partage la table des unites avec son parent (jdc)
538 #self.build_jdcauxInclude(text)
539 # Attention fonctionne pour import_Zone de MT
540 # a adapter eventuellement
542 contexte = self.get_contexte_jdc(None,text)
543 except EficasException:
546 for e in self.etapes:
550 index=self.jdc.etapes.index(self)
551 self.jdc.etapes=self.jdc.etapes[:index+1]+self.etapes+self.jdc.etapes[index+1:]
555 self.jdc.reset_context()
557 CONTEXT.unset_current_step()
561 def build_jdcauxInclude(self,text):
564 contexte = self.get_contexte_jdc(None,text)
565 except EficasException:
567 index=self.jdc.etapes.index(self)
568 for e in self.etapes:
570 self.jdc.etapes=self.jdc.etapes[:index+1]+self.etapes+self.jdc.etapes[index+1:]
574 CONTEXT.unset_current_step()
576 def build_jdcaux(self,fichier,text):
578 Cree un jdc auxiliaire initialise avec text.
579 Initialise le nom du fichier associe avec fichier
580 N'enregistre pas d'association unite <-> fichier
582 self.fichier_ini = fichier
583 self.fichier_text= text
584 self.fichier_unite=None
585 self.fichier_err = None
587 contexte = self.get_contexte_jdc(fichier,text)
588 if contexte is None :
589 # Impossible de construire le jdc auxiliaire (sortie par None)
590 # On simule une sortie par exception
591 raise EficasException(tr("Impossible de construire le jeu de commandes correspondant au fichier"))
593 # La construction du jdc auxiliaire est allee au bout
594 self.contexte_fichier_init = contexte
598 # Impossible de construire le jdc auxiliaire (sortie par exception)
599 l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
600 if self.jdc.appli is not None:
601 self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
602 message= tr("Ce fichier ne sera pas pris en compte\n %s",''.join(l)))
607 self.fichier_err = ''.join(l)
608 self.contexte_fichier_init={}
611 raise EficasException(" ")
613 def make_contexte_include(self,fichier,text):
615 Cette methode sert a craer un contexte en interpratant un texte source Python.
617 print ("make_contexte_include",fichier)
618 # on recupere le contexte d'un nouveau jdc dans lequel on interprete text
619 contexte = self.get_contexte_jdc(fichier,text)
620 print ("make_contexte_include",fichier)
621 if contexte == None :
622 raise EficasException("Impossible de construire le jeu de commandes correspondant au fichier")
624 # Pour les macros de type include : INCLUDE, INCLUDE_MATERIAU et POURSUITE
625 # l'attribut g_context est un dictionnaire qui contient les concepts produits par inclusion
626 # l'attribut contexte_fichier_init est un dictionnaire qui contient les concepts produits
627 # en sortie de macro. g_context est obtenu en retirant de contexte_fichier_init les concepts
628 # existants en debut de macro contenus dans context_ini (dans get_contexte_jdc)
629 # g_context est utilise pour avoir les concepts produits par la macro
630 # contexte_fichier_init est utilise pour avoir les concepts supprimes par la macro
631 self.contexte_fichier_init = contexte
632 print ("fin make_contexte_include",fichier)
634 def reevalue_fichier_init_OBSOLETE(self):
635 """Recalcule les concepts produits par le fichier enregistre"""
636 #print "reevalue_fichier_init"
637 old_context=self.contexte_fichier_init
639 self.make_contexte_include(self.fichier_ini ,self.fichier_text)
641 l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
642 self.fichier_err = ''.join(l)
646 self.old_contexte_fichier_init=old_context
647 self.contexte_fichier_init={}
648 self.reevalue_sd_jdc()
651 # L'evaluation s'est bien passee
652 self.fichier_err = None
653 self.old_contexte_fichier_init=old_context
654 self.reevalue_sd_jdc()
656 def update_fichier_init(self,unite):
657 """Reevalue le fichier init sans demander (dans la mesure du possible) a l'utilisateur
658 les noms des fichiers
659 Ceci suppose que les relations entre unites et noms ont ete memorisees prealablement
660 L'include a ete initialise precedemment. Le jdc auxiliaire existe.
662 #print "update_fichier_init",unite,self.fichier_unite
663 self.old_contexte_fichier_init=self.contexte_fichier_init
664 old_fichier_ini=self.fichier_ini
665 if not hasattr(self,"jdc_aux"):self.jdc_aux=None
666 old_jdc_aux=self.jdc_aux
668 #print "update_fichier_init",self,self.parent,self.parent.recorded_units
670 if self.fichier_unite is None:
671 # L'unite n'etait pas definie precedemment. On ne change que l'unite
672 #print "update_fichier_init","pas de changement dans include"
673 self.fichier_unite=unite
675 elif unite == self.fichier_unite :
676 # L'unite n'a pas change
677 #print "update_fichier_init","pas de changement dans include 3"
679 elif unite != self.fichier_unite :
680 # L'unite etait definie precedemment. On remplace l'include
682 f,text=self.get_file_memo(unite=unite,fic_origine=self.parent.nom)
684 # Le fichier associe n'a pas pu etre defini
685 # on change l'unite associee mais pas l'include
686 #print "update_fichier_init","pas de changement dans include 2"
687 self.fichier_unite=unite
691 self.fichier_text=text
692 self.fichier_unite=unite
693 #print "update_fichier_init",self.recorded_units
695 #print "update_fichier_init",self.fichier_ini,self.fichier_text,self.fichier_unite
697 if old_fichier_ini == self.fichier_ini:
698 # Le fichier inclus n'a pas change. On ne recree pas le contexte
699 # mais on enregistre le changement d'association unite <-> fichier
700 #print "update_fichier_init.fichier inchange",self.jdc_aux.context_ini
701 self.parent.record_unit(unite,self)
705 self.fichier_err=None
706 self.make_contexte_include(self.fichier_ini,self.fichier_text)
707 # Les 3 attributs fichier_ini fichier_text recorded_units doivent etre corrects
708 # avant d'appeler change_unit
710 # Erreurs lors de l'evaluation de text dans un JDC auxiliaire
711 l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
712 # On conserve la memoire du nouveau fichier
713 # mais on n'utilise pas les concepts crees par ce fichier
714 # on met l'etape en erreur : fichier_err=''.join(l)
715 self.fichier_err=''.join(l)
719 self.contexte_fichier_init={}
723 self.parent.record_unit(unite,self)
724 # Le contexte du parent doit etre reinitialise car les concepts
725 # produits ont change
726 self.parent.reset_context()
727 # Si des concepts ont disparu lors du changement de fichier, on
728 # demande leur suppression
729 self.reevalue_sd_jdc()
730 #print "update_fichier_init",self.jdc_aux.context_ini.keys()
732 def record_unite(self):
733 #print "record_unite",self.nom
734 if self.nom == "POURSUITE":
735 self.parent.record_unit(None,self)
737 if hasattr(self,'fichier_unite') :
738 self.parent.record_unit(self.fichier_unite,self)
740 def get_file_memo(self, unite=None, fname=None, fic_origine=''):
741 """Retourne le nom du fichier et le source correspondant a l'unite unite
742 Initialise en plus recorded_units
744 #print "get_file_memo",unite,fic_origine,self,self.parent
745 #print self.parent.recorded_units
747 # On est dans le cas d'une poursuite. On ne reutilise aucune unite de parent
750 # On est dans le cas d'un include. On reutilise toutes les unites de parent
751 units=self.parent.recorded_units
753 if unite in self.parent.recorded_units:
754 f,text,units=self.parent.recorded_units[unite]
757 if not osp.exists(fname):
758 raise AsException(fname + tr(" n'est pas un fichier existant"))
760 text = open(fname, 'r').read()
762 f,text=self.jdc.get_file(unite=unite, fic_origine=fic_origine)
766 self.recorded_units=units
767 if f is None and self.jdc.appli:
768 self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
769 message= tr("Ce fichier ne sera pas pris en compte\nLe fichier associe n'est pas defini"))
772 def update_context(self,d):
774 Met a jour le contexte contenu dans le dictionnaire d
775 Une MACRO_ETAPE peut ajouter plusieurs concepts dans le contexte
776 Une fonction enregistree dans op_init peut egalement modifier le contexte
778 #print ("update_context",self,self.nom,d.keys())
779 if hasattr(self,"jdc_aux") and self.jdc_aux:
780 #ATTENTION: update_context NE DOIT PAS appeler reset_context
781 # car il appelle directement ou indirectement update_context
782 # equivalent a reset_context. Evite les recursions
783 self.jdc_aux.context_ini=d.copy()
784 self.jdc_aux.current_context={}
785 self.jdc_aux.index_etape_courante=0
786 #ATTENTION: il ne faut pas utiliser self.jdc_aux.get_contexte_avant
787 #car cet appel conduit a des remontees multiples incoherentes dans le
789 #get_context_avant appelle update_context qui NE DOIT PAS appeler get_contexte_avant
790 #On n'a besoin que d'un update local connaissant
791 # le contexte amont : d qui sert a reinitialiser self.context_ini
792 for e in self.etapes:
796 if type(self.definition.op_init) == types.FunctionType:
797 self.definition.op_init(*(self,d))
798 if self.sd != None :d[self.sd.nom]=self.sd
799 for co in self.sdprods:
801 #print "update_context.fin",d.keys()
803 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
805 etape=Noyau.N_MACRO_ETAPE.MACRO_ETAPE.copy(self)
806 if hasattr(etape,"etapes") :etape.etapes=[]
807 if hasattr(etape,"jdc_aux") :
809 del etape.fichier_ini
813 #print "supprime",self
814 if hasattr(self,"jdc_aux") and self.jdc_aux:
815 self.jdc_aux.supprime_aux()
817 Noyau.N_MACRO_ETAPE.MACRO_ETAPE.supprime(self)
819 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
820 def get_file(self,unite=None,fic_origine=''):
821 """Retourne le nom du fichier et le source correspondant a l'unite unite
824 f,text=self.jdc.get_file(unite=unite,fic_origine=fic_origine)
830 def make_include3(self,fichier=None):
831 self.make_includeCarmel(fichier)
834 def make_includeCND(self,fichier=None):
836 if fichier==None : return
837 if hasattr(self,'fichier_ini') : print((self.fichier_ini))
838 if hasattr(self,'fichier_ini') : return
839 self.fichier_ini=fichier
840 from acquiertGroupes import getGroupes
841 erreur,listeGroupes=getGroupes(fichier)
842 if erreur != "" : print ("a traiter")
847 for groupe in listeGroupes :
848 if groupe[0:8]=='CURRENT_': texteSources +=groupe[8:]+"=SOURCE();\n"
849 if groupe[0:5]=='COND_': texteCond +=groupe[5:]+"=CONDUCTEUR();\n"
850 if groupe[0:7]=='NOCOND_': texteNoCond +=groupe[7:]+"=NOCOND();\n"
851 #if groupe[0:5]=='VCUT_': texteVcut +=groupe[5:]+"=VCUT();\n"
852 if groupe[0:5]=='VCUT_': texteVcut +='V_'+groupe[5:]+"=VCUT();\n"
853 texte=texteSources+texteCond+texteNoCond+texteVcut
855 self.build_includeInclude(texte)
856 if CONTEXT.get_current_step()==None : CONTEXT.set_current_step(self)
859 def make_includeCarmel(self,fichier=None):
861 #print "je suis dans make_includeCarmel"
863 if hasattr(self,'fichier_ini') : return
865 if hasattr(self,'old_context_fichier_init' ):
867 for concept in self.old_context_fichier_init.values():
868 self.jdc.delete_concept(concept)
870 fichier=str(self.jdc.appli.get_file_dictDonnees())
871 if fichier == str("") :
872 self.fichier_ini="badfile"
874 self.fichier_err=tr("Le fichier n est pas defini")
875 self.parent.record_unit(999,self)
877 MCFils=self.get_child('FileName')
878 MCFils.set_valeur(None)
881 raise EficasException(self.fichier_err)
882 self.fichier_ini = fichier
883 f=open(self.fichier_ini,'r')
884 self.fichier_text=f.read()
887 self.contexte_fichier_init={}
888 self.fichier_unite=999
889 self.fichier_err=None
893 import Extensions.jdc_include
894 self.JdC_aux=Extensions.jdc_include.JdC_include
897 traceback.print_exc()
898 self.make_incl2_except()
899 raise EficasException(" ")
903 self.make_contexte_include(self.fichier_ini ,self.fichier_text)
904 self.old_context_fichier_init=self.contexte_fichier_init
905 self.parent.record_unit(unite,self)
907 MCFils=self.get_child('FileName')
908 #MCFils.set_valeur(fichier)
909 #on appelle pas set_valeur qui modifie le contexte ce qui fout le bazar
910 #pas de modification de bloc
911 MCFils.valeur=fichier
917 self.make_incl2_except()
918 # Cette P*** de ligne suivante ne fonctionne que pour Aster
919 # si quelqu un a une idee merci de m en parler
920 #CONTEXT.set_current_step(self)
922 def make_include2(self,fichier=None):
924 # gestion de l unicite SVP
927 if hasattr(self,'fichier_ini') : return
929 if hasattr(self,'old_context_fichier_init' ):
931 for concept in self.old_context_fichier_init.values():
932 self.jdc.delete_concept(concept)
935 fichier=str(self.jdc.appli.get_file_variable())
936 if fichier == str("") :
937 self.fichier_ini="badfile"
939 self.fichier_err=tr("Le fichier n est pas defini")
940 self.parent.record_unit(999,self)
942 MCFils=self.get_child('FileName')
943 MCFils.set_valeur(None)
946 raise EficasException(self.fichier_err)
948 self.fichier_ini = fichier
949 self.fichier_text = ""
950 self.contexte_fichier_init={}
951 self.fichier_unite=999
952 self.fichier_err=None
955 from openturns import WrapperFile
956 monWrapper=WrapperFile(fichier)
957 data=monWrapper.getWrapperData()
958 maVariableListe=data.getVariableList()
959 nbVariables=maVariableListe.getSize()
960 for i in range(nbVariables) :
961 nom=maVariableListe[i].id_
962 type=maVariableListe[i].type_
964 #ligneTexte="%s=DETERMINISTICVARIABLE(N='%s',T='out',R=%d);\n" % (nom, nom, i)
966 nbVariableOut=nbVariableOut+1
968 ligneTexte="%s=DETERMINISTICVARIABLE(N='%s',T='in',R=%d);\n" % (nom, nom, i)
969 self.fichier_text = self.fichier_text + ligneTexte
971 self.make_incl2_except()
972 raise EficasException(" ")
974 if nbVariableOut != 1 :
975 print((nbVariableOut ,"nbVariableOut"))
976 self.make_incl2_except(mess=tr("le fichier doit contenir une unique variable de sortie"))
977 raise EficasException(" ")
980 import Extensions.jdc_include
981 self.JdC_aux=Extensions.jdc_include.JdC_include
983 traceback.print_exc()
984 self.make_incl2_except()
985 raise EficasException(" ")
988 print((self.fichier_ini ,self.fichier_text))
989 self.make_contexte_include(self.fichier_ini ,self.fichier_text)
990 self.old_context_fichier_init=self.contexte_fichier_init
991 self.parent.record_unit(unite,self)
993 MCFils=self.get_child('FileName')
994 MCFils.set_valeur(fichier)
998 self.make_incl2_except()
1000 # recalcul validite pour la matrice eventuelle
1002 for e in self.jdc.etapes:
1003 if e.nom == "VARIABLE" :
1006 mc=e.get_child('ModelVariable')
1010 if e.nom == "CORRELATION" :
1013 mc=e.get_child('Matrix')
1015 mcFeuille=mc.get_child('CorrelationMatrix')
1016 mcFeuille.state="modified"
1021 def make_incl2_except(self,mess=None):
1022 l=traceback.format_exception_only(tr("Fichier invalide"),sys.exc_info()[1])
1023 if self.jdc.appli is not None:
1025 self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
1026 message= tr("Le contenu de ce fichier ne sera pas pris en compte\n %s",\
1030 self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
1032 #self.parent.record_unit(unite,self)
1036 self.fichier_err = ''.join(l)
1037 self.contexte_fichier_init={}
1039 MCFils=self.get_child('FileName')
1040 MCFils.set_valeur(None)
1045 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
1046 def make_include(self, unite=None, fname=None):
1048 Inclut un fichier dont l'unite logique est unite
1049 Cette methode est appelee par la fonction sd_prod de la macro INCLUDE
1050 Si l'INCLUDE est invalide, la methode doit produire une exception
1051 Sinon on retourne None. Les concepts produits par l'INCLUDE sont
1052 pris en compte par le JDC parent lors du calcul du contexte (appel de ???)
1054 #print "make_include",unite
1055 # On supprime l'attribut unite qui bloque l'evaluation du source de l'INCLUDE
1056 # car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini
1057 # Si unite n'a pas de valeur, l'etape est forcement invalide. On peut retourner None
1058 if not unite and not fname:
1061 if not hasattr(self,'fichier_ini') :
1062 # Si le fichier n'est pas defini on le demande
1063 f,text=self.get_file_memo(unite=unite, fname=fname, fic_origine=self.parent.nom)
1064 # On memorise le fichier retourne
1065 self.fichier_ini = f
1066 self.fichier_text = text
1067 self.contexte_fichier_init={}
1068 self.fichier_unite=unite
1069 self.fichier_err=None
1071 import Extensions.jdc_include
1073 traceback.print_exc()
1074 raise EficasException("pb import Extensions")
1075 self.JdC_aux=Extensions.jdc_include.JdC_include
1077 #print "make_include",self.fichier_ini,self.fichier_text
1078 if f is None and not text:
1079 self.fichier_err=tr("Le fichier INCLUDE n est pas defini")
1080 self.parent.record_unit(unite,self)
1081 raise EficasException(self.fichier_err)
1084 self.make_contexte_include(self.fichier_ini ,self.fichier_text)
1085 self.parent.record_unit(unite,self)
1087 l=traceback.format_exception_only(tr("Fichier invalide %s",sys.exc_info()[1]))
1089 self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
1090 message=tr("Le contenu de ce fichier ne sera pas pris en compte\n"+''.join(l)))
1091 self.parent.record_unit(unite,self)
1095 self.fichier_err = ''.join(l)
1096 self.contexte_fichier_init={}
1097 raise EficasException(" ")
1100 # Si le fichier est deja defini on ne reevalue pas le fichier
1101 # et on leve une exception si une erreur a ete enregistree
1102 self.update_fichier_init(unite)
1103 self.fichier_unite=unite
1104 if self.fichier_err is not None: raise EficasException(self.fichier_err)
1107 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
1108 def make_contexte(self,fichier,text):
1110 Cette methode sert a creer un contexte pour INCLUDE_MATERIAU
1111 en interpretant un texte source Python
1112 Elle est appelee par la fonction sd_prod d'INCLUDE_MATERIAU
1114 #print "make_contexte",fichier
1115 # On supprime l'attribut mat qui bloque l'evaluation du source de l'INCLUDE_MATERIAU
1116 # car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini
1117 if hasattr(self,'mat'):del self.mat
1118 if not hasattr(self,'fichier_ini') or self.fichier_ini != fichier or self.fichier_mater != self.nom_mater:
1119 # le fichier est nouveau ou change
1120 self.fichier_ini =fichier
1121 self.fichier_unite =fichier
1122 self.fichier_mater=self.nom_mater
1123 self.fichier_text=text
1124 self.fichier_err=None
1125 self.contexte_fichier_init={}
1126 # On specifie la classe a utiliser pour le JDC auxiliaire
1128 import Extensions.jdc_include
1129 self.JdC_aux=Extensions.jdc_include.JdC_include
1131 raise EficasException(" ")
1133 self.make_contexte_include(self.fichier_ini ,self.fichier_text)
1134 if not self.nom_mater in self.g_context :
1135 #Pour permettre de lire un jeu de commandes avec des INCLUDE_MATERIAU errones
1136 self.g_context[self.nom_mater]=None
1137 if self.parent: self.parent.g_context[self.nom_mater]=None
1139 l=traceback.format_exception_only(tr("Fichier invalide %s",sys.exc_info()[1]))
1140 self.fichier_err = ''.join(l)
1142 #Pour permettre de lire un jeu de commandes avec des INCLUDE_MATERIAU errones
1144 self.parent.g_context[self.nom_mater]=None
1145 self.g_context[self.nom_mater]=None
1149 self.contexte_fichier_init={}
1150 raise EficasException(" ")
1152 # le fichier est le meme on ne le reevalue pas
1153 # et on leve une exception si une erreur a ete enregistree
1154 if self.fichier_err is not None: raise EficasException(self.fichier_err)
1156 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
1157 def update_sdprod(self,cr='non'):
1158 # Cette methode peut etre appelee dans EFICAS avec des mots cles de
1159 # la commande modifies. Ceci peut conduire a la construction ou
1160 # a la reconstruction d'etapes dans le cas d'INCLUDE ou d'INCLUDE_MATERIAU
1161 # Il faut donc positionner le current_step avant l'appel
1162 CONTEXT.unset_current_step()
1163 CONTEXT.set_current_step(self)
1164 valid=Validation.V_MACRO_ETAPE.MACRO_ETAPE.update_sdprod(self,cr=cr)
1165 CONTEXT.unset_current_step()
1168 #ATTENTION SURCHARGE: cette methode surcharge celle de Noyau a garder en synchro
1169 def Build_sd(self,nom):
1171 Methode de Noyau surchargee pour poursuivre malgre tout
1172 si une erreur se produit pendant la creation du concept produit
1175 sd=Noyau.N_MACRO_ETAPE.MACRO_ETAPE.Build_sd(self,nom)
1178 #except AsException,e:
1179 # Une erreur s'est produite lors de la construction du concept
1180 # Comme on est dans EFICAS, on essaie de poursuivre quand meme
1181 # Si on poursuit, on a le choix entre deux possibilites :
1182 # 1. on annule la sd associee a self
1183 # 2. on la conserve mais il faut la retourner
1184 # On choisit de l'annuler
1185 # En plus il faut rendre coherents sdnom et sd.nom
1188 self.state="unchanged"
1193 #ATTENTION SURCHARGE: cette methode surcharge celle de Noyau a garder en synchro
1194 def make_poursuite(self):
1195 """ Cette methode est appelee par la fonction sd_prod de la macro POURSUITE
1197 #print "make_poursuite"
1198 if not hasattr(self,'fichier_ini') :
1199 # Si le fichier n'est pas defini on le demande
1200 f,text=self.get_file_memo(fic_origine=self.parent.nom)
1201 # On memorise le fichier retourne
1202 self.fichier_ini = f
1203 self.fichier_unite = None
1204 self.fichier_text = text
1205 self.fichier_err=None
1207 import Extensions.jdc_include
1209 traceback.print_exc()
1210 raise EficasException(" ")
1211 self.JdC_aux=Extensions.jdc_include.JdC_poursuite
1212 self.contexte_fichier_init={}
1213 #print "make_poursuite",self.fichier_ini,self.fichier_text
1216 self.fichier_err="Le fichier POURSUITE n'est pas defini"
1218 self.parent.record_unit(None,self)
1219 raise EficasException(self.fichier_err)
1222 self.make_contexte_include(self.fichier_ini,self.fichier_text)
1223 self.parent.record_unit(None,self)
1225 l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
1227 self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier poursuite"),
1228 message=tr("Ce fichier ne sera pas pris en compte\n %s",''.join(l)))
1229 self.parent.record_unit(None,self)
1233 self.fichier_err = ''.join(l)
1234 self.contexte_fichier_init={}
1235 raise EficasException(" ")
1238 # Si le fichier est deja defini on ne reevalue pas le fichier
1239 # et on leve une exception si une erreur a ete enregistree
1240 self.update_fichier_init(None)
1241 if self.fichier_err is not None: raise EficasException(self.fichier_err)