X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=Ihm%2FI_MACRO_ETAPE.py;h=b3c03efb4153659ef73f53d381712c2c2fe86a55;hb=217a9ce2f303b098ad28d282bb0df2dfeeeed3c2;hp=7e58aa0382e47413e2ccb7055ebe1d43bc0f1501;hpb=69ed0ccae7884aee37bbe54cb1af2983cb51492d;p=tools%2Feficas.git diff --git a/Ihm/I_MACRO_ETAPE.py b/Ihm/I_MACRO_ETAPE.py index 7e58aa03..b3c03efb 100644 --- a/Ihm/I_MACRO_ETAPE.py +++ b/Ihm/I_MACRO_ETAPE.py @@ -1,51 +1,57 @@ -# -*- coding: utf-8 -*- -# CONFIGURATION MANAGEMENT OF EDF VERSION -# ====================================================================== -# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG -# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY -# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY -# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR -# (AT YOUR OPTION) ANY LATER VERSION. +# -*- coding: iso-8859-1 -*- +# Copyright (C) 2007-2013 EDF R&D # -# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License. # -# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE -# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, -# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. # +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # -# ====================================================================== """ """ # Modules Python +from __future__ import absolute_import +from __future__ import print_function import sys -import traceback,types,string +import os.path as osp +import traceback,types # Modules Eficas -import I_ETAPE -import I_ENTITE -import I_OBJECT +from Extensions.i18n import tr +from Extensions.eficas_exception import EficasException +from . import I_ETAPE +from . import I_ENTITE +from . import I_OBJECT import Noyau from Noyau.N_ASSD import ASSD from Noyau import N__F import convert from Extensions import param2 -# import rajoutés suite à l'ajout de Build_sd --> à résorber +# import rajoutes suite a l'ajout de Build_sd --> a resorber import Noyau, Validation.V_MACRO_ETAPE from Noyau import N_Exception from Noyau.N_Exception import AsException import Accas # attention aux imports circulaires -# fin import à résorber +import six +from six.moves import range +# fin import a resorber class MACRO_ETAPE(I_ETAPE.ETAPE): def __init__(self): self.typret=None - #indique si le jeu de commande inclus a pu etre analysé par convert + #indique si le jeu de commande inclus a pu etre analyse par convert #pour etre editable (0=NON, 1=OUI) self.text_converted=1 self.text_error="" @@ -61,24 +67,25 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): if co.nom == nom_sd:return co if type(self.definition.op_init) == types.FunctionType: d={} - apply(self.definition.op_init,(self,d)) + self.definition.op_init(*(self,d)) return d.get(nom_sd,None) return None def get_contexte_jdc(self,fichier,text): """ - Interprète text comme un texte de jdc et retourne le contexte final. + Interprete text comme un texte de jdc et retourne le contexte final. - Le contexte final est le dictionnaire des sd disponibles à la dernière étape. + Le contexte final est le dictionnaire des sd disponibles a la derniere etape. Si text n'est pas un texte de jdc valide, retourne None ou leve une exception - --> utilisée par ops.POURSUITE et INCLUDE + --> utilisee par ops.POURSUITE et INCLUDE """ - #print "get_contexte_jdc",self,self.nom + print ("get_contexte_jdc",self,self.nom) # On recupere l'etape courante step=CONTEXT.get_current_step() try: - # on essaie de créer un objet JDC auxiliaire avec un contexte initial + #if 1 : + # on essaie de creer un objet JDC auxiliaire avec un contexte initial # Attention get_contexte_avant retourne un dictionnaire qui contient # le contexte courant. Ce dictionnaire est reactualise regulierement. # Si on veut garder l'etat du contexte fige, il faut en faire une copie. @@ -91,7 +98,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): prefix_include=None if hasattr(self,'prefix'): prefix_include=self.prefix - # ATTENTION : le dictionnaire recorded_units sert à memoriser les unites des + # ATTENTION : le dictionnaire recorded_units sert a memoriser les unites des # fichiers inclus. Il est preferable de garder le meme dictionnaire pendant # tout le traitement et de ne pas le reinitialiser brutalement (utiliser # clear plutot) si on ne veut pas perdre la memoire des unites. @@ -111,22 +118,25 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): self.text_error="" if self.nom != "INCLUDE_MATERIAU": if self.parent.appli.ihm == "QT" : - format=self.jdc.appli.format_fichier + format=self.parent.appli.appliEficas.format_fichier else : format=self.jdc.appli.format_fichier.get() - if convert.plugins.has_key(format): + #on force a python pour Carmel + if format=="CARMEL3D" : format="python" + if format in convert.plugins : # Le convertisseur existe on l'utilise p=convert.plugins[format]() p.text=text text=p.convert('exec',self.jdc.appli) #Si le fichier ne peut pas etre converti, le cr n'est pas vide - #et le texte est retourné tel que + #et le texte est retourne tel que if not p.cr.estvide(): self.text_converted=0 self.text_error=str(p.cr) else: self.text_converted=1 + j=self.JdC_aux( procedure=text, nom=fichier, appli=self.jdc.appli, cata=self.jdc.cata, @@ -138,10 +148,13 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): old_recorded_units=old_recorded_units,**args) j.analyse() - # On récupère les étapes internes (pour validation) + # On recupere les etapes internes (pour validation) self.etapes=j.etapes self.jdc_aux=j + self.jdc.jdcDict=self.jdc_aux + except: + #else : traceback.print_exc() # On retablit l'etape courante step CONTEXT.unset_current_step() @@ -153,21 +166,24 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): # mais on n'insere pas les concepts # On retablit l'etape courante step #print j.cr + #print j.isvalid() CONTEXT.unset_current_step() CONTEXT.set_current_step(step) - raise Exception("Impossible de relire le fichier\n"+str(j.cr)) + raise EficasException(tr("Impossible de relire le fichier %s \n ")+ six.text_type(j.cr)) + if not j.isvalid(): # L'INCLUDE n'est pas valide. # on produit un rapport d'erreurs cr=j.report() - #print cr # On retablit l'etape courante step CONTEXT.unset_current_step() CONTEXT.set_current_step(step) - raise Exception("Le fichier include contient des erreurs\n"+str(cr)) + self.jdc.cr.fatal("Le fichier include contient des erreurs ") + raise EficasException(tr("Le fichier include contient des erreurs ")) - # Si aucune erreur rencontrée + + # Si aucune erreur rencontree # On recupere le contexte de l'include verifie try: j_context=j.get_verif_contexte() @@ -177,27 +193,27 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): # On retablit l'etape courante step CONTEXT.unset_current_step() CONTEXT.set_current_step(step) - raise + raise EficasException(" ") - # Si on est arrivé ici, le texte du fichier inclus (INCLUDE, POURSUITE, ...) - # est valide et insérable dans le JDC + # Si on est arrive ici, le texte du fichier inclus (INCLUDE, POURSUITE, ...) + # est valide et inserable dans le JDC # On remplit le dictionnaire des concepts produits inclus - # en retirant les concepts présents dans le contexte initial + # en retirant les concepts presents dans le contexte initial # On ajoute egalement le concept produit dans le sds_dict du parent - # sans verification car on est sur (verification integrée) que + # sans verification car on est sur (verification integree) que # le nommage est possible self.g_context.clear() for k,v in j_context.items(): - if not context_ini.has_key(k) or context_ini[k] != v: + if (not k in context_ini) or (context_ini[k] != v): self.g_context[k]=v self.parent.sds_dict[k]=v - #Ce traitement n'est réalisé que dans les cas suivants: + #Ce traitement n'est realise que dans les cas suivants: # - si convert n'a pas pu convertir le jeu de commandes # - et ce n'est pas un INCLUDE_MATERIAU #On collecte les variables Python qui ne sont pas dans le contexte initial - #et dans le contexte validé et on en fait un pseudo-parametre (Variable) + #et dans le contexte valide et on en fait un pseudo-parametre (Variable) if self.text_converted == 0 and self.nom != "INCLUDE_MATERIAU": for k,v in j.g_context.items(): if k in context_ini:continue @@ -208,6 +224,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): if callable(v):continue self.g_context[k]=param2.Variable(k,v) + print ('kljkljkljlkjklj') # On recupere le contexte courant self.current_context=j.current_context self.index_etape_courante=j.index_etape_courante @@ -217,12 +234,13 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): CONTEXT.unset_current_step() CONTEXT.set_current_step(step) + print ('kljkljkljlkjklj') return j_context def reevalue_sd_jdc(self): """ - Avec la liste des SD qui ont été supprimées, propage la - disparition de ces SD dans toutes les étapes et descendants + Avec la liste des SD qui ont ete supprimees, propage la + disparition de ces SD dans toutes les etapes et descendants """ #print "reevalue_sd_jdc" l_sd_supp,l_sd_repl = self.diff_contextes() @@ -233,7 +251,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): def diff_contextes(self): """ - Réalise la différence entre les 2 contextes + Realise la difference entre les 2 contextes old_contexte_fichier_init et contexte_fichier_init cad retourne la liste des sd qui ont disparu ou ne derivent pas de la meme classe et des sd qui ont ete remplacees @@ -241,8 +259,8 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): if not hasattr(self,'old_contexte_fichier_init'):return [],[] l_sd_suppressed = [] l_sd_replaced = [] - for old_key in self.old_contexte_fichier_init.keys(): - if not self.contexte_fichier_init.has_key(old_key): + for old_key in self.old_contexte_fichier_init: + if not old_key in self.contexte_fichier_init: if isinstance(self.old_contexte_fichier_init[old_key],ASSD): l_sd_suppressed.append(self.old_contexte_fichier_init[old_key]) else: @@ -266,7 +284,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): """ #print "I_MACRO_ETAPE.control_sdprods",d.keys(),self.nom,self.sd and self.sd.nom if self.sd: - if d.has_key(self.sd.nom): + if self.sd.nom in d: # Le concept est deja defini if self.reuse and self.reuse is d[self.sd.nom]: # Le concept est reutilise : situation normale @@ -286,8 +304,8 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): sdprods=self.sdprods[:] self.sdprods=[] for co in sdprods: - if d.has_key(co.nom) and co is not d[co.nom] : - #nettoie les mots cles de l'étape qui ont comme valeur co + if co.nom in d and co is not d[co.nom] : + #nettoie les mots cles de l'etape qui ont comme valeur co self.delete_concept(co) #supprime les references a co dans les etapes suivantes self.parent.delete_concept_after_etape(self,co) @@ -322,19 +340,19 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): def supprime_sdprods(self): """ Fonction: Lors de la destruction de la macro-etape, detruit tous les concepts produits - Un opérateur n a qu un concept produit + Un operateur n a qu un concept produit Une procedure n'en a aucun - Une macro en a en général plus d'un + Une macro en a en general plus d'un """ #print "supprime_sdprods" if self.reuse is not self.sd : - # l'étape n'est pas réentrante - # le concept retourné par l'étape est à supprimer car il était - # créé par l'étape + # l'etape n'est pas reentrante + # le concept retourne par l'etape est a supprimer car il etait + # cree par l'etape if self.sd != None : self.parent.del_sdprod(self.sd) self.parent.delete_concept(self.sd) - # On détruit les concepts à droite du signe = + # On detruit les concepts a droite du signe = for co in self.sdprods: self.parent.del_sdprod(co) self.parent.delete_concept(co) @@ -343,7 +361,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): if not isinstance(co,ASSD):continue self.parent.del_sdprod(co) self.parent.delete_concept(co) - # On met g_context à blanc + # On met g_context a blanc self.g_context={} def close(self): @@ -365,7 +383,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): def delete_concept(self,sd): """ Fonction : Mettre a jour les mots cles de l etape et eventuellement - le concept produit si reuse suite à la disparition du concept sd + le concept produit si reuse suite a la disparition du concept sd Seuls les mots cles simples MCSIMP font un traitement autre que de transmettre aux fils """ @@ -386,10 +404,9 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): def change_fichier_init(self,new_fic,text): """ - Tente de changer le fichier include. Le precedent include est conservé + Tente de changer le fichier include. Le precedent include est conserve dans old_xxx """ - #print "change_fichier_init",new_fic if not hasattr(self,'fichier_ini'): self.fichier_ini=None self.fichier_text=None @@ -415,18 +432,18 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): try: self.make_contexte_include(new_fic,text) except: - l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1]) - self.fichier_err=string.join(l) - raise + l=traceback.format_exception_only(tr("Fichier invalide %s", sys.exc_info()[1])) + self.fichier_err=''.join(l) + raise EficasException(self.fichier_err) - # L'evaluation de text dans un JDC auxiliaire s'est bien passé + # L'evaluation de text dans un JDC auxiliaire s'est bien passe # on peut poursuivre le traitement self.init_modif() self.state="undetermined" self.fichier_err=None # On enregistre la modification de fichier self.record_unite() - # Le contexte du parent doit etre reinitialise car les concepts produits ont changé + # Le contexte du parent doit etre reinitialise car les concepts produits ont change self.parent.reset_context() # Si des concepts ont disparu lors du changement de fichier, on demande leur suppression @@ -456,15 +473,15 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): # Reinitialisation complete du compte-rendu d'erreurs self.jdc_aux.cr=self.jdc_aux.CR() # On remplit le dictionnaire des concepts produits inclus - # en retirant les concepts présents dans le contexte initial + # en retirant les concepts presents dans le contexte initial # On ajoute egalement le concept produit dans le sds_dict du parent - # sans verification car on est sur (verification integrée) que + # sans verification car on est sur (verification integree) que # le nommage est possible j_context=self.jdc_aux.get_contexte_avant(None) self.g_context.clear() context_ini=self.jdc_aux.context_ini for k,v in j_context.items(): - if not context_ini.has_key(k) or context_ini[k] != v: + if not k in context_ini or context_ini[k] != v: self.g_context[k]=v self.parent.sds_dict[k]=v # On recupere le contexte courant @@ -477,7 +494,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): self.init_modif() self.state="undetermined" self.record_unite() - # Le contexte du parent doit etre reinitialise car les concepts produits ont changé + # Le contexte du parent doit etre reinitialise car les concepts produits ont change self.parent.reset_context() # On remplace les anciens concepts par les nouveaux (y compris ajouts @@ -507,10 +524,34 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): self.recorded_units={} self.build_jdcaux(fichier,text) + + + def build_includeInclude(self,text): + import Extensions.jdc_include + self.JdC_aux=Extensions.jdc_include.JdC_include + # un include partage la table des unites avec son parent (jdc) + self.build_jdcauxInclude(text) + + + def build_jdcauxInclude(self,text): + + try : + contexte = self.get_contexte_jdc(None,text) + except EficasException: + pass + index=self.jdc.etapes.index(self) + for e in self.etapes: + e.niveau=self.niveau + self.jdc.etapes=self.jdc.etapes[:index+1]+self.etapes+self.jdc.etapes[index+1:] + self.g_context={} + self.etapes=[] + self.jdc_aux=None + CONTEXT.unset_current_step() + def build_jdcaux(self,fichier,text): """ Cree un jdc auxiliaire initialise avec text. - Initialise le nom du fichier associé avec fichier + Initialise le nom du fichier associe avec fichier N'enregistre pas d'association unite <-> fichier """ self.fichier_ini = fichier @@ -522,46 +563,48 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): if contexte is None : # Impossible de construire le jdc auxiliaire (sortie par None) # On simule une sortie par exception - raise Exception("Impossible de construire le jeu de commandes correspondant au fichier") + raise EficasException(tr("Impossible de construire le jeu de commandes correspondant au fichier")) else: - # La construction du jdc auxiliaire est allée au bout + # La construction du jdc auxiliaire est allee au bout self.contexte_fichier_init = contexte self.init_modif() self.fin_modif() except: # Impossible de construire le jdc auxiliaire (sortie par exception) l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1]) - if self.jdc.appli: - self.jdc.appli.affiche_alerte("Erreur lors de l'evaluation du fichier inclus", - message="Ce fichier ne sera pas pris en compte\n"+string.join(l) - ) + if self.jdc.appli is not None: + self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"), + message= tr("Ce fichier ne sera pas pris en compte\n %s",''.join(l))) + self.g_context={} self.etapes=[] self.jdc_aux=None - self.fichier_err = string.join(l) + self.fichier_err = ''.join(l) self.contexte_fichier_init={} self.init_modif() self.fin_modif() - raise + raise EficasException(" ") def make_contexte_include(self,fichier,text): """ - Cette méthode sert à créer un contexte en interprétant un texte source Python. + Cette methode sert a craer un contexte en interpratant un texte source Python. """ - #print "make_contexte_include",fichier - # on récupère le contexte d'un nouveau jdc dans lequel on interprete text + print ("make_contexte_include",fichier) + # on recupere le contexte d'un nouveau jdc dans lequel on interprete text contexte = self.get_contexte_jdc(fichier,text) + print ("make_contexte_include",fichier) if contexte == None : - raise Exception("Impossible de construire le jeu de commandes correspondant au fichier") + raise EficasException("Impossible de construire le jeu de commandes correspondant au fichier") else: # Pour les macros de type include : INCLUDE, INCLUDE_MATERIAU et POURSUITE # l'attribut g_context est un dictionnaire qui contient les concepts produits par inclusion # l'attribut contexte_fichier_init est un dictionnaire qui contient les concepts produits # en sortie de macro. g_context est obtenu en retirant de contexte_fichier_init les concepts # existants en debut de macro contenus dans context_ini (dans get_contexte_jdc) - # g_context est utilisé pour avoir les concepts produits par la macro - # contexte_fichier_init est utilisé pour avoir les concepts supprimés par la macro + # g_context est utilise pour avoir les concepts produits par la macro + # contexte_fichier_init est utilise pour avoir les concepts supprimes par la macro self.contexte_fichier_init = contexte + print ("fin make_contexte_include",fichier) def reevalue_fichier_init_OBSOLETE(self): """Recalcule les concepts produits par le fichier enregistre""" @@ -571,7 +614,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): self.make_contexte_include(self.fichier_ini ,self.fichier_text) except: l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1]) - self.fichier_err = string.join(l) + self.fichier_err = ''.join(l) self.g_context={} self.etapes=[] self.jdc_aux=None @@ -588,8 +631,8 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): def update_fichier_init(self,unite): """Reevalue le fichier init sans demander (dans la mesure du possible) a l'utilisateur les noms des fichiers - Ceci suppose que les relations entre unites et noms ont été memorisees préalablement - L'include a été initialisé précédemment. Le jdc auxiliaire existe. + Ceci suppose que les relations entre unites et noms ont ete memorisees prealablement + L'include a ete initialise precedemment. Le jdc auxiliaire existe. """ #print "update_fichier_init",unite,self.fichier_unite self.old_contexte_fichier_init=self.contexte_fichier_init @@ -600,21 +643,21 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): #print "update_fichier_init",self,self.parent,self.parent.recorded_units if self.fichier_unite is None: - # L'unité n'était pas définie précédemment. On ne change que l'unite + # L'unite n'etait pas definie precedemment. On ne change que l'unite #print "update_fichier_init","pas de changement dans include" self.fichier_unite=unite return elif unite == self.fichier_unite : - # L'unité n'a pas changé + # L'unite n'a pas change #print "update_fichier_init","pas de changement dans include 3" return elif unite != self.fichier_unite : - # L'unité était définie précédemment. On remplace l'include + # L'unite etait definie precedemment. On remplace l'include # f,text=self.get_file_memo(unite=unite,fic_origine=self.parent.nom) if f is None: - # Le fichier associé n'a pas pu etre defini - # on change l'unite associée mais pas l'include + # Le fichier associe n'a pas pu etre defini + # on change l'unite associee mais pas l'include #print "update_fichier_init","pas de changement dans include 2" self.fichier_unite=unite return @@ -627,7 +670,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): #print "update_fichier_init",self.fichier_ini,self.fichier_text,self.fichier_unite if old_fichier_ini == self.fichier_ini: - # Le fichier inclus n'a pas changé. On ne recrée pas le contexte + # Le fichier inclus n'a pas change. On ne recree pas le contexte # mais on enregistre le changement d'association unite <-> fichier #print "update_fichier_init.fichier inchange",self.jdc_aux.context_ini self.parent.record_unit(unite,self) @@ -643,8 +686,8 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1]) # On conserve la memoire du nouveau fichier # mais on n'utilise pas les concepts crees par ce fichier - # on met l'etape en erreur : fichier_err=string.join(l) - self.fichier_err=string.join(l) + # on met l'etape en erreur : fichier_err=''.join(l) + self.fichier_err=''.join(l) self.g_context={} self.etapes=[] self.jdc_aux=None @@ -654,7 +697,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): old_jdc_aux.close() self.parent.record_unit(unite,self) # Le contexte du parent doit etre reinitialise car les concepts - # produits ont changé + # produits ont change self.parent.reset_context() # Si des concepts ont disparu lors du changement de fichier, on # demande leur suppression @@ -669,7 +712,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): if hasattr(self,'fichier_unite') : self.parent.record_unit(self.fichier_unite,self) - def get_file_memo(self,unite=None,fic_origine=''): + def get_file_memo(self, unite=None, fname=None, fic_origine=''): """Retourne le nom du fichier et le source correspondant a l'unite unite Initialise en plus recorded_units """ @@ -682,22 +725,28 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): # On est dans le cas d'un include. On reutilise toutes les unites de parent units=self.parent.recorded_units - if self.parent.recorded_units.has_key(unite): + if unite in self.parent.recorded_units: f,text,units=self.parent.recorded_units[unite] elif self.jdc : - f,text=self.jdc.get_file(unite=unite,fic_origine=fic_origine) + if fname: + if not osp.exists(fname): + raise AsException(fname + tr(" n'est pas un fichier existant")) + f = fname + text = open(fname, 'r').read() + else: + f,text=self.jdc.get_file(unite=unite, fic_origine=fic_origine) else: f,text=None,None self.recorded_units=units if f is None and self.jdc.appli: - self.jdc.appli.affiche_alerte("Erreur lors de l'evaluation du fichier inclus", - message="Ce fichier ne sera pas pris en compte\n"+"Le fichier associé n'est pas défini") + self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"), + message= tr("Ce fichier ne sera pas pris en compte\nLe fichier associe n'est pas defini")) return f,text def update_context(self,d): """ - Met à jour le contexte contenu dans le dictionnaire d + Met a jour le contexte contenu dans le dictionnaire d Une MACRO_ETAPE peut ajouter plusieurs concepts dans le contexte Une fonction enregistree dans op_init peut egalement modifier le contexte """ @@ -710,7 +759,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): self.jdc_aux.current_context={} self.jdc_aux.index_etape_courante=0 #ATTENTION: il ne faut pas utiliser self.jdc_aux.get_contexte_avant - #car cet appel conduit a des remontées multiples incohérentes dans le + #car cet appel conduit a des remontees multiples incoherentes dans le # ou les parents. #get_context_avant appelle update_context qui NE DOIT PAS appeler get_contexte_avant #On n'a besoin que d'un update local connaissant @@ -720,7 +769,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): return if type(self.definition.op_init) == types.FunctionType: - apply(self.definition.op_init,(self,d)) + self.definition.op_init(*(self,d)) if self.sd != None:d[self.sd.nom]=self.sd for co in self.sdprods: d[co.nom]=co @@ -741,12 +790,6 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): self.jdc_aux.supprime_aux() self.jdc_aux=None Noyau.N_MACRO_ETAPE.MACRO_ETAPE.supprime(self) - # self.contexte_fichier_init={} - # self.old_contexte_fichier_init={} - # self.g_context={} - # self.current_context={} - # self.etapes=[] - # self.mc_liste=[] #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro) def get_file(self,unite=None,fic_origine=''): @@ -758,8 +801,224 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): f,text=None,None return f,text + + def make_include3(self,fichier=None): + self.make_includeCarmel(fichier) + + + def make_includeCND(self,fichier=None): + unite=999 + if fichier==None : return + if hasattr(self,'fichier_ini') : print((self.fichier_ini)) + if hasattr(self,'fichier_ini') : return + self.fichier_ini=fichier + from acquiertGroupes import getGroupes + erreur,listeGroupes=getGroupes(fichier) + if erreur != "" : print ("a traiter") + texteSources="" + texteCond="" + texteNoCond="" + texteVcut="" + for groupe in listeGroupes : + if groupe[0:8]=='CURRENT_': texteSources +=groupe[8:]+"=SOURCE();\n" + if groupe[0:5]=='COND_': texteCond +=groupe[5:]+"=CONDUCTEUR();\n" + if groupe[0:7]=='NOCOND_': texteNoCond +=groupe[7:]+"=NOCOND();\n" + #if groupe[0:5]=='VCUT_': texteVcut +=groupe[5:]+"=VCUT();\n" + if groupe[0:5]=='VCUT_': texteVcut +='V_'+groupe[5:]+"=VCUT();\n" + texte=texteSources+texteCond+texteNoCond+texteVcut + #print (texte) + self.build_includeInclude(texte) + if CONTEXT.get_current_step()==None : CONTEXT.set_current_step(self) + reevalue=0 + + def make_includeCarmel(self,fichier=None): + # Pour Carmel + #print "je suis dans make_includeCarmel" + unite=999 + if hasattr(self,'fichier_ini') : return + reevalue=0 + if hasattr(self,'old_context_fichier_init' ): + reevalue=1 + for concept in self.old_context_fichier_init.values(): + self.jdc.delete_concept(concept) + if fichier == None : + fichier=str(self.jdc.appli.get_file_dictDonnees()) + if fichier == str("") : + self.fichier_ini="badfile" + self.fichier_text="" + self.fichier_err=tr("Le fichier n est pas defini") + self.parent.record_unit(999,self) + try : + MCFils=self.get_child('FileName') + MCFils.set_valeur(None) + except : + pass + raise EficasException(self.fichier_err) + self.fichier_ini = fichier + f=open(self.fichier_ini,'r') + self.fichier_text=f.read() + f.close() + + self.contexte_fichier_init={} + self.fichier_unite=999 + self.fichier_err=None + + try: + #if 1 : + import Extensions.jdc_include + self.JdC_aux=Extensions.jdc_include.JdC_include + except: + #else: + traceback.print_exc() + self.make_incl2_except() + raise EficasException(" ") + + try: + #if 1 : + self.make_contexte_include(self.fichier_ini ,self.fichier_text) + self.old_context_fichier_init=self.contexte_fichier_init + self.parent.record_unit(unite,self) + try : + MCFils=self.get_child('FileName') + #MCFils.set_valeur(fichier) + #on appelle pas set_valeur qui modifie le contexte ce qui fout le bazar + #pas de modification de bloc + MCFils.valeur=fichier + MCFils.val=fichier + except : + pass + except: + #else: + self.make_incl2_except() + # Cette P*** de ligne suivante ne fonctionne que pour Aster + # si quelqu un a une idee merci de m en parler + #CONTEXT.set_current_step(self) + + def make_include2(self,fichier=None): + # Pour OT + # gestion de l unicite SVP + unite=999 + + if hasattr(self,'fichier_ini') : return + reevalue=0 + if hasattr(self,'old_context_fichier_init' ): + reevalue=1 + for concept in self.old_context_fichier_init.values(): + self.jdc.delete_concept(concept) + + if fichier == None : + fichier=str(self.jdc.appli.get_file_variable()) + if fichier == str("") : + self.fichier_ini="badfile" + self.fichier_text="" + self.fichier_err=tr("Le fichier n est pas defini") + self.parent.record_unit(999,self) + try : + MCFils=self.get_child('FileName') + MCFils.set_valeur(None) + except : + pass + raise EficasException(self.fichier_err) + + self.fichier_ini = fichier + self.fichier_text = "" + self.contexte_fichier_init={} + self.fichier_unite=999 + self.fichier_err=None + nbVariableOut=0 + try : + from openturns import WrapperFile + monWrapper=WrapperFile(fichier) + data=monWrapper.getWrapperData() + maVariableListe=data.getVariableList() + nbVariables=maVariableListe.getSize() + for i in range(nbVariables) : + nom=maVariableListe[i].id_ + type=maVariableListe[i].type_ + if type : + #ligneTexte="%s=DETERMINISTICVARIABLE(N='%s',T='out',R=%d);\n" % (nom, nom, i) + ligneTexte="" + nbVariableOut=nbVariableOut+1 + else : + ligneTexte="%s=DETERMINISTICVARIABLE(N='%s',T='in',R=%d);\n" % (nom, nom, i) + self.fichier_text = self.fichier_text + ligneTexte + except: + self.make_incl2_except() + raise EficasException(" ") + + if nbVariableOut != 1 : + print((nbVariableOut ,"nbVariableOut")) + self.make_incl2_except(mess=tr("le fichier doit contenir une unique variable de sortie")) + raise EficasException(" ") + + try: + import Extensions.jdc_include + self.JdC_aux=Extensions.jdc_include.JdC_include + except: + traceback.print_exc() + self.make_incl2_except() + raise EficasException(" ") + + try: + print((self.fichier_ini ,self.fichier_text)) + self.make_contexte_include(self.fichier_ini ,self.fichier_text) + self.old_context_fichier_init=self.contexte_fichier_init + self.parent.record_unit(unite,self) + try : + MCFils=self.get_child('FileName') + MCFils.set_valeur(fichier) + except : + pass + except: + self.make_incl2_except() + + # recalcul validite pour la matrice eventuelle + if reevalue : + for e in self.jdc.etapes: + if e.nom == "VARIABLE" : + e.state="modified" + try : + mc=e.get_child('ModelVariable') + mc.state="modified" + except : + pass + if e.nom == "CORRELATION" : + e.state="modified" + try : + mc=e.get_child('Matrix') + mc.state="modified" + mcFeuille=mc.get_child('CorrelationMatrix') + mcFeuille.state="modified" + except : + pass + e.isvalid() + + def make_incl2_except(self,mess=None): + l=traceback.format_exception_only(tr("Fichier invalide"),sys.exc_info()[1]) + if self.jdc.appli is not None: + if mess == None : + self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"), + message= tr("Le contenu de ce fichier ne sera pas pris en compte\n %s",\ + ''.join(l))) + + else : + self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"), + message=tr(mess)) + #self.parent.record_unit(unite,self) + self.g_context={} + self.etapes=[] + self.jdc_aux=None + self.fichier_err = ''.join(l) + self.contexte_fichier_init={} + try : + MCFils=self.get_child('FileName') + MCFils.set_valeur(None) + except : + pass + + #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro) - def make_include(self,unite=None): + def make_include(self, unite=None, fname=None): """ Inclut un fichier dont l'unite logique est unite Cette methode est appelee par la fonction sd_prod de la macro INCLUDE @@ -771,11 +1030,12 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): # On supprime l'attribut unite qui bloque l'evaluation du source de l'INCLUDE # car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini # Si unite n'a pas de valeur, l'etape est forcement invalide. On peut retourner None - if not unite : return + if not unite and not fname: + return if not hasattr(self,'fichier_ini') : # Si le fichier n'est pas defini on le demande - f,text=self.get_file_memo(unite=unite,fic_origine=self.parent.nom) + f,text=self.get_file_memo(unite=unite, fname=fname, fic_origine=self.parent.nom) # On memorise le fichier retourne self.fichier_ini = f self.fichier_text = text @@ -786,46 +1046,44 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): import Extensions.jdc_include except: traceback.print_exc() - raise + raise EficasException("pb import Extensions") self.JdC_aux=Extensions.jdc_include.JdC_include #print "make_include",self.fichier_ini,self.fichier_text if f is None and not text: - self.fichier_err="Le fichier INCLUDE n est pas defini" + self.fichier_err=tr("Le fichier INCLUDE n est pas defini") self.parent.record_unit(unite,self) - raise Exception(self.fichier_err) + raise EficasException(self.fichier_err) try: self.make_contexte_include(self.fichier_ini ,self.fichier_text) self.parent.record_unit(unite,self) - #print "make_include.context_ini",self.jdc_aux.context_ini except: - l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1]) + l=traceback.format_exception_only(tr("Fichier invalide %s",sys.exc_info()[1])) if self.jdc.appli: - self.jdc.appli.affiche_alerte("Erreur lors de l'evaluation du fichier inclus", - message="Le contenu de ce fichier ne sera pas pris en compte\n"+string.join(l) - ) + self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"), + message=tr("Le contenu de ce fichier ne sera pas pris en compte\n"+''.join(l))) self.parent.record_unit(unite,self) self.g_context={} self.etapes=[] self.jdc_aux=None - self.fichier_err = string.join(l) + self.fichier_err = ''.join(l) self.contexte_fichier_init={} - raise + raise EficasException(" ") else: # Si le fichier est deja defini on ne reevalue pas le fichier - # et on leve une exception si une erreur a été enregistrée + # et on leve une exception si une erreur a ete enregistree self.update_fichier_init(unite) self.fichier_unite=unite - if self.fichier_err is not None: raise Exception(self.fichier_err) + if self.fichier_err is not None: raise EficasException(self.fichier_err) #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro) def make_contexte(self,fichier,text): """ - Cette méthode sert à créer un contexte pour INCLUDE_MATERIAU - en interprétant un texte source Python + Cette methode sert a creer un contexte pour INCLUDE_MATERIAU + en interpretant un texte source Python Elle est appelee par la fonction sd_prod d'INCLUDE_MATERIAU """ #print "make_contexte",fichier @@ -845,16 +1103,16 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): import Extensions.jdc_include self.JdC_aux=Extensions.jdc_include.JdC_include except: - raise + raise EficasException(" ") try: self.make_contexte_include(self.fichier_ini ,self.fichier_text) - if not self.g_context.has_key(self.nom_mater): + if not self.nom_mater in self.g_context : #Pour permettre de lire un jeu de commandes avec des INCLUDE_MATERIAU errones self.g_context[self.nom_mater]=None if self.parent: self.parent.g_context[self.nom_mater]=None except: - l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1]) - self.fichier_err = string.join(l) + l=traceback.format_exception_only(tr("Fichier invalide %s",sys.exc_info()[1])) + self.fichier_err = ''.join(l) self.g_context={} #Pour permettre de lire un jeu de commandes avec des INCLUDE_MATERIAU errones if self.parent: @@ -864,11 +1122,11 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): self.etapes=[] self.jdc_aux=None self.contexte_fichier_init={} - raise + raise EficasException(" ") else: # le fichier est le meme on ne le reevalue pas - # et on leve une exception si une erreur a été enregistrée - if self.fichier_err is not None: raise Exception(self.fichier_err) + # et on leve une exception si une erreur a ete enregistree + if self.fichier_err is not None: raise EficasException(self.fichier_err) #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro) def update_sdprod(self,cr='non'): @@ -890,11 +1148,13 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): """ try: sd=Noyau.N_MACRO_ETAPE.MACRO_ETAPE.Build_sd(self,nom) - except AsException,e: + except : + # return None + #except AsException,e: # Une erreur s'est produite lors de la construction du concept # Comme on est dans EFICAS, on essaie de poursuivre quand meme - # Si on poursuit, on a le choix entre deux possibilités : - # 1. on annule la sd associée à self + # Si on poursuit, on a le choix entre deux possibilites : + # 1. on annule la sd associee a self # 2. on la conserve mais il faut la retourner # On choisit de l'annuler # En plus il faut rendre coherents sdnom et sd.nom @@ -907,7 +1167,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): #ATTENTION SURCHARGE: cette methode surcharge celle de Noyau a garder en synchro def make_poursuite(self): - """ Cette methode est appelée par la fonction sd_prod de la macro POURSUITE + """ Cette methode est appelee par la fonction sd_prod de la macro POURSUITE """ #print "make_poursuite" if not hasattr(self,'fichier_ini') : @@ -922,7 +1182,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): import Extensions.jdc_include except: traceback.print_exc() - raise + raise EficasException(" ") self.JdC_aux=Extensions.jdc_include.JdC_poursuite self.contexte_fichier_init={} #print "make_poursuite",self.fichier_ini,self.fichier_text @@ -931,7 +1191,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): self.fichier_err="Le fichier POURSUITE n'est pas defini" self.jdc_aux=None self.parent.record_unit(None,self) - raise Exception(self.fichier_err) + raise EficasException(self.fichier_err) try: self.make_contexte_include(self.fichier_ini,self.fichier_text) @@ -939,19 +1199,18 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): except: l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1]) if self.jdc.appli: - self.jdc.appli.affiche_alerte("Erreur lors de l'evaluation du fichier poursuite", - message="Ce fichier ne sera pas pris en compte\n"+string.join(l) - ) + self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier poursuite"), + message=tr("Ce fichier ne sera pas pris en compte\n %s",''.join(l))) self.parent.record_unit(None,self) self.g_context={} self.etapes=[] self.jdc_aux=None - self.fichier_err = string.join(l) + self.fichier_err = ''.join(l) self.contexte_fichier_init={} - raise + raise EficasException(" ") else: # Si le fichier est deja defini on ne reevalue pas le fichier - # et on leve une exception si une erreur a été enregistrée + # et on leve une exception si une erreur a ete enregistree self.update_fichier_init(None) - if self.fichier_err is not None: raise Exception(self.fichier_err) + if self.fichier_err is not None: raise EficasException(self.fichier_err)