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 print ('kljkljkljlkjklj')
228 # On recupere le contexte courant
229 self.current_context=j.current_context
230 self.index_etape_courante=j.index_etape_courante
233 # On retablit l'etape courante step
234 CONTEXT.unset_current_step()
235 CONTEXT.set_current_step(step)
237 print ('kljkljkljlkjklj')
240 def reevalue_sd_jdc(self):
242 Avec la liste des SD qui ont ete supprimees, propage la
243 disparition de ces SD dans toutes les etapes et descendants
245 #print "reevalue_sd_jdc"
246 l_sd_supp,l_sd_repl = self.diff_contextes()
248 self.parent.delete_concept_after_etape(self,sd)
249 for old_sd,sd in l_sd_repl:
250 self.parent.replace_concept_after_etape(self,old_sd,sd)
252 def diff_contextes(self):
254 Realise la difference entre les 2 contextes
255 old_contexte_fichier_init et contexte_fichier_init
256 cad retourne la liste des sd qui ont disparu ou ne derivent pas
257 de la meme classe et des sd qui ont ete remplacees
259 if not hasattr(self,'old_contexte_fichier_init'):return [],[]
262 for old_key in self.old_contexte_fichier_init:
263 if not old_key in self.contexte_fichier_init:
264 if isinstance(self.old_contexte_fichier_init[old_key],ASSD):
265 l_sd_suppressed.append(self.old_contexte_fichier_init[old_key])
267 if isinstance(self.old_contexte_fichier_init[old_key],ASSD):
268 # Un concept de meme nom existe
269 old_class=self.old_contexte_fichier_init[old_key].__class__
270 if not isinstance(self.contexte_fichier_init[old_key],old_class):
271 # S'il n'est pas d'une classe derivee, on le supprime
272 l_sd_suppressed.append(self.old_contexte_fichier_init[old_key])
274 l_sd_replaced.append((self.old_contexte_fichier_init[old_key],self.contexte_fichier_init[old_key]))
275 return l_sd_suppressed,l_sd_replaced
277 def control_sdprods(self,d):
279 Cette methode doit verifier que les concepts produits par la
280 commande ne sont pas incompatibles avec le contexte fourni (d).
281 Si c'est le cas, le concept produit doit etre supprime
282 Si la macro a elle meme des etapes, elle doit propager
283 le traitement (voir methode control_jdc_context_apres de I_JDC)
285 #print "I_MACRO_ETAPE.control_sdprods",d.keys(),self.nom,self.sd and self.sd.nom
288 # Le concept est deja defini
289 if self.reuse and self.reuse is d[self.sd.nom]:
290 # Le concept est reutilise : situation normale
293 # Redefinition du concept, on l'annule
294 #XXX on pourrait simplement annuler son nom pour conserver les objets
295 # l'utilisateur n'aurait alors qu'a renommer le concept (faisable??)
298 self.sd=self.reuse=self.sdnom=None
299 self.parent.delete_concept_after_etape(self,sd)
302 # On verifie les concepts a droite du signe =
304 sdprods=self.sdprods[:]
307 if co.nom in d and co is not d[co.nom] :
308 #nettoie les mots cles de l'etape qui ont comme valeur co
309 self.delete_concept(co)
310 #supprime les references a co dans les etapes suivantes
311 self.parent.delete_concept_after_etape(self,co)
313 self.sdprods.append(co)
316 for e in self.etapes:
320 def supprime_sdprod(self,sd):
322 Supprime le concept produit sd s'il est produit par l'etape
324 if sd in self.sdprods:
326 self.parent.del_sdprod(sd)
327 self.sdprods.remove(sd)
329 self.parent.delete_concept(sd)
332 if sd is not self.sd :return
333 if self.sd is not None :
335 self.parent.del_sdprod(sd)
338 self.parent.delete_concept(sd)
340 def supprime_sdprods(self):
342 Fonction: Lors de la destruction de la macro-etape, detruit tous les concepts produits
343 Un operateur n a qu un concept produit
344 Une procedure n'en a aucun
345 Une macro en a en general plus d'un
347 #print "supprime_sdprods"
348 if self.reuse is not self.sd :
349 # l'etape n'est pas reentrante
350 # le concept retourne par l'etape est a supprimer car il etait
353 self.parent.del_sdprod(self.sd)
354 self.parent.delete_concept(self.sd)
355 # On detruit les concepts a droite du signe =
356 for co in self.sdprods:
357 self.parent.del_sdprod(co)
358 self.parent.delete_concept(co)
359 # Si la macro a des etapes et des concepts inclus, on les detruit
360 for nom_sd,co in self.g_context.items():
361 if not isinstance(co,ASSD):continue
362 self.parent.del_sdprod(co)
363 self.parent.delete_concept(co)
364 # On met g_context a blanc
369 if hasattr(self,"jdc_aux") and self.jdc_aux:
370 # La macro a un jdc auxiliaire inclus. On demande sa fermeture
373 def reset_context(self):
374 if hasattr(self,"jdc_aux") and self.jdc_aux:
375 # La macro a un jdc auxiliaire inclus. On demande la reinitialisation du contexte
376 self.jdc_aux.reset_context()
378 def update_concept(self,sd):
379 I_ETAPE.ETAPE.update_concept(self,sd)
380 for etape in self.etapes:
381 etape.update_concept(sd)
383 def delete_concept(self,sd):
385 Fonction : Mettre a jour les mots cles de l etape et eventuellement
386 le concept produit si reuse suite a la disparition du concept sd
387 Seuls les mots cles simples MCSIMP font un traitement autre
388 que de transmettre aux fils
390 #print "delete_concept",sd
391 I_ETAPE.ETAPE.delete_concept(self,sd)
392 for etape in self.etapes:
393 etape.delete_concept(sd)
395 def replace_concept(self,old_sd,sd):
397 Fonction : Mettre a jour les mots cles de l etape et le concept produit si reuse
398 suite au remplacement du concept old_sd par sd
400 #print "replace_concept",old_sd,sd
401 I_ETAPE.ETAPE.replace_concept(self,old_sd,sd)
402 for etape in self.etapes:
403 etape.replace_concept(old_sd,sd)
405 def change_fichier_init(self,new_fic,text):
407 Tente de changer le fichier include. Le precedent include est conserve
410 if not hasattr(self,'fichier_ini'):
411 self.fichier_ini=None
412 self.fichier_text=None
413 self.fichier_err="Le fichier n'est pas defini"
414 self.contexte_fichier_init={}
415 self.recorded_units={}
417 self.fichier_unite="PasDefini"
418 import Extensions.jdc_include
419 self.JdC_aux=Extensions.jdc_include.JdC_include
421 self.old_fic = self.fichier_ini
422 self.old_text = self.fichier_text
423 self.old_err = self.fichier_err
424 self.old_context=self.contexte_fichier_init
425 self.old_units=self.recorded_units
426 self.old_etapes=self.etapes
427 self.old_jdc_aux=self.jdc_aux
429 self.fichier_ini = new_fic
430 self.fichier_text=text
433 self.make_contexte_include(new_fic,text)
435 l=traceback.format_exception_only(tr("Fichier invalide %s", sys.exc_info()[1]))
436 self.fichier_err=''.join(l)
437 raise EficasException(self.fichier_err)
439 # L'evaluation de text dans un JDC auxiliaire s'est bien passe
440 # on peut poursuivre le traitement
442 self.state="undetermined"
443 self.fichier_err=None
444 # On enregistre la modification de fichier
446 # Le contexte du parent doit etre reinitialise car les concepts produits ont change
447 self.parent.reset_context()
449 # Si des concepts ont disparu lors du changement de fichier, on demande leur suppression
450 self.old_contexte_fichier_init=self.old_context
451 self.reevalue_sd_jdc()
455 self.old_jdc_aux.close()
457 def restore_fichier_init(self):
459 Restaure le fichier init enregistre dans old_xxx
461 self.fichier_ini=self.old_fic
462 self.fichier_text=self.old_text
463 self.fichier_err=self.old_err
464 self.contexte_fichier_init=self.old_context
465 self.recorded_units=self.old_units
466 self.etapes=self.old_etapes
467 self.jdc_aux=self.old_jdc_aux
469 def force_fichier_init(self):
471 Force le remplacement du fichier init meme si le remplacant est en erreur
473 # Reinitialisation complete du compte-rendu d'erreurs
474 self.jdc_aux.cr=self.jdc_aux.CR()
475 # On remplit le dictionnaire des concepts produits inclus
476 # en retirant les concepts presents dans le contexte initial
477 # On ajoute egalement le concept produit dans le sds_dict du parent
478 # sans verification car on est sur (verification integree) que
479 # le nommage est possible
480 j_context=self.jdc_aux.get_contexte_avant(None)
481 self.g_context.clear()
482 context_ini=self.jdc_aux.context_ini
483 for k,v in j_context.items():
484 if not k in context_ini or context_ini[k] != v:
486 self.parent.sds_dict[k]=v
487 # On recupere le contexte courant
488 self.current_context=self.jdc_aux.current_context
489 self.index_etape_courante=self.jdc_aux.index_etape_courante
490 self.contexte_fichier_init = j_context
491 self.fichier_err = None
493 # On enregistre la modification de fichier
495 self.state="undetermined"
497 # Le contexte du parent doit etre reinitialise car les concepts produits ont change
498 self.parent.reset_context()
500 # On remplace les anciens concepts par les nouveaux (y compris ajouts
501 # et suppression) et on propage les modifications aux etapes precedentes et suivantes
502 # reevalue_sd_jdc construit la liste des differences entre les contextes contexte_fichier_init
503 # et old_contexte_fichier_init et effectue les destructions et remplacements de concept
505 self.old_contexte_fichier_init=self.old_context
506 self.reevalue_sd_jdc()
509 self.old_jdc_aux.close()
511 self.jdc_aux.force_contexte(self.g_context)
513 def build_include(self,fichier,text):
514 import Extensions.jdc_include
515 self.JdC_aux=Extensions.jdc_include.JdC_include
516 # un include partage la table des unites avec son parent (jdc)
517 self.recorded_units=self.parent.recorded_units
518 self.build_jdcaux(fichier,text)
520 def build_poursuite(self,fichier,text):
521 import Extensions.jdc_include
522 self.JdC_aux=Extensions.jdc_include.JdC_poursuite
523 # une poursuite a sa propre table d'unites
524 self.recorded_units={}
525 self.build_jdcaux(fichier,text)
529 def build_includeInclude(self,text):
530 import Extensions.jdc_include
531 self.JdC_aux=Extensions.jdc_include.JdC_include
532 # un include partage la table des unites avec son parent (jdc)
533 self.build_jdcauxInclude(text)
536 def build_jdcauxInclude(self,text):
539 contexte = self.get_contexte_jdc(None,text)
540 except EficasException:
542 index=self.jdc.etapes.index(self)
543 for e in self.etapes:
545 self.jdc.etapes=self.jdc.etapes[:index+1]+self.etapes+self.jdc.etapes[index+1:]
549 CONTEXT.unset_current_step()
551 def build_jdcaux(self,fichier,text):
553 Cree un jdc auxiliaire initialise avec text.
554 Initialise le nom du fichier associe avec fichier
555 N'enregistre pas d'association unite <-> fichier
557 self.fichier_ini = fichier
558 self.fichier_text= text
559 self.fichier_unite=None
560 self.fichier_err = None
562 contexte = self.get_contexte_jdc(fichier,text)
563 if contexte is None :
564 # Impossible de construire le jdc auxiliaire (sortie par None)
565 # On simule une sortie par exception
566 raise EficasException(tr("Impossible de construire le jeu de commandes correspondant au fichier"))
568 # La construction du jdc auxiliaire est allee au bout
569 self.contexte_fichier_init = contexte
573 # Impossible de construire le jdc auxiliaire (sortie par exception)
574 l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
575 if self.jdc.appli is not None:
576 self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
577 message= tr("Ce fichier ne sera pas pris en compte\n %s",''.join(l)))
582 self.fichier_err = ''.join(l)
583 self.contexte_fichier_init={}
586 raise EficasException(" ")
588 def make_contexte_include(self,fichier,text):
590 Cette methode sert a craer un contexte en interpratant un texte source Python.
592 print ("make_contexte_include",fichier)
593 # on recupere le contexte d'un nouveau jdc dans lequel on interprete text
594 contexte = self.get_contexte_jdc(fichier,text)
595 print ("make_contexte_include",fichier)
596 if contexte == None :
597 raise EficasException("Impossible de construire le jeu de commandes correspondant au fichier")
599 # Pour les macros de type include : INCLUDE, INCLUDE_MATERIAU et POURSUITE
600 # l'attribut g_context est un dictionnaire qui contient les concepts produits par inclusion
601 # l'attribut contexte_fichier_init est un dictionnaire qui contient les concepts produits
602 # en sortie de macro. g_context est obtenu en retirant de contexte_fichier_init les concepts
603 # existants en debut de macro contenus dans context_ini (dans get_contexte_jdc)
604 # g_context est utilise pour avoir les concepts produits par la macro
605 # contexte_fichier_init est utilise pour avoir les concepts supprimes par la macro
606 self.contexte_fichier_init = contexte
607 print ("fin make_contexte_include",fichier)
609 def reevalue_fichier_init_OBSOLETE(self):
610 """Recalcule les concepts produits par le fichier enregistre"""
611 #print "reevalue_fichier_init"
612 old_context=self.contexte_fichier_init
614 self.make_contexte_include(self.fichier_ini ,self.fichier_text)
616 l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
617 self.fichier_err = ''.join(l)
621 self.old_contexte_fichier_init=old_context
622 self.contexte_fichier_init={}
623 self.reevalue_sd_jdc()
626 # L'evaluation s'est bien passee
627 self.fichier_err = None
628 self.old_contexte_fichier_init=old_context
629 self.reevalue_sd_jdc()
631 def update_fichier_init(self,unite):
632 """Reevalue le fichier init sans demander (dans la mesure du possible) a l'utilisateur
633 les noms des fichiers
634 Ceci suppose que les relations entre unites et noms ont ete memorisees prealablement
635 L'include a ete initialise precedemment. Le jdc auxiliaire existe.
637 #print "update_fichier_init",unite,self.fichier_unite
638 self.old_contexte_fichier_init=self.contexte_fichier_init
639 old_fichier_ini=self.fichier_ini
640 if not hasattr(self,"jdc_aux"):self.jdc_aux=None
641 old_jdc_aux=self.jdc_aux
643 #print "update_fichier_init",self,self.parent,self.parent.recorded_units
645 if self.fichier_unite is None:
646 # L'unite n'etait pas definie precedemment. On ne change que l'unite
647 #print "update_fichier_init","pas de changement dans include"
648 self.fichier_unite=unite
650 elif unite == self.fichier_unite :
651 # L'unite n'a pas change
652 #print "update_fichier_init","pas de changement dans include 3"
654 elif unite != self.fichier_unite :
655 # L'unite etait definie precedemment. On remplace l'include
657 f,text=self.get_file_memo(unite=unite,fic_origine=self.parent.nom)
659 # Le fichier associe n'a pas pu etre defini
660 # on change l'unite associee mais pas l'include
661 #print "update_fichier_init","pas de changement dans include 2"
662 self.fichier_unite=unite
666 self.fichier_text=text
667 self.fichier_unite=unite
668 #print "update_fichier_init",self.recorded_units
670 #print "update_fichier_init",self.fichier_ini,self.fichier_text,self.fichier_unite
672 if old_fichier_ini == self.fichier_ini:
673 # Le fichier inclus n'a pas change. On ne recree pas le contexte
674 # mais on enregistre le changement d'association unite <-> fichier
675 #print "update_fichier_init.fichier inchange",self.jdc_aux.context_ini
676 self.parent.record_unit(unite,self)
680 self.fichier_err=None
681 self.make_contexte_include(self.fichier_ini,self.fichier_text)
682 # Les 3 attributs fichier_ini fichier_text recorded_units doivent etre corrects
683 # avant d'appeler change_unit
685 # Erreurs lors de l'evaluation de text dans un JDC auxiliaire
686 l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
687 # On conserve la memoire du nouveau fichier
688 # mais on n'utilise pas les concepts crees par ce fichier
689 # on met l'etape en erreur : fichier_err=''.join(l)
690 self.fichier_err=''.join(l)
694 self.contexte_fichier_init={}
698 self.parent.record_unit(unite,self)
699 # Le contexte du parent doit etre reinitialise car les concepts
700 # produits ont change
701 self.parent.reset_context()
702 # Si des concepts ont disparu lors du changement de fichier, on
703 # demande leur suppression
704 self.reevalue_sd_jdc()
705 #print "update_fichier_init",self.jdc_aux.context_ini.keys()
707 def record_unite(self):
708 #print "record_unite",self.nom
709 if self.nom == "POURSUITE":
710 self.parent.record_unit(None,self)
712 if hasattr(self,'fichier_unite') :
713 self.parent.record_unit(self.fichier_unite,self)
715 def get_file_memo(self, unite=None, fname=None, fic_origine=''):
716 """Retourne le nom du fichier et le source correspondant a l'unite unite
717 Initialise en plus recorded_units
719 #print "get_file_memo",unite,fic_origine,self,self.parent
720 #print self.parent.recorded_units
722 # On est dans le cas d'une poursuite. On ne reutilise aucune unite de parent
725 # On est dans le cas d'un include. On reutilise toutes les unites de parent
726 units=self.parent.recorded_units
728 if unite in self.parent.recorded_units:
729 f,text,units=self.parent.recorded_units[unite]
732 if not osp.exists(fname):
733 raise AsException(fname + tr(" n'est pas un fichier existant"))
735 text = open(fname, 'r').read()
737 f,text=self.jdc.get_file(unite=unite, fic_origine=fic_origine)
741 self.recorded_units=units
742 if f is None and self.jdc.appli:
743 self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
744 message= tr("Ce fichier ne sera pas pris en compte\nLe fichier associe n'est pas defini"))
747 def update_context(self,d):
749 Met a jour le contexte contenu dans le dictionnaire d
750 Une MACRO_ETAPE peut ajouter plusieurs concepts dans le contexte
751 Une fonction enregistree dans op_init peut egalement modifier le contexte
753 #print "update_context",self,self.nom,d.keys()
754 if hasattr(self,"jdc_aux") and self.jdc_aux:
755 #ATTENTION: update_context NE DOIT PAS appeler reset_context
756 # car il appelle directement ou indirectement update_context
757 # equivalent a reset_context. Evite les recursions
758 self.jdc_aux.context_ini=d.copy()
759 self.jdc_aux.current_context={}
760 self.jdc_aux.index_etape_courante=0
761 #ATTENTION: il ne faut pas utiliser self.jdc_aux.get_contexte_avant
762 #car cet appel conduit a des remontees multiples incoherentes dans le
764 #get_context_avant appelle update_context qui NE DOIT PAS appeler get_contexte_avant
765 #On n'a besoin que d'un update local connaissant
766 # le contexte amont : d qui sert a reinitialiser self.context_ini
767 for e in self.etapes:
771 if type(self.definition.op_init) == types.FunctionType:
772 self.definition.op_init(*(self,d))
773 if self.sd != None:d[self.sd.nom]=self.sd
774 for co in self.sdprods:
776 #print "update_context.fin",d.keys()
778 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
780 etape=Noyau.N_MACRO_ETAPE.MACRO_ETAPE.copy(self)
781 if hasattr(etape,"etapes") :etape.etapes=[]
782 if hasattr(etape,"jdc_aux") :
784 del etape.fichier_ini
788 #print "supprime",self
789 if hasattr(self,"jdc_aux") and self.jdc_aux:
790 self.jdc_aux.supprime_aux()
792 Noyau.N_MACRO_ETAPE.MACRO_ETAPE.supprime(self)
794 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
795 def get_file(self,unite=None,fic_origine=''):
796 """Retourne le nom du fichier et le source correspondant a l'unite unite
799 f,text=self.jdc.get_file(unite=unite,fic_origine=fic_origine)
805 def make_include3(self,fichier=None):
806 self.make_includeCarmel(fichier)
809 def make_includeCND(self,fichier=None):
811 if fichier==None : return
812 if hasattr(self,'fichier_ini') : print((self.fichier_ini))
813 if hasattr(self,'fichier_ini') : return
814 self.fichier_ini=fichier
815 from acquiertGroupes import getGroupes
816 erreur,listeGroupes=getGroupes(fichier)
817 if erreur != "" : print ("a traiter")
822 for groupe in listeGroupes :
823 if groupe[0:8]=='CURRENT_': texteSources +=groupe[8:]+"=SOURCE();\n"
824 if groupe[0:5]=='COND_': texteCond +=groupe[5:]+"=CONDUCTEUR();\n"
825 if groupe[0:7]=='NOCOND_': texteNoCond +=groupe[7:]+"=NOCOND();\n"
826 #if groupe[0:5]=='VCUT_': texteVcut +=groupe[5:]+"=VCUT();\n"
827 if groupe[0:5]=='VCUT_': texteVcut +='V_'+groupe[5:]+"=VCUT();\n"
828 texte=texteSources+texteCond+texteNoCond+texteVcut
830 self.build_includeInclude(texte)
831 if CONTEXT.get_current_step()==None : CONTEXT.set_current_step(self)
834 def make_includeCarmel(self,fichier=None):
836 #print "je suis dans make_includeCarmel"
838 if hasattr(self,'fichier_ini') : return
840 if hasattr(self,'old_context_fichier_init' ):
842 for concept in self.old_context_fichier_init.values():
843 self.jdc.delete_concept(concept)
845 fichier=str(self.jdc.appli.get_file_dictDonnees())
846 if fichier == str("") :
847 self.fichier_ini="badfile"
849 self.fichier_err=tr("Le fichier n est pas defini")
850 self.parent.record_unit(999,self)
852 MCFils=self.get_child('FileName')
853 MCFils.set_valeur(None)
856 raise EficasException(self.fichier_err)
857 self.fichier_ini = fichier
858 f=open(self.fichier_ini,'r')
859 self.fichier_text=f.read()
862 self.contexte_fichier_init={}
863 self.fichier_unite=999
864 self.fichier_err=None
868 import Extensions.jdc_include
869 self.JdC_aux=Extensions.jdc_include.JdC_include
872 traceback.print_exc()
873 self.make_incl2_except()
874 raise EficasException(" ")
878 self.make_contexte_include(self.fichier_ini ,self.fichier_text)
879 self.old_context_fichier_init=self.contexte_fichier_init
880 self.parent.record_unit(unite,self)
882 MCFils=self.get_child('FileName')
883 #MCFils.set_valeur(fichier)
884 #on appelle pas set_valeur qui modifie le contexte ce qui fout le bazar
885 #pas de modification de bloc
886 MCFils.valeur=fichier
892 self.make_incl2_except()
893 # Cette P*** de ligne suivante ne fonctionne que pour Aster
894 # si quelqu un a une idee merci de m en parler
895 #CONTEXT.set_current_step(self)
897 def make_include2(self,fichier=None):
899 # gestion de l unicite SVP
902 if hasattr(self,'fichier_ini') : return
904 if hasattr(self,'old_context_fichier_init' ):
906 for concept in self.old_context_fichier_init.values():
907 self.jdc.delete_concept(concept)
910 fichier=str(self.jdc.appli.get_file_variable())
911 if fichier == str("") :
912 self.fichier_ini="badfile"
914 self.fichier_err=tr("Le fichier n est pas defini")
915 self.parent.record_unit(999,self)
917 MCFils=self.get_child('FileName')
918 MCFils.set_valeur(None)
921 raise EficasException(self.fichier_err)
923 self.fichier_ini = fichier
924 self.fichier_text = ""
925 self.contexte_fichier_init={}
926 self.fichier_unite=999
927 self.fichier_err=None
930 from openturns import WrapperFile
931 monWrapper=WrapperFile(fichier)
932 data=monWrapper.getWrapperData()
933 maVariableListe=data.getVariableList()
934 nbVariables=maVariableListe.getSize()
935 for i in range(nbVariables) :
936 nom=maVariableListe[i].id_
937 type=maVariableListe[i].type_
939 #ligneTexte="%s=DETERMINISTICVARIABLE(N='%s',T='out',R=%d);\n" % (nom, nom, i)
941 nbVariableOut=nbVariableOut+1
943 ligneTexte="%s=DETERMINISTICVARIABLE(N='%s',T='in',R=%d);\n" % (nom, nom, i)
944 self.fichier_text = self.fichier_text + ligneTexte
946 self.make_incl2_except()
947 raise EficasException(" ")
949 if nbVariableOut != 1 :
950 print((nbVariableOut ,"nbVariableOut"))
951 self.make_incl2_except(mess=tr("le fichier doit contenir une unique variable de sortie"))
952 raise EficasException(" ")
955 import Extensions.jdc_include
956 self.JdC_aux=Extensions.jdc_include.JdC_include
958 traceback.print_exc()
959 self.make_incl2_except()
960 raise EficasException(" ")
963 print((self.fichier_ini ,self.fichier_text))
964 self.make_contexte_include(self.fichier_ini ,self.fichier_text)
965 self.old_context_fichier_init=self.contexte_fichier_init
966 self.parent.record_unit(unite,self)
968 MCFils=self.get_child('FileName')
969 MCFils.set_valeur(fichier)
973 self.make_incl2_except()
975 # recalcul validite pour la matrice eventuelle
977 for e in self.jdc.etapes:
978 if e.nom == "VARIABLE" :
981 mc=e.get_child('ModelVariable')
985 if e.nom == "CORRELATION" :
988 mc=e.get_child('Matrix')
990 mcFeuille=mc.get_child('CorrelationMatrix')
991 mcFeuille.state="modified"
996 def make_incl2_except(self,mess=None):
997 l=traceback.format_exception_only(tr("Fichier invalide"),sys.exc_info()[1])
998 if self.jdc.appli is not None:
1000 self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
1001 message= tr("Le contenu de ce fichier ne sera pas pris en compte\n %s",\
1005 self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
1007 #self.parent.record_unit(unite,self)
1011 self.fichier_err = ''.join(l)
1012 self.contexte_fichier_init={}
1014 MCFils=self.get_child('FileName')
1015 MCFils.set_valeur(None)
1020 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
1021 def make_include(self, unite=None, fname=None):
1023 Inclut un fichier dont l'unite logique est unite
1024 Cette methode est appelee par la fonction sd_prod de la macro INCLUDE
1025 Si l'INCLUDE est invalide, la methode doit produire une exception
1026 Sinon on retourne None. Les concepts produits par l'INCLUDE sont
1027 pris en compte par le JDC parent lors du calcul du contexte (appel de ???)
1029 #print "make_include",unite
1030 # On supprime l'attribut unite qui bloque l'evaluation du source de l'INCLUDE
1031 # car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini
1032 # Si unite n'a pas de valeur, l'etape est forcement invalide. On peut retourner None
1033 if not unite and not fname:
1036 if not hasattr(self,'fichier_ini') :
1037 # Si le fichier n'est pas defini on le demande
1038 f,text=self.get_file_memo(unite=unite, fname=fname, fic_origine=self.parent.nom)
1039 # On memorise le fichier retourne
1040 self.fichier_ini = f
1041 self.fichier_text = text
1042 self.contexte_fichier_init={}
1043 self.fichier_unite=unite
1044 self.fichier_err=None
1046 import Extensions.jdc_include
1048 traceback.print_exc()
1049 raise EficasException("pb import Extensions")
1050 self.JdC_aux=Extensions.jdc_include.JdC_include
1052 #print "make_include",self.fichier_ini,self.fichier_text
1053 if f is None and not text:
1054 self.fichier_err=tr("Le fichier INCLUDE n est pas defini")
1055 self.parent.record_unit(unite,self)
1056 raise EficasException(self.fichier_err)
1059 self.make_contexte_include(self.fichier_ini ,self.fichier_text)
1060 self.parent.record_unit(unite,self)
1062 l=traceback.format_exception_only(tr("Fichier invalide %s",sys.exc_info()[1]))
1064 self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
1065 message=tr("Le contenu de ce fichier ne sera pas pris en compte\n"+''.join(l)))
1066 self.parent.record_unit(unite,self)
1070 self.fichier_err = ''.join(l)
1071 self.contexte_fichier_init={}
1072 raise EficasException(" ")
1075 # Si le fichier est deja defini on ne reevalue pas le fichier
1076 # et on leve une exception si une erreur a ete enregistree
1077 self.update_fichier_init(unite)
1078 self.fichier_unite=unite
1079 if self.fichier_err is not None: raise EficasException(self.fichier_err)
1082 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
1083 def make_contexte(self,fichier,text):
1085 Cette methode sert a creer un contexte pour INCLUDE_MATERIAU
1086 en interpretant un texte source Python
1087 Elle est appelee par la fonction sd_prod d'INCLUDE_MATERIAU
1089 #print "make_contexte",fichier
1090 # On supprime l'attribut mat qui bloque l'evaluation du source de l'INCLUDE_MATERIAU
1091 # car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini
1092 if hasattr(self,'mat'):del self.mat
1093 if not hasattr(self,'fichier_ini') or self.fichier_ini != fichier or self.fichier_mater != self.nom_mater:
1094 # le fichier est nouveau ou change
1095 self.fichier_ini =fichier
1096 self.fichier_unite =fichier
1097 self.fichier_mater=self.nom_mater
1098 self.fichier_text=text
1099 self.fichier_err=None
1100 self.contexte_fichier_init={}
1101 # On specifie la classe a utiliser pour le JDC auxiliaire
1103 import Extensions.jdc_include
1104 self.JdC_aux=Extensions.jdc_include.JdC_include
1106 raise EficasException(" ")
1108 self.make_contexte_include(self.fichier_ini ,self.fichier_text)
1109 if not self.nom_mater in self.g_context :
1110 #Pour permettre de lire un jeu de commandes avec des INCLUDE_MATERIAU errones
1111 self.g_context[self.nom_mater]=None
1112 if self.parent: self.parent.g_context[self.nom_mater]=None
1114 l=traceback.format_exception_only(tr("Fichier invalide %s",sys.exc_info()[1]))
1115 self.fichier_err = ''.join(l)
1117 #Pour permettre de lire un jeu de commandes avec des INCLUDE_MATERIAU errones
1119 self.parent.g_context[self.nom_mater]=None
1120 self.g_context[self.nom_mater]=None
1124 self.contexte_fichier_init={}
1125 raise EficasException(" ")
1127 # le fichier est le meme on ne le reevalue pas
1128 # et on leve une exception si une erreur a ete enregistree
1129 if self.fichier_err is not None: raise EficasException(self.fichier_err)
1131 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
1132 def update_sdprod(self,cr='non'):
1133 # Cette methode peut etre appelee dans EFICAS avec des mots cles de
1134 # la commande modifies. Ceci peut conduire a la construction ou
1135 # a la reconstruction d'etapes dans le cas d'INCLUDE ou d'INCLUDE_MATERIAU
1136 # Il faut donc positionner le current_step avant l'appel
1137 CONTEXT.unset_current_step()
1138 CONTEXT.set_current_step(self)
1139 valid=Validation.V_MACRO_ETAPE.MACRO_ETAPE.update_sdprod(self,cr=cr)
1140 CONTEXT.unset_current_step()
1143 #ATTENTION SURCHARGE: cette methode surcharge celle de Noyau a garder en synchro
1144 def Build_sd(self,nom):
1146 Methode de Noyau surchargee pour poursuivre malgre tout
1147 si une erreur se produit pendant la creation du concept produit
1150 sd=Noyau.N_MACRO_ETAPE.MACRO_ETAPE.Build_sd(self,nom)
1153 #except AsException,e:
1154 # Une erreur s'est produite lors de la construction du concept
1155 # Comme on est dans EFICAS, on essaie de poursuivre quand meme
1156 # Si on poursuit, on a le choix entre deux possibilites :
1157 # 1. on annule la sd associee a self
1158 # 2. on la conserve mais il faut la retourner
1159 # On choisit de l'annuler
1160 # En plus il faut rendre coherents sdnom et sd.nom
1163 self.state="unchanged"
1168 #ATTENTION SURCHARGE: cette methode surcharge celle de Noyau a garder en synchro
1169 def make_poursuite(self):
1170 """ Cette methode est appelee par la fonction sd_prod de la macro POURSUITE
1172 #print "make_poursuite"
1173 if not hasattr(self,'fichier_ini') :
1174 # Si le fichier n'est pas defini on le demande
1175 f,text=self.get_file_memo(fic_origine=self.parent.nom)
1176 # On memorise le fichier retourne
1177 self.fichier_ini = f
1178 self.fichier_unite = None
1179 self.fichier_text = text
1180 self.fichier_err=None
1182 import Extensions.jdc_include
1184 traceback.print_exc()
1185 raise EficasException(" ")
1186 self.JdC_aux=Extensions.jdc_include.JdC_poursuite
1187 self.contexte_fichier_init={}
1188 #print "make_poursuite",self.fichier_ini,self.fichier_text
1191 self.fichier_err="Le fichier POURSUITE n'est pas defini"
1193 self.parent.record_unit(None,self)
1194 raise EficasException(self.fichier_err)
1197 self.make_contexte_include(self.fichier_ini,self.fichier_text)
1198 self.parent.record_unit(None,self)
1200 l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
1202 self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier poursuite"),
1203 message=tr("Ce fichier ne sera pas pris en compte\n %s",''.join(l)))
1204 self.parent.record_unit(None,self)
1208 self.fichier_err = ''.join(l)
1209 self.contexte_fichier_init={}
1210 raise EficasException(" ")
1213 # Si le fichier est deja defini on ne reevalue pas le fichier
1214 # et on leve une exception si une erreur a ete enregistree
1215 self.update_fichier_init(None)
1216 if self.fichier_err is not None: raise EficasException(self.fichier_err)