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)