Ihm/I_MACRO_ETAPE.py

   1 # -*- coding: iso-8859-1 -*-
   2 # Copyright (C) 2007-2021   EDF R&D
   3 #
   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.
   8 #
   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.
  13 #
  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
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20 """
  21 """
  22 # Modules Python
  23 from __future__ import absolute_import
  24 from __future__ import print_function
  25 import sys
  26 import os.path as osp
  27 import traceback,types
  28
  29 # Modules Eficas
  30 from Extensions.i18n import tr
  31 from Extensions.eficas_exception import EficasException
  32 from Ihm  import I_ETAPE
  33 from Ihm import I_ENTITE
  34 from Ihm import I_OBJECT
  35 import Noyau
  36 from Noyau.N_ASSD import ASSD
  37 from Noyau import N__F
  38 from Extensions import param2
  39
  40 # import rajoutes suite a l'ajout de buildSd --> a resorber
  41 import Noyau, Validation.V_MACRO_ETAPE
  42 from Noyau import N_Exception
  43 from Noyau.N_Exception import AsException
  44 import Accas # attention aux imports circulaires
  45 # fin import a resorber
  46
  47 class MACRO_ETAPE(I_ETAPE.ETAPE):
  48
  49     def __init__(self):
  50         self.typret=None
  51         #indique si le jeu de commande inclus a pu etre analyse par convert
  52         #pour etre editable (0=NON, 1=OUI)
  53         self.text_converted=1
  54         self.text_error=""
  55         self.recorded_units={}
  56
  57     def getSdprods(self,nom_sd):
  58         """
  59              Fonction : retourne le concept produit par l etape de nom nom_sd
  60              s il existe sinon None
  61         """
  62         if self.sd and self.sd.nom == nom_sd :return self.sd
  63         for co in self.sdprods:
  64             if co.nom == nom_sd:return co
  65         if type(self.definition.op_init) == types.FunctionType:
  66             d={}
  67             self.definition.op_init(*(self,d))
  68             return d.get(nom_sd,None)
  69         return None
  70
  71     def getContexteJdc(self,fichier,text,doitEtreValide=1):
  72         """
  73              Interprete text comme un texte de jdc et retourne le contexte final.
  74
  75              Le contexte final est le dictionnaire des sd disponibles a la derniere etape.
  76              Si text n'est pas un texte de jdc valide, retourne None
  77              ou leve une exception
  78              --> utilisee par ops.POURSUITE et INCLUDE
  79         """
  80         #print ("getContexteJdc",self,self.nom, text)
  81         # On recupere l'etape courante
  82         step=CONTEXT.getCurrentStep()
  83         self.text_included_converted=0
  84         try:
  85         #if 1 :
  86             # on essaie de creer un objet JDC auxiliaire avec un contexte initial
  87             # Attention getContexteAvant retourne un dictionnaire qui contient
  88             # le contexte courant. Ce dictionnaire est reactualise regulierement.
  89             # Si on veut garder l'etat du contexte fige, il faut en faire une copie.
  90             context_ini = self.parent.getContexteAvant(self).copy()
  91
  92             # Indispensable avant de creer un nouveau JDC
  93             CONTEXT.unsetCurrentStep()
  94             args=self.jdc.args
  95             prefix_include=None
  96             if hasattr(self,'prefix'):
  97                 prefix_include=self.prefix
  98             # ATTENTION : le dictionnaire recorded_units sert a memoriser les unites des
  99             # fichiers inclus. Il est preferable de garder le meme dictionnaire pendant
 100             # tout le traitement et de ne pas le reinitialiser brutalement (utiliser
 101             # clear plutot) si on ne veut pas perdre la memoire des unites.
 102             # En principe si la memorisation est faite au bon moment il n'est pas necessaire
 103             # de prendre cette precaution mais ce n'est pas vrai partout.
 104             old_recorded_units=self.recorded_units.copy()
 105
 106             # on supprime l'ancien jdc_aux s'il existe
 107             if hasattr(self,'jdc_aux') and self.jdc_aux:
 108                 self.jdc_aux.supprime_aux()
 109
 110             if fichier is None:fichier="SansNom"
 111
 112             # Il faut convertir le texte inclus en fonction du format
 113             # sauf les INCLUDE_MATERIAU
 114             self.text_converted=0
 115             self.text_error=""
 116             if self.nom != "INCLUDE_MATERIAU":
 117                 format=self.jdc.appliEficas.format_fichier
 118                 #on force a python pour Carmel
 119                 if format=="CARMEL3D" : format="python"
 120                 import convert
 121                 if format in convert.plugins :
 122                     # Le convertisseur existe on l'utilise
 123                     p=convert.plugins[format]()
 124                     p.text=text
 125                     text=p.convert('exec',self.jdc.appliEficas)
 126                     #Si le fichier ne peut pas etre converti, le cr n'est pas vide
 127                     #et le texte est retourne tel que
 128                     if not p.cr.estvide():
 129                         self.text_converted=0
 130                         self.text_error=str(p.cr)
 131                     else:
 132                         self.text_converted=1
 133
 134
 135             if hasattr(self,'sd') and self.sd != None : context_ini[self.sd.nom]=self.sd
 136             j=self.JdC_aux( procedure=text, nom=fichier,
 137                                      appliEficas=self.jdc.appliEficas,
 138                                      cata=self.jdc.cata,
 139                                      cata_ord_dico=self.jdc.cata_ordonne_dico,
 140                                      context_ini = context_ini,
 141                                      jdc_pere=self.jdc,etape_include=self,
 142                                      prefix_include=prefix_include,
 143                                      recorded_units=self.recorded_units,
 144                                      old_recorded_units=old_recorded_units,**args)
 145
 146             j.analyse()
 147             if not j.cr.estvide(): self.text_included_converted=0
 148             else : self.text_included_converted=1
 149             self.text_included_error=str(j.cr)
 150             # On recupere les etapes internes (pour validation)
 151             self.etapes=j.etapes
 152             self.jdc_aux=j
 153             self.jdc.jdcDict=self.jdc_aux
 154
 155         except:
 156         #else :
 157             traceback.print_exc()
 158             # On retablit l'etape courante step
 159             CONTEXT.unsetCurrentStep()
 160             CONTEXT.setCurrentStep(step)
 161             return None
 162
 163
 164         if not j.cr.estvide() and doitEtreValide:
 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
 168             #print (j.cr)
 169             #print ("valid ",j.isValid())
 170             CONTEXT.unsetCurrentStep()
 171             CONTEXT.setCurrentStep(step)
 172             raise EficasException(tr("Impossible de relire le fichier %s \n ")+ str(j.cr))
 173
 174
 175         if not j.isValid() and doitEtreValide:
 176             # L'INCLUDE n'est pas valide.
 177             # on produit un rapport d'erreurs
 178             cr=j.report()
 179             #print ('cr', cr)
 180             # On retablit l'etape courante step
 181             CONTEXT.unsetCurrentStep()
 182             CONTEXT.setCurrentStep(step)
 183             self.jdc.cr.fatal("Le fichier include contient des erreurs ")
 184             raise EficasException(tr("Le fichier include contient des erreurs "))
 185
 186
 187         # Si aucune erreur rencontree
 188         # ou qu on accepte un jdc incomplet
 189         # On recupere le contexte de l'include verifie
 190         try:
 191             j_context=j.getVerifContexte()
 192             #print j_context.keys()
 193             #print j.g_context.keys()
 194         except:
 195             # On retablit l'etape courante step
 196             CONTEXT.unsetCurrentStep()
 197             CONTEXT.setCurrentStep(step)
 198             raise EficasException(" ")
 199
 200         # Si on est arrive ici, le texte du fichier inclus (INCLUDE, POURSUITE, ...)
 201         # est valide et inserable dans le JDC
 202
 203         # On remplit le dictionnaire des concepts produits inclus
 204         # en retirant les concepts presents dans le  contexte initial
 205         # On ajoute egalement le concept produit dans le sdsDict du parent
 206         # sans verification car on est sur (verification integree) que
 207         # le nommage est possible
 208         self.g_context.clear()
 209         for k,v in j_context.items():
 210             if (not k in context_ini) or (context_ini[k] != v):
 211                 self.g_context[k]=v
 212                 self.parent.sdsDict[k]=v
 213
 214         #Ce traitement n'est realise que dans les cas suivants:
 215         #     - si convert n'a pas pu convertir le jeu de commandes
 216         #     - et ce n'est pas un INCLUDE_MATERIAU
 217         #On collecte les variables Python qui ne sont pas dans le contexte initial
 218         #et dans le contexte valide et on en fait un pseudo-parametre (Variable)
 219         if self.text_converted == 0 and self.nom != "INCLUDE_MATERIAU":
 220             for k,v in j.g_context.items():
 221                 if k in context_ini:continue
 222                 if k in j_context:continue
 223                 if isinstance(v,ASSD):continue
 224                 if isinstance(v,I_ENTITE.ENTITE):continue
 225                 if isinstance(v,I_OBJECT.OBJECT):continue
 226                 if callable(v):continue
 227                 self.g_context[k]=param2.Variable(k,v)
 228
 229         # On recupere le contexte courant
 230         self.currentContext=j.currentContext
 231         self.index_etape_courante=j.index_etape_courante
 232         self.jdc_aux=j
 233
 234         # On retablit l'etape courante step
 235         CONTEXT.unsetCurrentStep()
 236         CONTEXT.setCurrentStep(step)
 237
 238         return j_context
 239
 240     def reevalueSdJdc(self):
 241         """
 242             Avec la liste des SD qui ont ete supprimees, propage la
 243             disparition de ces SD dans toutes les etapes et descendants
 244         """
 245         #print "reevalueSdJdc"
 246         l_sd_supp,l_sd_repl = self.diffContextes()
 247         for sd in l_sd_supp:
 248             self.parent.deleteConceptAfterEtape(self,sd)
 249         for old_sd,sd in l_sd_repl:
 250             self.parent.replaceConceptAfterEtape(self,old_sd,sd)
 251
 252     def diffContextes(self):
 253         """
 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
 258         """
 259         if not hasattr(self,'old_contexte_fichier_init'):return [],[]
 260         l_sd_suppressed = []
 261         l_sd_replaced = []
 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])
 266             else:
 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])
 273                     else:
 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
 276
 277     def controlSdprods(self,d):
 278         """
 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 controlJdcContextApres de I_JDC)
 284         """
 285         #print ("I_MACRO_ETAPE.controlSdprods",d.keys(),self,self.nom,self.sd and self.sd.nom)
 286         if self.sd:
 287             if self.sd.nom in d:
 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
 291                     pass
 292                 else:
 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??)
 296                     self.initModif()
 297                     sd=self.sd
 298                     self.sd=self.reuse=self.sdnom=None
 299                     self.parent.deleteConceptAfterEtape(self,sd)
 300                     self.finModif()
 301
 302         # On verifie les concepts a droite du signe =
 303         self.initModif()
 304         sdprods=self.sdprods[:]
 305         self.sdprods=[]
 306         for co in 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.deleteConcept(co)
 310                 #supprime les references a co dans les etapes suivantes
 311                 self.parent.deleteConceptAfterEtape(self,co)
 312             else:
 313                 self.sdprods.append(co)
 314         self.finModif()
 315
 316         for e in self.etapes:
 317             e.controlSdprods(d)
 318             e.updateContext(d)
 319
 320     def supprimeSdprod(self,sd):
 321         """
 322            Supprime le concept produit sd s'il est produit par l'etape
 323         """
 324         #print ('supprimeSdprod de MACRO_ETAPE')
 325         if sd in self.sdprods:
 326             self.initModif()
 327             self.parent.delSdprod(sd)
 328             self.sdprods.remove(sd)
 329             self.finModif()
 330             self.parent.deleteConcept(sd)
 331             return
 332
 333         if sd is not self.sd :return
 334         if self.sd is not None :
 335             self.initModif()
 336             self.parent.delSdprod(sd)
 337             self.sd=None
 338             self.finModif()
 339             self.parent.deleteConcept(sd)
 340
 341     def supprimeSdProds(self):
 342         """
 343             Fonction: Lors de la destruction de la macro-etape, detruit tous les concepts produits
 344             Un operateur n a qu un concept produit
 345             Une procedure n'en a aucun
 346             Une macro en a en general plus d'un
 347         """
 348         #print "supprimeSdProds"
 349         if self.reuse is not self.sd :
 350             # l'etape n'est pas reentrante
 351             # le concept retourne par l'etape est a supprimer car il etait
 352             # cree par l'etape
 353             if self.sd != None :
 354                 self.parent.delSdprod(self.sd)
 355                 self.parent.deleteConcept(self.sd)
 356         # On detruit les concepts a droite du signe =
 357         for co in self.sdprods:
 358             self.parent.delSdprod(co)
 359             self.parent.deleteConcept(co)
 360         # Si la macro a des etapes et des concepts inclus, on les detruit
 361         for nom_sd,co in self.g_context.items():
 362             if not isinstance(co,ASSD):continue
 363             self.parent.delSdprod(co)
 364             self.parent.deleteConcept(co)
 365         # On met g_context a blanc
 366         self.g_context={}
 367
 368     def close(self):
 369         #print "close",self
 370         if hasattr(self,"jdc_aux") and self.jdc_aux:
 371             # La macro a un jdc auxiliaire inclus. On demande sa fermeture
 372             self.jdc_aux.close()
 373
 374     def resetContext(self):
 375         if hasattr(self,"jdc_aux") and self.jdc_aux:
 376             # La macro a un jdc auxiliaire inclus. On demande la reinitialisation du contexte
 377             self.jdc_aux.resetContext()
 378
 379     def updateConcept(self,sd):
 380         I_ETAPE.ETAPE.updateConcept(self,sd)
 381         for etape in self.etapes:
 382             etape.updateConcept(sd)
 383
 384     def deleteConcept(self,sd):
 385         """
 386             Fonction : Mettre a jour les mots cles de l etape et eventuellement
 387             le concept produit si reuse suite a la disparition du concept sd
 388             Seuls les mots cles simples MCSIMP font un traitement autre
 389             que de transmettre aux fils
 390         """
 391         #print "deleteConcept",sd
 392         I_ETAPE.ETAPE.deleteConcept(self,sd)
 393         for etape in self.etapes:
 394             etape.deleteConcept(sd)
 395
 396     def replaceConcept(self,old_sd,sd):
 397         """
 398             Fonction : Mettre a jour les mots cles de l etape et le concept produit si reuse
 399             suite au remplacement  du concept old_sd par sd
 400         """
 401         #print "replaceConcept",old_sd,sd
 402         I_ETAPE.ETAPE.replaceConcept(self,old_sd,sd)
 403         for etape in self.etapes:
 404             etape.replaceConcept(old_sd,sd)
 405
 406     def changeFichierInit(self,new_fic,text):
 407         """
 408            Tente de changer le fichier include. Le precedent include est conserve
 409            dans old_xxx
 410         """
 411         if not hasattr(self,'fichier_ini'):
 412             self.fichier_ini=None
 413             self.fichier_text=None
 414             self.fichier_err="Le fichier n'est pas defini"
 415             self.contexte_fichier_init={}
 416             self.recorded_units={}
 417             self.jdc_aux=None
 418             self.fichier_unite="PasDefini"
 419             import Extensions.jdc_include
 420             self.JdC_aux=Extensions.jdc_include.JdC_include
 421
 422         self.old_fic = self.fichier_ini
 423         self.old_text = self.fichier_text
 424         self.old_err = self.fichier_err
 425         self.old_context=self.contexte_fichier_init
 426         self.old_units=self.recorded_units
 427         self.old_etapes=self.etapes
 428         self.old_jdc_aux=self.jdc_aux
 429
 430         self.fichier_ini = new_fic
 431         self.fichier_text=text
 432
 433         try:
 434             self.makeContexteInclude(new_fic,text)
 435         except:
 436             l=traceback.format_exception_only(tr("Fichier invalide %s", sys.exc_info()[1]))
 437             self.fichier_err=''.join(l)
 438             raise EficasException(self.fichier_err)
 439
 440         # L'evaluation de text dans un JDC auxiliaire s'est bien passe
 441         # on peut poursuivre le traitement
 442         self.initModif()
 443         self.state="undetermined"
 444         self.fichier_err=None
 445         # On enregistre la modification de fichier
 446         self.recordUnite()
 447         # Le contexte du parent doit etre reinitialise car les concepts produits ont change
 448         self.parent.resetContext()
 449
 450         # Si des concepts ont disparu lors du changement de fichier, on demande leur suppression
 451         self.old_contexte_fichier_init=self.old_context
 452         self.reevalueSdJdc()
 453
 454         self.finModif()
 455         if self.old_jdc_aux:
 456             self.old_jdc_aux.close()
 457
 458     def restoreFichierInit(self):
 459         """
 460            Restaure le fichier init enregistre dans old_xxx
 461         """
 462         self.fichier_ini=self.old_fic
 463         self.fichier_text=self.old_text
 464         self.fichier_err=self.old_err
 465         self.contexte_fichier_init=self.old_context
 466         self.recorded_units=self.old_units
 467         self.etapes=self.old_etapes
 468         self.jdc_aux=self.old_jdc_aux
 469
 470     def forceFichierInit(self):
 471         """
 472            Force le remplacement du fichier init meme si le remplacant est en erreur
 473         """
 474         # Reinitialisation complete du compte-rendu d'erreurs
 475         self.jdc_aux.cr=self.jdc_aux.CR()
 476         # On remplit le dictionnaire des concepts produits inclus
 477         # en retirant les concepts presents dans le  contexte initial
 478         # On ajoute egalement le concept produit dans le sdsDict du parent
 479         # sans verification car on est sur (verification integree) que
 480         # le nommage est possible
 481         j_context=self.jdc_aux.getContexteAvant(None)
 482         self.g_context.clear()
 483         context_ini=self.jdc_aux.context_ini
 484         for k,v in j_context.items():
 485             if not k in context_ini or context_ini[k] != v:
 486                 self.g_context[k]=v
 487                 self.parent.sdsDict[k]=v
 488         # On recupere le contexte courant
 489         self.currentContext=self.jdc_aux.currentContext
 490         self.index_etape_courante=self.jdc_aux.index_etape_courante
 491         self.contexte_fichier_init = j_context
 492         self.fichier_err = None
 493
 494         # On enregistre la modification de fichier
 495         self.initModif()
 496         self.state="undetermined"
 497         self.recordUnite()
 498         # Le contexte du parent doit etre reinitialise car les concepts produits ont change
 499         self.parent.resetContext()
 500
 501         # On remplace les anciens concepts par les nouveaux (y compris ajouts
 502         # et suppression) et on propage les modifications aux etapes precedentes et suivantes
 503         # reevalueSdJdc construit la liste des differences entre les contextes contexte_fichier_init
 504         # et old_contexte_fichier_init et effectue les destructions et remplacements de concept
 505         # necessaires
 506         self.old_contexte_fichier_init=self.old_context
 507         self.reevalueSdJdc()
 508         self.finModif()
 509         if self.old_jdc_aux:
 510             self.old_jdc_aux.close()
 511
 512         self.jdc_aux.forceContexte(self.g_context)
 513
 514     def buildInclude(self,fichier,text):
 515         import Extensions.jdc_include
 516         self.JdC_aux=Extensions.jdc_include.JdC_include
 517         # un include partage la table des unites avec son parent (jdc)
 518         self.recorded_units=self.parent.recorded_units
 519         self.buildJdcaux(fichier,text)
 520
 521     def buildPoursuite(self,fichier,text):
 522         import Extensions.jdc_include
 523         self.JdC_aux=Extensions.jdc_include.JdC_poursuite
 524         # une poursuite a sa propre table d'unites
 525         self.recorded_units={}
 526         self.buildJdcaux(fichier,text)
 527
 528
 529     def buildIncludeInclude(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
 534
 535     def buildIncludeEtape(self,text,doitEtreValide = 0):
 536         import Extensions.jdc_include
 537         self.JdC_aux=Extensions.jdc_include.JdC_include
 538         # un include partage la table des unites avec son parent (jdc)
 539         #self.buildJdcauxInclude(text)
 540         # Attention fonctionne pour import_Zone de MT
 541         # a adapter eventuellement
 542         try :
 543         #if 1 :
 544             contexte = self.getContexteJdc(None,text,doitEtreValide)
 545         except EficasException:
 546             return 0
 547
 548         for e in self.etapes:
 549             e.niveau=self.niveau
 550             e.parent=self.parent
 551             e.state='change'
 552
 553         index=self.jdc.etapes.index(self)
 554         self.jdc.etapes=self.jdc.etapes[:index+1]+self.etapes+self.jdc.etapes[index+1:]
 555
 556         self.g_context={}
 557         self.etapes=[]
 558         self.jdc.resetContext()
 559         self.jdc_aux=None
 560         CONTEXT.unsetCurrentStep()
 561         return 1
 562
 563
 564     def buildJdcauxInclude(self,text):
 565
 566         try :
 567             contexte = self.getContexteJdc(None,text)
 568         except EficasException:
 569             pass
 570         index=self.jdc.etapes.index(self)
 571         for e in self.etapes:
 572             e.niveau=self.niveau
 573         self.jdc.etapes=self.jdc.etapes[:index+1]+self.etapes+self.jdc.etapes[index+1:]
 574         self.g_context={}
 575         self.etapes=[]
 576         self.jdc_aux=None
 577         CONTEXT.unsetCurrentStep()
 578
 579     def buildJdcaux(self,fichier,text):
 580         """
 581              Cree un jdc auxiliaire initialise avec text.
 582              Initialise le nom du fichier associe avec fichier
 583              N'enregistre pas d'association unite <-> fichier
 584         """
 585         self.fichier_ini = fichier
 586         self.fichier_text= text
 587         self.fichier_unite=None
 588         self.fichier_err = None
 589         try:
 590             contexte = self.getContexteJdc(fichier,text)
 591             if contexte is None :
 592             # Impossible de construire le jdc auxiliaire (sortie par None)
 593             # On simule une sortie par exception
 594                 raise EficasException(tr("Impossible de construire le jeu de commandes correspondant au fichier"))
 595             else:
 596                 # La construction du jdc auxiliaire est allee au bout
 597                 self.contexte_fichier_init = contexte
 598             self.initModif()
 599             self.finModif()
 600         except:
 601             # Impossible de construire le jdc auxiliaire (sortie par exception)
 602             l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
 603             if self.jdc.editor is not None:
 604                 self.jdc.editor.afficheAlerte(tr("Erreur lors de l'evaluation du fichier inclus"),
 605                                              message= tr("Ce fichier ne sera pas pris en compte\n %s",''.join(l)))
 606
 607             self.g_context={}
 608             self.etapes=[]
 609             self.jdc_aux=None
 610             self.fichier_err = ''.join(l)
 611             self.contexte_fichier_init={}
 612             self.initModif()
 613             self.finModif()
 614             raise EficasException(" ")
 615
 616     def makeContexteInclude(self,fichier,text):
 617         """
 618             Cette methode sert a craer un contexte en interpratant un texte source Python.
 619         """
 620         #print ("makeContexteInclude",fichier)
 621         # on recupere le contexte d'un nouveau jdc dans lequel on interprete text
 622         contexte = self.getContexteJdc(fichier,text)
 623         #print (contexte)
 624         if contexte == None :
 625             raise EficasException("Impossible de construire le jeu de commandes correspondant au fichier")
 626         else:
 627             # Pour les macros de type include : INCLUDE, INCLUDE_MATERIAU et POURSUITE
 628             # l'attribut g_context est un dictionnaire qui contient les concepts produits par inclusion
 629             # l'attribut contexte_fichier_init est un dictionnaire qui contient les concepts produits
 630             # en sortie de macro. g_context est obtenu en retirant de contexte_fichier_init les concepts
 631             # existants en debut de macro contenus dans context_ini (dans getContexteJdc)
 632             # g_context est utilise pour avoir les concepts produits par la macro
 633             # contexte_fichier_init est utilise pour avoir les concepts supprimes par la macro
 634             self.contexte_fichier_init = contexte
 635         #print ("fin makeContexteInclude",fichier)
 636
 637     def reevalueFichierInitObsolete(self):
 638         """Recalcule les concepts produits par le fichier enregistre"""
 639         #print "reevalue_fichier_init"
 640         old_context=self.contexte_fichier_init
 641         try:
 642             self.makeContexteInclude(self.fichier_ini ,self.fichier_text)
 643         except:
 644             l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
 645             self.fichier_err = ''.join(l)
 646             self.g_context={}
 647             self.etapes=[]
 648             self.jdc_aux=None
 649             self.old_contexte_fichier_init=old_context
 650             self.contexte_fichier_init={}
 651             self.reevalueSdJdc()
 652             return
 653
 654         # L'evaluation s'est bien passee
 655         self.fichier_err = None
 656         self.old_contexte_fichier_init=old_context
 657         self.reevalueSdJdc()
 658
 659     def updateFichierInit(self,unite):
 660         """Reevalue le fichier init sans demander (dans la mesure du possible) a l'utilisateur
 661            les noms des fichiers
 662            Ceci suppose que les relations entre unites et noms ont ete memorisees prealablement
 663            L'include a ete initialise precedemment. Le jdc auxiliaire existe.
 664         """
 665         #print "updateFichierInit",unite,self.fichier_unite
 666         self.old_contexte_fichier_init=self.contexte_fichier_init
 667         old_fichier_ini=self.fichier_ini
 668         if not hasattr(self,"jdc_aux"):self.jdc_aux=None
 669         old_jdc_aux=self.jdc_aux
 670
 671         #print "updateFichierInit",self,self.parent,self.parent.recorded_units
 672
 673         if self.fichier_unite is None:
 674             # L'unite n'etait pas definie precedemment. On ne change que l'unite
 675             #print "updateFichierInit","pas de changement dans include"
 676             self.fichier_unite=unite
 677             return
 678         elif unite == self.fichier_unite :
 679             # L'unite n'a pas change
 680             #print "updateFichierInit","pas de changement dans include 3"
 681             return
 682         elif unite != self.fichier_unite :
 683             # L'unite etait definie precedemment. On remplace l'include
 684             #
 685             f,text=self.getFileMemo(unite=unite,fic_origine=self.parent.nom)
 686             if f is None:
 687                 # Le fichier associe n'a pas pu etre defini
 688                 # on change l'unite associee mais pas l'include
 689                 #print "updateFichierInit","pas de changement dans include 2"
 690                 self.fichier_unite=unite
 691                 return
 692             else:
 693                 self.fichier_ini = f
 694                 self.fichier_text=text
 695                 self.fichier_unite=unite
 696             #print "updateFichierInit",self.recorded_units
 697
 698         #print "updateFichierInit",self.fichier_ini,self.fichier_text,self.fichier_unite
 699
 700         if old_fichier_ini == self.fichier_ini:
 701             # Le fichier inclus n'a pas change. On ne recree pas le contexte
 702             # mais on enregistre le changement d'association unite <-> fichier
 703             #print "updateFichierInit.fichier inchange",self.jdc_aux.context_ini
 704             self.parent.recordUnit(unite,self)
 705             return
 706
 707         try:
 708             self.fichier_err=None
 709             self.makeContexteInclude(self.fichier_ini,self.fichier_text)
 710             # Les 3 attributs fichier_ini fichier_text recorded_units doivent etre corrects
 711             # avant d'appeler changeUnit
 712         except:
 713             # Erreurs lors de l'evaluation de text dans un JDC auxiliaire
 714             l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
 715             # On conserve la memoire du nouveau fichier
 716             # mais on n'utilise pas les concepts crees par ce fichier
 717             # on met l'etape en erreur : fichier_err=''.join(l)
 718             self.fichier_err=''.join(l)
 719             self.g_context={}
 720             self.etapes=[]
 721             self.jdc_aux=None
 722             self.contexte_fichier_init={}
 723
 724         if old_jdc_aux:
 725             old_jdc_aux.close()
 726         self.parent.recordUnit(unite,self)
 727         # Le contexte du parent doit etre reinitialise car les concepts
 728         # produits ont change
 729         self.parent.resetContext()
 730         # Si des concepts ont disparu lors du changement de fichier, on
 731         # demande leur suppression
 732         self.reevalueSdJdc()
 733         #print "updateFichierInit",self.jdc_aux.context_ini.keys()
 734
 735     def recordUnite(self):
 736         #print "recordUnite",self.nom
 737         if self.nom == "POURSUITE":
 738             self.parent.recordUnit(None,self)
 739         else:
 740             if hasattr(self,'fichier_unite') :
 741                 self.parent.recordUnit(self.fichier_unite,self)
 742
 743     def getFileMemo(self, unite=None, fname=None, fic_origine=''):
 744         """Retourne le nom du fichier et le source correspondant a l'unite unite
 745            Initialise en plus recorded_units
 746         """
 747         #print "getFileMemo",unite,fic_origine,self,self.parent
 748         #print self.parent.recorded_units
 749         if unite is None:
 750             # On est dans le cas d'une poursuite. On ne reutilise aucune unite de parent
 751             units={}
 752         else:
 753             # On est dans le cas d'un include. On reutilise toutes les unites de parent
 754             units=self.parent.recorded_units
 755
 756         if unite in self.parent.recorded_units:
 757             f,text,units=self.parent.recorded_units[unite]
 758         elif self.jdc :
 759             if fname:
 760                 if not osp.exists(fname):
 761                     raise AsException(fname + tr(" n'est pas un fichier existant"))
 762                 f = fname
 763                 text = open(fname, 'r').read()
 764             else:
 765                 f,text=self.jdc.getFile(unite=unite, fic_origine=fic_origine)
 766         else:
 767             f,text=None,None
 768
 769         self.recorded_units=units
 770         if f is None and self.jdc.editor:
 771             self.jdc.editor.afficheAlerte(tr("Erreur lors de l'evaluation du fichier inclus"),
 772                   message= tr("Ce fichier ne sera pas pris en compte\nLe fichier associe n'est pas defini"))
 773         return f,text
 774
 775     def updateContext(self,d):
 776         """
 777            Met a jour le contexte contenu dans le dictionnaire d
 778            Une MACRO_ETAPE peut ajouter plusieurs concepts dans le contexte
 779            Une fonction enregistree dans op_init peut egalement modifier le contexte
 780         """
 781         #print ("updateContext",self,self.nom,d.keys())
 782         if hasattr(self,"jdc_aux") and self.jdc_aux:
 783                 #ATTENTION: updateContext NE DOIT PAS appeler resetContext
 784                 # car il appelle directement ou indirectement updateContext
 785                 # equivalent a resetContext. Evite les recursions
 786             self.jdc_aux.context_ini=d.copy()
 787             self.jdc_aux.currentContext={}
 788             self.jdc_aux.index_etape_courante=0
 789             #ATTENTION: il ne faut pas utiliser self.jdc_aux.getContexteAvant
 790             #car cet appel conduit a des remontees multiples incoherentes dans le
 791             # ou les parents.
 792             #get_context_avant appelle updateContext qui NE DOIT PAS appeler getContexteAvant
 793             #On n'a besoin que d'un update local connaissant
 794             # le contexte amont : d qui sert a reinitialiser self.context_ini
 795             for e in self.etapes:
 796                 e.updateContext(d)
 797             return
 798
 799         if type(self.definition.op_init) == types.FunctionType:
 800             self.definition.op_init(*(self,d))
 801         if self.sd != None :d[self.sd.nom]=self.sd
 802         for co in self.sdprods:
 803             d[co.nom]=co
 804         #print "updateContext.fin",d.keys()
 805
 806 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
 807     def copy(self):
 808         etape=Noyau.N_MACRO_ETAPE.MACRO_ETAPE.copy(self)
 809         if hasattr(etape,"etapes") :etape.etapes=[]
 810         if hasattr(etape,"jdc_aux") :
 811             etape.jdc_aux=None
 812             del etape.fichier_ini
 813         return etape
 814
 815     def supprime(self):
 816         #print "supprime",self
 817         if hasattr(self,"jdc_aux") and self.jdc_aux:
 818             self.jdc_aux.supprime_aux()
 819             self.jdc_aux=None
 820         Noyau.N_MACRO_ETAPE.MACRO_ETAPE.supprime(self)
 821
 822 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
 823     def getFile(self,unite=None,fic_origine=''):
 824         """Retourne le nom du fichier et le source correspondant a l'unite unite
 825         """
 826         if self.jdc :
 827             f,text=self.jdc.getFile(unite=unite,fic_origine=fic_origine)
 828         else:
 829             f,text=None,None
 830         return f,text
 831
 832
 833     def makeInclude3(self,fichier=None):
 834         self.makeIncludeCarmel(fichier)
 835
 836
 837     def makeIncludeCND(self,fichier=None):
 838         unite=999
 839         if fichier==None : return
 840         if hasattr(self,'fichier_ini') : print((self.fichier_ini))
 841         if hasattr(self,'fichier_ini') : return
 842         self.fichier_ini=fichier
 843         from acquiertGroupes import getGroupes
 844         erreur,listeGroupes=getGroupes(fichier)
 845         if erreur != "" : print ("a traiter")
 846         texteSources=""
 847         texteCond=""
 848         texteNoCond=""
 849         texteVcut=""
 850         for groupe in listeGroupes :
 851             if groupe[0:8]=='CURRENT_': texteSources +=groupe[8:]+"=SOURCE();\n"
 852             if groupe[0:5]=='COND_':    texteCond    +=groupe[5:]+"=CONDUCTEUR();\n"
 853             if groupe[0:7]=='NOCOND_':  texteNoCond  +=groupe[7:]+"=NOCOND();\n"
 854             #if groupe[0:5]=='VCUT_':    texteVcut    +=groupe[5:]+"=VCUT();\n"
 855             if groupe[0:5]=='VCUT_':    texteVcut    +='V_'+groupe[5:]+"=VCUT();\n"
 856         texte=texteSources+texteCond+texteNoCond+texteVcut
 857         #print (texte)
 858         self.buildIncludeInclude(texte)
 859         if CONTEXT.getCurrentStep()==None : CONTEXT.setCurrentStep(self)
 860         reevalue=0
 861
 862     def makeIncludeCarmel(self,fichier=None):
 863     # Pour Carmel
 864         #print "je suis dans makeIncludeCarmel"
 865         unite=999
 866         if hasattr(self,'fichier_ini') : return
 867         reevalue=0
 868         if hasattr(self,'old_context_fichier_init' ):
 869             reevalue=1
 870             for concept in self.old_context_fichier_init.values():
 871                 self.jdc.deleteConcept(concept)
 872         if fichier == None :
 873             fichier=str(self.jdc.appliEficas.getFile_dictDonnees())
 874             if fichier  == str("") :
 875                 self.fichier_ini="badfile"
 876                 self.fichier_text=""
 877                 self.fichier_err=tr("Le fichier n est pas defini")
 878                 self.parent.recordUnit(999,self)
 879                 try :
 880                     MCFils=self.getChild('FileName')
 881                     MCFils.setValeur(None)
 882                 except :
 883                     pass
 884                 raise EficasException(self.fichier_err)
 885         self.fichier_ini  = fichier
 886         f=open(self.fichier_ini,'r')
 887         self.fichier_text=f.read()
 888         f.close()
 889
 890         self.contexte_fichier_init={}
 891         self.fichier_unite=999
 892         self.fichier_err=None
 893
 894         try:
 895         #if 1 :
 896             import Extensions.jdc_include
 897             self.JdC_aux=Extensions.jdc_include.JdC_include
 898         except:
 899         #else:
 900             traceback.print_exc()
 901             self.makeIncl2Except()
 902             raise EficasException(" ")
 903
 904         try:
 905         #if 1 :
 906             self.makeContexteInclude(self.fichier_ini ,self.fichier_text)
 907             self.old_context_fichier_init=self.contexte_fichier_init
 908             self.parent.recordUnit(unite,self)
 909             try :
 910                 MCFils=self.getChild('FileName')
 911                 #MCFils.setValeur(fichier)
 912                 #on appelle pas setValeur qui modifie le contexte ce qui fout le bazar
 913                 #pas de modification de bloc
 914                 MCFils.valeur=fichier
 915                 MCFils.val=fichier
 916             except :
 917                 pass
 918         except:
 919         #else:
 920             self.makeIncl2Except()
 921         # Cette P*** de ligne suivante ne fonctionne que pour Aster
 922         # si quelqu un a une idee merci de m en parler
 923         #CONTEXT.setCurrentStep(self)
 924
 925     def makeInclude2(self,fichier=None):
 926     # Pour OT
 927         # gestion de l unicite SVP
 928         unite=999
 929
 930         if hasattr(self,'fichier_ini') : return
 931         reevalue=0
 932         if hasattr(self,'old_context_fichier_init' ):
 933             reevalue=1
 934             for concept in self.old_context_fichier_init.values():
 935                 self.jdc.deleteConcept(concept)
 936
 937         if fichier == None :
 938             fichier=str(self.jdc.appliEficas.getFileVariable())
 939             if fichier  == str("") :
 940                 self.fichier_ini="badfile"
 941                 self.fichier_text=""
 942                 self.fichier_err=tr("Le fichier n est pas defini")
 943                 self.parent.recordUnit(999,self)
 944                 try :
 945                     MCFils=self.getChild('FileName')
 946                     MCFils.setValeur(None)
 947                 except :
 948                     pass
 949                 raise EficasException(self.fichier_err)
 950
 951         self.fichier_ini  = fichier
 952         self.fichier_text = ""
 953         self.contexte_fichier_init={}
 954         self.fichier_unite=999
 955         self.fichier_err=None
 956         nbVariableOut=0
 957         try :
 958             from openturns import WrapperFile
 959             monWrapper=WrapperFile(fichier)
 960             data=monWrapper.getWrapperData()
 961             maVariableListe=data.getVariableList()
 962             nbVariables=maVariableListe.getSize()
 963             for i in range(nbVariables) :
 964                 nom=maVariableListe[i].id_
 965                 type=maVariableListe[i].type_
 966                 if type :
 967                         #ligneTexte="%s=DETERMINISTICVARIABLE(N='%s',T='out',R=%d);\n" % (nom, nom, i)
 968                     ligneTexte=""
 969                     nbVariableOut=nbVariableOut+1
 970                 else :
 971                     ligneTexte="%s=DETERMINISTICVARIABLE(N='%s',T='in',R=%d);\n" % (nom, nom, i)
 972                 self.fichier_text = self.fichier_text + ligneTexte
 973         except:
 974             self.makeIncl2Except()
 975             raise EficasException(" ")
 976
 977         if nbVariableOut != 1 :
 978             self.makeIncl2Except(mess=tr("le fichier doit contenir une unique variable de sortie"))
 979             raise EficasException(" ")
 980
 981         try:
 982             import Extensions.jdc_include
 983             self.JdC_aux=Extensions.jdc_include.JdC_include
 984         except:
 985             traceback.print_exc()
 986             self.makeIncl2Except()
 987             raise EficasException(" ")
 988
 989         try:
 990             self.makeContexteInclude(self.fichier_ini ,self.fichier_text)
 991             self.old_context_fichier_init=self.contexte_fichier_init
 992             self.parent.recordUnit(unite,self)
 993             try :
 994                 MCFils=self.getChild('FileName')
 995                 MCFils.setValeur(fichier)
 996             except :
 997                 pass
 998         except:
 999             self.makeIncl2Except()
1000
1001         # recalcul validite pour la matrice eventuelle
1002         if reevalue :
1003             for e in self.jdc.etapes:
1004                 if e.nom == "VARIABLE" :
1005                     e.state="modified"
1006                     try :
1007                         mc=e.getChild('ModelVariable')
1008                         mc.state="modified"
1009                     except :
1010                         pass
1011                 if e.nom == "CORRELATION" :
1012                     e.state="modified"
1013                     try :
1014                         mc=e.getChild('Matrix')
1015                         mc.state="modified"
1016                         mcFeuille=mc.getChild('CorrelationMatrix')
1017                         mcFeuille.state="modified"
1018                     except :
1019                         pass
1020                     e.isValid()
1021
1022     def makeIncl2Except(self,mess=None):
1023         l=traceback.format_exception_only(tr("Fichier invalide"),sys.exc_info()[1])
1024         if self.jdc.editor is not None:
1025             if mess == None :
1026                 self.jdc.editor.afficheAlerte(tr("Erreur lors de l'evaluation du fichier inclus"),
1027                 message= tr("Le contenu de ce fichier ne sera pas pris en compte\n %s",\
1028                                                               ''.join(l)))
1029
1030             else :
1031                 self.jdc.editor.afficheAlerte(tr("Erreur lors de l'evaluation du fichier inclus"),
1032                                        message=tr(mess))
1033         #self.parent.recordUnit(unite,self)
1034         self.g_context={}
1035         self.etapes=[]
1036         self.jdc_aux=None
1037         self.fichier_err = ''.join(l)
1038         self.contexte_fichier_init={}
1039         try :
1040             MCFils=self.getChild('FileName')
1041             MCFils.setValeur(None)
1042         except :
1043             pass
1044
1045
1046 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
1047     #def makeInclude(self, unite=None, fname=None):
1048     def makeInclude(self, unite=None, fname=None):
1049         """
1050             Inclut un fichier dont l'unite logique est unite
1051             Cette methode est appelee par la fonction sd_prod de la macro INCLUDE
1052             Si l'INCLUDE est invalide, la methode doit produire une exception
1053             Sinon on retourne None. Les concepts produits par l'INCLUDE sont
1054             pris en compte par le JDC parent lors du calcul du contexte (appel de ???)
1055         """
1056         # On supprime l'attribut unite qui bloque l'evaluation du source de l'INCLUDE
1057         # car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini
1058         # Si unite n'a pas de valeur, l'etape est forcement invalide. On peut retourner None
1059         #if not unite and not fname:
1060         #    return
1061         # 2020 on supprime unite
1062         #      attention cependant c est utilise pour poursuite
1063         #      PNPN a revoir
1064         if not fname : return
1065
1066         if not hasattr(self,'fichier_ini') :
1067         # Si le fichier n'est pas defini on le demande
1068             f,text=self.getFileMemo(unite=unite, fname=fname, fic_origine=self.parent.nom)
1069             # On memorise le fichier retourne
1070             self.fichier_ini  = f
1071             self.fichier_text = text
1072             self.contexte_fichier_init={}
1073             self.fichier_unite=unite
1074             self.fichier_err=None
1075             try:
1076                 import Extensions.jdc_include
1077             except:
1078                 traceback.print_exc()
1079                 raise EficasException("pb import Extensions")
1080             self.JdC_aux=Extensions.jdc_include.JdC_include
1081
1082             #print "makeInclude",self.fichier_ini,self.fichier_text
1083             if f is None and not text:
1084                 self.fichier_err=tr("Le fichier INCLUDE n est pas defini")
1085                 self.parent.recordUnit(unite,self)
1086                 raise EficasException(self.fichier_err)
1087
1088             try:
1089                 self.makeContexteInclude(self.fichier_ini ,self.fichier_text)
1090                 self.parent.recordUnit(unite,self)
1091             except:
1092                 l=traceback.format_exception_only(tr("Fichier invalide %s",sys.exc_info()[1]))
1093                 if self.jdc.editor:
1094                     self.jdc.editor.afficheAlerte(tr("Erreur lors de l'evaluation du fichier inclus"),
1095                                                   message=tr("Le contenu de ce fichier ne sera pas pris en compte\n"+''.join(l)))
1096                 self.parent.recordUnit(unite,self)
1097                 self.g_context={}
1098                 self.etapes=[]
1099                 self.jdc_aux=None
1100                 self.fichier_err = ''.join(l)
1101                 self.contexte_fichier_init={}
1102                 raise EficasException(" ")
1103
1104         else:
1105             # Si le fichier est deja defini on ne reevalue pas le fichier
1106             # et on leve une exception si une erreur a ete enregistree
1107             self.updateFichierInit(unite)
1108             self.fichier_unite=unite
1109             if self.fichier_err is not None: raise EficasException(self.fichier_err)
1110         #print ('self.g_context', self.g_context)
1111
1112
1113 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
1114     def makeContexte(self,fichier,text):
1115         """
1116             Cette methode sert a creer un contexte pour INCLUDE_MATERIAU
1117             en interpretant un texte source Python
1118             Elle est appelee par la fonction sd_prod d'INCLUDE_MATERIAU
1119         """
1120         #print "makeContexte",fichier
1121         # On supprime l'attribut mat qui bloque l'evaluation du source de l'INCLUDE_MATERIAU
1122         # car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini
1123         if hasattr(self,'mat'):del self.mat
1124         if not hasattr(self,'fichier_ini') or self.fichier_ini != fichier or self.fichier_mater != self.nom_mater:
1125             # le fichier est nouveau ou change
1126             self.fichier_ini =fichier
1127             self.fichier_unite =fichier
1128             self.fichier_mater=self.nom_mater
1129             self.fichier_text=text
1130             self.fichier_err=None
1131             self.contexte_fichier_init={}
1132             # On specifie la classe a utiliser pour le JDC auxiliaire
1133             try:
1134                 import Extensions.jdc_include
1135                 self.JdC_aux=Extensions.jdc_include.JdC_include
1136             except:
1137                 raise EficasException(" ")
1138             try:
1139                 self.makeContexteInclude(self.fichier_ini ,self.fichier_text)
1140                 if not self.nom_mater in self.g_context :
1141                 #Pour permettre de lire un jeu de commandes avec des INCLUDE_MATERIAU errones
1142                     self.g_context[self.nom_mater]=None
1143                     if self.parent: self.parent.g_context[self.nom_mater]=None
1144             except:
1145                 l=traceback.format_exception_only(tr("Fichier invalide %s",sys.exc_info()[1]))
1146                 self.fichier_err = ''.join(l)
1147                 self.g_context={}
1148                 #Pour permettre de lire un jeu de commandes avec des INCLUDE_MATERIAU errones
1149                 if self.parent:
1150                     self.parent.g_context[self.nom_mater]=None
1151                 self.g_context[self.nom_mater]=None
1152                 #-------------
1153                 self.etapes=[]
1154                 self.jdc_aux=None
1155                 self.contexte_fichier_init={}
1156                 raise EficasException(" ")
1157         else:
1158             # le fichier est le meme on ne le reevalue pas
1159             # et on leve une exception si une erreur a ete enregistree
1160             if self.fichier_err is not None: raise EficasException(self.fichier_err)
1161
1162 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
1163     def updateSdprod(self,cr='non'):
1164         # Cette methode peut etre appelee dans EFICAS avec des mots cles de
1165         # la commande modifies. Ceci peut conduire a la construction ou
1166         # a la reconstruction d'etapes dans le cas d'INCLUDE ou d'INCLUDE_MATERIAU
1167         # Il faut donc positionner le current_step avant l'appel
1168         CONTEXT.unsetCurrentStep()
1169         CONTEXT.setCurrentStep(self)
1170         valid=Validation.V_MACRO_ETAPE.MACRO_ETAPE.updateSdprod(self,cr=cr)
1171         CONTEXT.unsetCurrentStep()
1172         return valid
1173
1174 #ATTENTION SURCHARGE: cette methode surcharge celle de Noyau a garder en synchro
1175     def buildSd(self,nom):
1176         """
1177              Methode de Noyau surchargee pour poursuivre malgre tout
1178              si une erreur se produit pendant la creation du concept produit
1179         """
1180         try:
1181             sd=Noyau.N_MACRO_ETAPE.MACRO_ETAPE.buildSd(self,nom)
1182         except :
1183         #   return None
1184         #except AsException,e:
1185             # Une erreur s'est produite lors de la construction du concept
1186             # Comme on est dans EFICAS, on essaie de poursuivre quand meme
1187             # Si on poursuit, on a le choix entre deux possibilites :
1188             # 1. on annule la sd associee a self
1189             # 2. on la conserve mais il faut la retourner
1190             # On choisit de l'annuler
1191             # En plus il faut rendre coherents sdnom et sd.nom
1192             self.sd=None
1193             self.sdnom=None
1194             self.state="unchanged"
1195             self.valid=0
1196
1197         return self.sd
1198
1199 #ATTENTION SURCHARGE: cette methode surcharge celle de Noyau a garder en synchro
1200     def makePoursuite(self):
1201         """ Cette methode est appelee par la fonction sd_prod de la macro POURSUITE
1202         """
1203         #print "makePoursuite"
1204         if not hasattr(self,'fichier_ini') :
1205             # Si le fichier n'est pas defini on le demande
1206             f,text=self.getFileMemo(fic_origine=self.parent.nom)
1207             # On memorise le fichier retourne
1208             self.fichier_ini = f
1209             self.fichier_unite = None
1210             self.fichier_text = text
1211             self.fichier_err=None
1212             try:
1213                 import Extensions.jdc_include
1214             except:
1215                 traceback.print_exc()
1216                 raise EficasException(" ")
1217             self.JdC_aux=Extensions.jdc_include.JdC_poursuite
1218             self.contexte_fichier_init={}
1219             #print "makePoursuite",self.fichier_ini,self.fichier_text
1220
1221             if f is None:
1222                 self.fichier_err="Le fichier POURSUITE n'est pas defini"
1223                 self.jdc_aux=None
1224                 self.parent.recordUnit(None,self)
1225                 raise EficasException(self.fichier_err)
1226
1227             try:
1228                 self.makeContexteInclude(self.fichier_ini,self.fichier_text)
1229                 self.parent.recordUnit(None,self)
1230             except:
1231                 l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
1232                 if self.jdc.editor:
1233                     self.jdc.editor.afficheAlerte(tr("Erreur lors de l'evaluation du fichier poursuite"),
1234                                                   message=tr("Ce fichier ne sera pas pris en compte\n %s",''.join(l)))
1235                 self.parent.recordUnit(None,self)
1236                 self.g_context={}
1237                 self.etapes=[]
1238                 self.jdc_aux=None
1239                 self.fichier_err = ''.join(l)
1240                 self.contexte_fichier_init={}
1241                 raise EficasException(" ")
1242
1243         else:
1244             # Si le fichier est deja defini on ne reevalue pas le fichier
1245             # et on leve une exception si une erreur a ete enregistree
1246             self.updateFichierInit(None)
1247             if self.fichier_err is not None: raise EficasException(self.fichier_err)