From cd33d2340845353f18c9560c9d59208834d32f31 Mon Sep 17 00:00:00 2001 From: "pascale.noyret" Date: Mon, 29 Mar 2021 10:44:02 +0200 Subject: [PATCH] reiindent sur Ihm --- Ihm/CONNECTOR.py | 252 ++-- Ihm/I_ASSD.py | 39 +- Ihm/I_AVANT.py | 93 +- Ihm/I_A_CLASSER.py | 23 +- Ihm/I_ENTITE.py | 132 +-- Ihm/I_ETAPE.py | 899 ++++++++------- Ihm/I_EVAL.py | 33 +- Ihm/I_EXCLUS.py | 25 +- Ihm/I_FICHIER.py | 27 +- Ihm/I_FONCTION.py | 72 +- Ihm/I_FORM_ETAPE.py | 35 +- Ihm/I_JDC.py | 1902 +++++++++++++++--------------- Ihm/I_JDC_CATA.py | 28 +- Ihm/I_LASSD.py | 4 +- Ihm/I_MACRO_ETAPE.py | 2360 +++++++++++++++++++------------------- Ihm/I_MCBLOC.py | 6 +- Ihm/I_MCCOMPO.py | 944 ++++++++------- Ihm/I_MCFACT.py | 184 +-- Ihm/I_MCLIST.py | 528 ++++----- Ihm/I_MCSIMP.py | 1576 +++++++++++++------------ Ihm/I_OBJECT.py | 311 +++-- Ihm/I_PRESENT_ABSENT.py | 19 +- Ihm/I_PRESENT_PRESENT.py | 18 +- Ihm/I_PROC_ETAPE.py | 109 +- Ihm/I_REGLE.py | 47 +- Ihm/I_UN_PARMI.py | 27 +- Ihm/I_VALIDATOR.py | 29 +- 27 files changed, 4848 insertions(+), 4874 deletions(-) diff --git a/Ihm/CONNECTOR.py b/Ihm/CONNECTOR.py index 5c066074..e69f95aa 100644 --- a/Ihm/CONNECTOR.py +++ b/Ihm/CONNECTOR.py @@ -21,8 +21,8 @@ La classe CONNECTOR sert a enregistrer les observateurs d'objets et a delivrer les messages emis a ces objets. - Le principe general est le suivant : un objet (subscriber) s'enregistre aupres du - connecteur global (theconnector) pour observer un objet emetteur de messages (publisher) + Le principe general est le suivant : un objet (subscriber) s'enregistre aupres du + connecteur global (theconnector) pour observer un objet emetteur de messages (publisher) sur un canal donne (channel). Il demande a etre notifie par appel d'une fonction (listener). La sequence est donc : @@ -46,147 +46,145 @@ class ConnectorError(Exception): class CONNECTOR: - def __init__(self): - self.connections={} - - def Connect(self, object, channel, function, args): - #print ("Connect",object, channel, function, args) - idx = id(object) - #if self.connections.has_key(idx): - if idx in self.connections : - channels = self.connections[idx] - else: - channels = self.connections[idx] = {} - - #if channels.has_key(channel): - if channel in channels : - receivers = channels[channel] - else: - receivers = channels[channel] = [] - - for funct,fargs in receivers[:]: - if funct() is None: - receivers.remove((funct,fargs)) - elif (function,args) == (funct(),fargs): - receivers.remove((funct,fargs)) - - receivers.append((ref(function),args)) - - - def Disconnect(self, object, channel, function, args): - try: - receivers = self.connections[id(object)][channel] - except KeyError: - raise ConnectorError ( - 'no receivers for channel %s of %s' % (channel, object)) - - for funct,fargs in receivers[:]: - if funct() is None: - receivers.remove((funct,fargs)) - - for funct,fargs in receivers: - if (function,args) == (funct(),fargs): - receivers.remove((funct,fargs)) - if not receivers: - # the list of receivers is empty now, remove the channel - channels = self.connections[id(object)] - del channels[channel] - if not channels: - # the object has no more channels - del self.connections[id(object)] - return - - raise ConnectorError( - 'receiver %s%s is not connected to channel %s of %s' \ - % (function, args, channel, object)) - - - - def Emit(self, object, channel, *args): - #print "Emit",object, channel, args - try: - receivers = self.connections[id(object)][channel] - except KeyError: - return - #print "Emit",object, channel, receivers - # Attention : copie pour eviter les pbs lies aux deconnexion reconnexion - # pendant l'execution des emit - for rfunc, fargs in copy(receivers): - try: - func=rfunc() - if func: - #print (func,args,fargs) - #rint args + fargs - #apply(func, args + fargs) - if args + fargs == () : func() - else : func ( args + fargs) - else: - # Le receveur a disparu - if (rfunc,fargs) in receivers:receivers.remove((rfunc,fargs)) - except: - traceback.print_exc() + def __init__(self): + self.connections={} + + def Connect(self, object, channel, function, args): + #print ("Connect",object, channel, function, args) + idx = id(object) + #if self.connections.has_key(idx): + if idx in self.connections : + channels = self.connections[idx] + else: + channels = self.connections[idx] = {} + + #if channels.has_key(channel): + if channel in channels : + receivers = channels[channel] + else: + receivers = channels[channel] = [] + + for funct,fargs in receivers[:]: + if funct() is None: + receivers.remove((funct,fargs)) + elif (function,args) == (funct(),fargs): + receivers.remove((funct,fargs)) + + receivers.append((ref(function),args)) + + + def Disconnect(self, object, channel, function, args): + try: + receivers = self.connections[id(object)][channel] + except KeyError: + raise ConnectorError ( + 'no receivers for channel %s of %s' % (channel, object)) + + for funct,fargs in receivers[:]: + if funct() is None: + receivers.remove((funct,fargs)) + + for funct,fargs in receivers: + if (function,args) == (funct(),fargs): + receivers.remove((funct,fargs)) + if not receivers: + # the list of receivers is empty now, remove the channel + channels = self.connections[id(object)] + del channels[channel] + if not channels: + # the object has no more channels + del self.connections[id(object)] + return + + raise ConnectorError( + 'receiver %s%s is not connected to channel %s of %s' \ + % (function, args, channel, object)) + + + + def Emit(self, object, channel, *args): + #print "Emit",object, channel, args + try: + receivers = self.connections[id(object)][channel] + except KeyError: + return + #print "Emit",object, channel, receivers + # Attention : copie pour eviter les pbs lies aux deconnexion reconnexion + # pendant l'execution des emit + for rfunc, fargs in copy(receivers): + try: + func=rfunc() + if func: + #print (func,args,fargs) + #rint args + fargs + #apply(func, args + fargs) + if args + fargs == () : func() + else : func ( args + fargs) + else: + # Le receveur a disparu + if (rfunc,fargs) in receivers:receivers.remove((rfunc,fargs)) + except: + traceback.print_exc() def ref(target,callback=None): - #if hasattr(target,"im_self"): - # return BoundMethodWeakref(target) - if hasattr(target,"__self__"): - return BoundMethodWeakref(target) - else: - return weakref.ref(target,callback) + #if hasattr(target,"im_self"): + # return BoundMethodWeakref(target) + if hasattr(target,"__self__"): + return BoundMethodWeakref(target) + else: + return weakref.ref(target,callback) class BoundMethodWeakref(object): - def __init__(self,callable): - #self.Self=weakref.ref(callable.im_self) - #self.Func=weakref.ref(callable.im_func) - self.Self=weakref.ref(callable.__self__) - self.Func=weakref.ref(callable.__func__) - - def __call__(self): - target=self.Self() - if not target:return None - func=self.Func() - if func: - return func.__get__(self.Self()) + def __init__(self,callable): + #self.Self=weakref.ref(callable.im_self) + #self.Func=weakref.ref(callable.im_func) + self.Self=weakref.ref(callable.__self__) + self.Func=weakref.ref(callable.__func__) + + def __call__(self): + target=self.Self() + if not target:return None + func=self.Func() + if func: + return func.__get__(self.Self()) _the_connector =CONNECTOR() Connect = _the_connector.Connect -Emit = _the_connector.Emit +Emit = _the_connector.Emit Disconnect = _the_connector.Disconnect if __name__ == "__main__": - class A: - pass - - class B: - def add(self,a): - print(("--------------------------------add ", self , a)) - - def __del__(self): - print(("__del__", self)) + class A: + pass - def f(a): - print((f, a)) + class B: + def add(self,a): + print(("--------------------------------add ", self , a)) - a=A() - b=B() - c=B() + def __del__(self): + print(("__del__", self)) - Connect(a,"add",b.add,()) - Connect(a,"add",b.add,()) - Connect(a,"add",c.add,()) - Connect(a,"add",f,()) + def f(a): + print((f, a)) - Emit(a,"add",1) + a=A() + b=B() + c=B() - print ("del b") - del b + Connect(a,"add",b.add,()) + Connect(a,"add",b.add,()) + Connect(a,"add",c.add,()) + Connect(a,"add",f,()) - Emit(a,"add",1) - print ("del f") - del f + Emit(a,"add",1) - Emit(a,"add",1) - Disconnect(a,"add",c.add,()) - Emit(a,"add",1) + print ("del b") + del b + Emit(a,"add",1) + print ("del f") + del f + Emit(a,"add",1) + Disconnect(a,"add",c.add,()) + Emit(a,"add",1) diff --git a/Ihm/I_ASSD.py b/Ihm/I_ASSD.py index a3359c53..8fd441b4 100644 --- a/Ihm/I_ASSD.py +++ b/Ihm/I_ASSD.py @@ -26,33 +26,32 @@ from Extensions.eficas_exception import EficasException from Noyau.N_VALIDATOR import ValError class ASSD: - def __repr__(self): - return "concept " + self.getName() + " type " + self.__class__.__name__ + def __repr__(self): + return "concept " + self.getName() + " type " + self.__class__.__name__ - def __str__(self): - return self.getName() or "" + def __str__(self): + return self.getName() or "" class assd(ASSD): - def __convert__(cls,valeur): - return valeur - __convert__=classmethod(__convert__) + def __convert__(cls,valeur): + return valeur + __convert__=classmethod(__convert__) class GEOM(ASSD): - def __convert__(cls,valeur): - return valeur - __convert__= classmethod(__convert__) + def __convert__(cls,valeur): + return valeur + __convert__= classmethod(__convert__) class geom(GEOM): - pass + pass class CO(ASSD): - def __convert__(cls,valeur): - if hasattr(valeur,'_etape') : - # valeur est un concept CO qui a ete transforme par typeSDProd - if valeur.etape == valeur._etape: - # le concept est bien produit par l'etape - return valeur - raise ValError(u"Pas un concept CO") - __convert__=classmethod(__convert__) - + def __convert__(cls,valeur): + if hasattr(valeur,'_etape') : + # valeur est un concept CO qui a ete transforme par typeSDProd + if valeur.etape == valeur._etape: + # le concept est bien produit par l'etape + return valeur + raise ValError(u"Pas un concept CO") + __convert__=classmethod(__convert__) diff --git a/Ihm/I_AVANT.py b/Ihm/I_AVANT.py index c783cb38..5bb4afef 100644 --- a/Ihm/I_AVANT.py +++ b/Ihm/I_AVANT.py @@ -24,55 +24,54 @@ import types class I_AVANT: - """ - La regle I_AVANT verifie que l'on trouve l ordre des mots-cles - de la regle parmi les arguments d'un JDC. + """ + La regle I_AVANT verifie que l'on trouve l ordre des mots-cles + de la regle parmi les arguments d'un JDC. - Ces arguments sont transmis a la regle pour validation sous la forme - d'une liste de noms de mots-cles ou d'un dictionnaire dont - les cles sont des noms de mots-cles. - """ + Ces arguments sont transmis a la regle pour validation sous la forme + d'une liste de noms de mots-cles ou d'un dictionnaire dont + les cles sont des noms de mots-cles. + """ - def __init__(self,*args): - if len(args) > 2 : - print(("Erreur a la creation de la regle A_CLASSER(",args,")")) - return - if type(args[0]) == tuple: - self.listeAvant=args[0] - else : - self.listeAvant=(args[0],) - if type(args[1]) == tuple: - self.listeApres=args[1] - else : - self.listeApres=(args[1],) + def __init__(self,*args): + if len(args) > 2 : + print(("Erreur a la creation de la regle A_CLASSER(",args,")")) + return + if type(args[0]) == tuple: + self.listeAvant=args[0] + else : + self.listeAvant=(args[0],) + if type(args[1]) == tuple: + self.listeApres=args[1] + else : + self.listeApres=(args[1],) - def verif(self,args): - """ - args peut etre un dictionnaire ou une liste. Les elements de args - sont soit les elements de la liste soit les cles du dictionnaire. - """ - # on compte le nombre de mots cles presents - text ='' - boolListeAvant=0 - boolListeApres=0 - boolOK=1 - for nom in args: - if nom in self.listeAvant : - boolListeAvant=1 - if boolListeApres == 1 : - boolOK = 0 - if nom in self.listeApres : - boolListeApres=1 - if boolListeAvant == 0 and boolListeApres == 1 : boolOK = 0 - return text,boolOK + def verif(self,args): + """ + args peut etre un dictionnaire ou une liste. Les elements de args + sont soit les elements de la liste soit les cles du dictionnaire. + """ + # on compte le nombre de mots cles presents + text ='' + boolListeAvant=0 + boolListeApres=0 + boolOK=1 + for nom in args: + if nom in self.listeAvant : + boolListeAvant=1 + if boolListeApres == 1 : + boolOK = 0 + if nom in self.listeApres : + boolListeApres=1 + if boolListeAvant == 0 and boolListeApres == 1 : boolOK = 0 + return text,boolOK - def getText(self): - text = "Regle de classement "' :\n' - for mc in self.listeAvant : - text = text + mc + ', ' - text = text + " \nAvant : \n" - for mc in self.listeApres : - text = text + mc + ',' - return text - + def getText(self): + text = "Regle de classement "' :\n' + for mc in self.listeAvant : + text = text + mc + ', ' + text = text + " \nAvant : \n" + for mc in self.listeApres : + text = text + mc + ',' + return text diff --git a/Ihm/I_A_CLASSER.py b/Ihm/I_A_CLASSER.py index 389869c4..4d09e487 100644 --- a/Ihm/I_A_CLASSER.py +++ b/Ihm/I_A_CLASSER.py @@ -25,15 +25,14 @@ from __future__ import absolute_import from . import I_REGLE class A_CLASSER(I_REGLE.REGLE): - def getText(self): - text = 'Regle ' + self.__class__.__name__+ ' :\n' - t=" D'abord :\n"+' '*8 - for arg in self.args0: - t=t+arg.strip()+' ou ' - text = text + t[0:-4] +'\n' - t = " Ensuite :\n"+' '*8 - for arg in self.args1: - t=t+arg.strip()+' ou ' - text = text + t[0:-4] +'\n' - return text - + def getText(self): + text = 'Regle ' + self.__class__.__name__+ ' :\n' + t=" D'abord :\n"+' '*8 + for arg in self.args0: + t=t+arg.strip()+' ou ' + text = text + t[0:-4] +'\n' + t = " Ensuite :\n"+' '*8 + for arg in self.args1: + t=t+arg.strip()+' ou ' + text = text + t[0:-4] +'\n' + return text diff --git a/Ihm/I_ENTITE.py b/Ihm/I_ENTITE.py index f29bda01..c309de36 100644 --- a/Ihm/I_ENTITE.py +++ b/Ihm/I_ENTITE.py @@ -22,63 +22,63 @@ _no=0 import Accas def numberEntite(entite): - """ - Fonction qui attribue un numero unique a tous les objets du catalogue - Ce numero permet de conserver l'ordre des objets - """ - global _no - _no=_no+1 - entite._no=_no + """ + Fonction qui attribue un numero unique a tous les objets du catalogue + Ce numero permet de conserver l'ordre des objets + """ + global _no + _no=_no+1 + entite._no=_no class ENTITE: - def __init__(self): - numberEntite(self) - - def getDocu(self): - if hasattr(self,'docu') : - if self.docu != "" : return self.docu - else: - if hasattr(self,'pere'): - return self.pere.getDocu() + def __init__(self): + numberEntite(self) + + def getDocu(self): + if hasattr(self,'docu') : + if self.docu != "" : return self.docu + else: + if hasattr(self,'pere'): + return self.pere.getDocu() + else: + return None else: - return None - else: - return None + return None - def getSug(self): - if hasattr(self,'sug') : - if self.sug != "" : return self.sug - return None + def getSug(self): + if hasattr(self,'sug') : + if self.sug != "" : return self.sug + return None - def checkDefinition(self, parent): - """Verifie la definition d'un objet composite (commande, fact, bloc).""" - args = self.entites.copy() - mcs = set() - for nom, val in args.items(): - if val.label == 'SIMP': - mcs.add(nom) - #XXX - #if val.max != 1 and val.type == 'TXM': - #print "#CMD", parent, nom - elif val.label == 'FACT': - val.checkDefinition(parent) - #PNPNPN surcharge - # CALC_SPEC ! - #assert self.label != 'FACT', \ - # 'Commande %s : Mot-clef facteur present sous un mot-clef facteur : interdit !' \ - # % parent - else: - continue - del args[nom] - # seuls les blocs peuvent entrer en conflit avec les mcs du plus haut niveau - for nom, val in args.items(): - if val.label == 'BLOC': - mcbloc = val.checkDefinition(parent) - #XXX - #print "#BLOC", parent, re.sub('\s+', ' ', val.condition) - #assert mcs.isdisjoint(mcbloc), "Commande %s : Mot(s)-clef(s) vu(s) plusieurs fois : %s" \ - # % (parent, tuple(mcs.intersection(mcbloc))) - return mcs + def checkDefinition(self, parent): + """Verifie la definition d'un objet composite (commande, fact, bloc).""" + args = self.entites.copy() + mcs = set() + for nom, val in args.items(): + if val.label == 'SIMP': + mcs.add(nom) + #XXX + #if val.max != 1 and val.type == 'TXM': + #print "#CMD", parent, nom + elif val.label == 'FACT': + val.checkDefinition(parent) + #PNPNPN surcharge + # CALC_SPEC ! + #assert self.label != 'FACT', \ + # 'Commande %s : Mot-clef facteur present sous un mot-clef facteur : interdit !' \ + # % parent + else: + continue + del args[nom] + # seuls les blocs peuvent entrer en conflit avec les mcs du plus haut niveau + for nom, val in args.items(): + if val.label == 'BLOC': + mcbloc = val.checkDefinition(parent) + #XXX + #print "#BLOC", parent, re.sub('\s+', ' ', val.condition) + #assert mcs.isdisjoint(mcbloc), "Commande %s : Mot(s)-clef(s) vu(s) plusieurs fois : %s" \ + # % (parent, tuple(mcs.intersection(mcbloc))) + return mcs # def enregistreXML(self,root,catalogueXml): # import xml.etree.ElementTree as ET @@ -110,7 +110,7 @@ class ENTITE: # if ((self.getSug() !=None) or \ # (hasattr(self,'defaut') and (self.defaut != None) and (self.defaut != 'None'))) : # # il faut ajouter des sug dans le catalogue -# # les attributs sont toujours du texte +# # les attributs sont toujours du texte # dico={} # if (self.defaut != None) and (self.defaut != 'None') : # if isinstance(self.defaut,str ) : dico["defaut"]=six.text_type(self.defaut,"iso-8859-1") @@ -118,7 +118,7 @@ class ENTITE: # if self.getSug() !=None: # if isinstance(self.getSug(),str ) : dico["sug"]=six.text_type(self.getSug(),"iso-8859-1") # else :dico["sug"]=str(self.getSug()) -# +# # doc=ET.SubElement(moi,'ValeurDef') # doc.attrib=dico # @@ -157,25 +157,25 @@ class ENTITE: # # if hasattr(self,'sd_prod') and self.sd_prod != () and self.sd_prod !=None: # typeCree=ET.SubElement(moi,'typeCree') -# typeCree.text=str(self.sd_prod.__name__) -# -# if hasattr(self,'op') and self.op !=None : +# typeCree.text=str(self.sd_prod.__name__) +# +# if hasattr(self,'op') and self.op !=None : # subRoutine=ET.SubElement(moi,'subRoutine') # subRoutine.text=str(self.op) # -# if hasattr(self,'proc') and self.proc != None : +# if hasattr(self,'proc') and self.proc != None : # construction=ET.SubElement(moi,'Construction') # construction.text=self.proc.uri # # for nomFils, fils in self.entites.items() : # fils.enregistreXML(moi,catalogueXml) -# +# # def enregistreXMLStructure(self,root,catalogueXml): # import xml.etree.ElementTree as ET # import types # moi=ET.SubElement(root,str(self.__class__)) # -# if hasattr(self,'into') and self.into!=None: +# if hasattr(self,'into') and self.into!=None: # INTO=ET.SubElement(moi,'into') # INTO.text='into' # @@ -216,23 +216,23 @@ class ENTITE: # elif t == "TXM" : ty=ET.SubElement(moi,'typeTXM') # else : # try : -# ty=ET.SubElement(moi,t.__name__) +# ty=ET.SubElement(moi,t.__name__) # except : -# ty=ET.SubElement(moi,'autre') +# ty=ET.SubElement(moi,'autre') # ty.text='type' # # if hasattr(self,'sd_prod') and self.sd_prod != () and self.sd_prod !=None: # typeCree=ET.SubElement(moi,'typeCree') # typeCree.text='sd_prod' -# -# if hasattr(self,'op') and self.op !=None : +# +# if hasattr(self,'op') and self.op !=None : # subRoutine=ET.SubElement(moi,'subRoutine') # subRoutine.text='op' # -# if hasattr(self,'proc') and self.proc != None : +# if hasattr(self,'proc') and self.proc != None : # construction=ET.SubElement(moi,'Construction') # construction.text='proc' # # for nomFils, fils in self.entites.items() : # fils.enregistreXMLStructure(moi,catalogueXml) -# +# diff --git a/Ihm/I_ETAPE.py b/Ihm/I_ETAPE.py index 513a3718..3d16c31b 100644 --- a/Ihm/I_ETAPE.py +++ b/Ihm/I_ETAPE.py @@ -47,462 +47,461 @@ from Extensions import commande_comm class ETAPE(I_MCCOMPO.MCCOMPO): - def ident(self): - return self.nom - - def getSdname(self): - #print "SDNAME ",self.reuse,self.sd,self.sd.getName() - if CONTEXT.debug : - print(("SDNAME ", self.reuse, self.sd, self.sd.getName())) - sdname='' - if self.reuse != None: - sdname= self.reuse.getName() - else: - if self.sd:sdname=self.sd.getName() - if sdname.find('sansnom') != -1 or sdname.find('SD_') != -1: - # dans le cas ou la SD est 'sansnom' ou 'SD_' on retourne la chaine vide - return '' - return sdname - - def isReentrant(self): - """ - Indique si la commande est reentrante - """ - return self.definition.reentrant == 'o' - - def initModif(self): - """ - Met l'etat de l'etape a : modifie - Propage la modification au parent - """ - # initModif doit etre appele avant de realiser une modification - # La validite devra etre recalculee apres cette modification - # mais dans l'appel a finModif pour preserver l'etat modified - # de tous les objets entre temps - #print "initModif",self,self.parent - self.state = 'modified' - if self.parent: - self.parent.initModif() - - def finModif(self): - """ - Methode appelee une fois qu'une modification a ete faite afin de - declencher d'eventuels traitements post-modification - ex : INCLUDE et POURSUITE - Ne pas mettre de traitement qui risque d'induire des recursions (soit a peu pres rien) - """ - CONNECTOR.Emit(self,"valid") - if self.parent: - self.parent.finModif() - - def nommeSd(self,nom) : - """ - Cette methode a pour fonction de donner un nom (nom) au concept - produit par l'etape (self). - - si le concept n'existe pas, on essaye de le creer a condition que l'etape soit valide ET non reentrante) - - si il existe dea, on le renomme et on repercute les changements dans les autres etapes - Les valeurs de retour sont : - - 0 si le nommage n'a pas pu etre menea son terme, - - 1 dans le cas contraire - """ - # Le nom d'un concept doit etre un identificateur Python (toujours vrai ou insuffisant?) - if not conceptRE.match(nom): - return 0, tr("Un nom de concept doit etre un identificateur Python") - - # pour eviter que le nom du concept soit le nom de la classe --> souci pour utiliser le concept - if (nom == self.definition.nom) : return (0, tr("un concept de type ")+ nom + tr(" ne peut pas se nommer ") + nom) - if ( nom in dir(self.jdc.cata)) : return (0, nom + tr("est un not reserve")) - #if (not isinstance(nom,str)) : return (0, tr("Le nom ") + nom + tr(" est un mot reserve")) - #if len(nom) > 8 and self.jdc.definition.code == 'ASTER': - # return 0, tr("Nom de concept trop long (maxi 8 caracteres)") - - self.initModif() - # - # On verifie d'abord si les mots cles sont valides - # - if not self.isValid(sd='non') : return 0,"Nommage du concept refuse : l'operateur n'est pas valide" - # - # Cas particulier des operateurs obligatoirement reentrants - # plus de concept reentrant (pour Aster) - # - if self.definition.reentrant == 'o': - self.sd = self.reuse = self.jdc.getSdAvantEtape(nom,self) - if self.sd != None : - self.sdnom=self.sd.nom - self.finModif() - return 1, tr("Concept existant") + def ident(self): + return self.nom + + def getSdname(self): + #print "SDNAME ",self.reuse,self.sd,self.sd.getName() + if CONTEXT.debug : + print(("SDNAME ", self.reuse, self.sd, self.sd.getName())) + sdname='' + if self.reuse != None: + sdname= self.reuse.getName() else: - return 0, tr("Operateur reentrant mais concept non existant") - # - # Cas particulier des operateurs facultativement reentrants - # - old_reuse=None - if self.definition.reentrant == 'f' : - sd = self.jdc.getSdAvantEtape(nom,self) - if sd != None : - if isinstance(sd,self.getType_produit()) : - self.sd = self.reuse = sd - self.sdnom = sd.nom - self.finModif() - return 1, tr("Operateur reentrant et concept existant trouve") - else: - return 0, tr("Concept deja existant et de mauvais type") - else : - # il faut enlever le lien vers une SD existante car si on passe ici - # cela signifie que l'operateur n'est pas utilise en mode reentrant. - # Si on ne fait pas cela, on risque de modifier une SD produite par un autre operateur - if self.reuse : - old_reuse=self.reuse - self.sd = self.reuse = self.sdnom = None - # - # On est dans le cas ou l'operateur n'est pas reentrant ou est facultativement reentrant - # mais est utilise en mode non reentrant - # - if self.sd == None : - #Pas de concept produit preexistant - if self.parent.getSdAutourEtape(nom,self): - # Un concept de ce nom existe dans le voisinage de l'etape courante - # On retablit l'ancien concept reentrant s'il existait - if old_reuse: - self.sd=self.reuse=old_reuse - self.sdnom=old_reuse.nom - return 0, tr("Nommage du concept refuse : un concept de meme nom existe deja") - else: - # Il n'existe pas de concept de ce nom dans le voisinage de l'etape courante - # On peut donc creer le concept retourne - # Il est cree sans nom mais enregistre dans la liste des concepts existants - try: - self.getSdProd() - # Renommage du concept : Il suffit de changer son attribut nom pour le nommer - self.sd.nom = nom - self.sdnom=nom - self.parent.sdsDict[nom]=self.sd - self.parent.updateConceptAfterEtape(self,self.sd) - self.finModif() - return 1, tr("Nommage du concept effectue") - except: - return 0, tr("Nommage impossible %s", str(sys.exc_info()[1])) - else : - #Un concept produit preexiste - old_nom=self.sd.nom - if old_nom.find('sansnom') : - # Dans le cas ou old_nom == sansnom, isValid retourne 0 alors que ... - # par contre si le concept existe et qu'il s'appelle sansnom c'est que l'etape est valide - # on peut donc le nommer sans test prealable - if self.parent.getSdAutourEtape(nom,self): - return 0, tr("Nommage du concept refuse : un concept de meme nom existe deja") + if self.sd:sdname=self.sd.getName() + if sdname.find('sansnom') != -1 or sdname.find('SD_') != -1: + # dans le cas ou la SD est 'sansnom' ou 'SD_' on retourne la chaine vide + return '' + return sdname + + def isReentrant(self): + """ + Indique si la commande est reentrante + """ + return self.definition.reentrant == 'o' + + def initModif(self): + """ + Met l'etat de l'etape a : modifie + Propage la modification au parent + """ + # initModif doit etre appele avant de realiser une modification + # La validite devra etre recalculee apres cette modification + # mais dans l'appel a finModif pour preserver l'etat modified + # de tous les objets entre temps + #print "initModif",self,self.parent + self.state = 'modified' + if self.parent: + self.parent.initModif() + + def finModif(self): + """ + Methode appelee une fois qu'une modification a ete faite afin de + declencher d'eventuels traitements post-modification + ex : INCLUDE et POURSUITE + Ne pas mettre de traitement qui risque d'induire des recursions (soit a peu pres rien) + """ + CONNECTOR.Emit(self,"valid") + if self.parent: + self.parent.finModif() + + def nommeSd(self,nom) : + """ + Cette methode a pour fonction de donner un nom (nom) au concept + produit par l'etape (self). + - si le concept n'existe pas, on essaye de le creer a condition que l'etape soit valide ET non reentrante) + - si il existe dea, on le renomme et on repercute les changements dans les autres etapes + Les valeurs de retour sont : + - 0 si le nommage n'a pas pu etre menea son terme, + - 1 dans le cas contraire + """ + # Le nom d'un concept doit etre un identificateur Python (toujours vrai ou insuffisant?) + if not conceptRE.match(nom): + return 0, tr("Un nom de concept doit etre un identificateur Python") + + # pour eviter que le nom du concept soit le nom de la classe --> souci pour utiliser le concept + if (nom == self.definition.nom) : return (0, tr("un concept de type ")+ nom + tr(" ne peut pas se nommer ") + nom) + if ( nom in dir(self.jdc.cata)) : return (0, nom + tr("est un not reserve")) + #if (not isinstance(nom,str)) : return (0, tr("Le nom ") + nom + tr(" est un mot reserve")) + #if len(nom) > 8 and self.jdc.definition.code == 'ASTER': + # return 0, tr("Nom de concept trop long (maxi 8 caracteres)") + + self.initModif() + # + # On verifie d'abord si les mots cles sont valides + # + if not self.isValid(sd='non') : return 0,"Nommage du concept refuse : l'operateur n'est pas valide" + # + # Cas particulier des operateurs obligatoirement reentrants + # plus de concept reentrant (pour Aster) + # + if self.definition.reentrant == 'o': + self.sd = self.reuse = self.jdc.getSdAvantEtape(nom,self) + if self.sd != None : + self.sdnom=self.sd.nom + self.finModif() + return 1, tr("Concept existant") else: - # Renommage du concept : Il suffit de changer son attribut nom pour le nommer - self.sd.nom=nom - self.sdnom=nom - self.parent.updateConceptAfterEtape(self,self.sd) - self.finModif() - return 1, tr("Nommage du concept effectue") - if self.isValid() : - # Normalement l appel de isValid a mis a jour le concept produit (son type) - # Il suffit de specifier l attribut nom de sd pour le nommer si le nom n est pas - # deja attribue + return 0, tr("Operateur reentrant mais concept non existant") + # + # Cas particulier des operateurs facultativement reentrants + # + old_reuse=None + if self.definition.reentrant == 'f' : + sd = self.jdc.getSdAvantEtape(nom,self) + if sd != None : + if isinstance(sd,self.getType_produit()) : + self.sd = self.reuse = sd + self.sdnom = sd.nom + self.finModif() + return 1, tr("Operateur reentrant et concept existant trouve") + else: + return 0, tr("Concept deja existant et de mauvais type") + else : + # il faut enlever le lien vers une SD existante car si on passe ici + # cela signifie que l'operateur n'est pas utilise en mode reentrant. + # Si on ne fait pas cela, on risque de modifier une SD produite par un autre operateur + if self.reuse : + old_reuse=self.reuse + self.sd = self.reuse = self.sdnom = None + # + # On est dans le cas ou l'operateur n'est pas reentrant ou est facultativement reentrant + # mais est utilise en mode non reentrant + # + if self.sd == None : + #Pas de concept produit preexistant if self.parent.getSdAutourEtape(nom,self): - return 0, tr("Nommage du concept refuse : un concept de meme nom existe deja") + # Un concept de ce nom existe dans le voisinage de l'etape courante + # On retablit l'ancien concept reentrant s'il existait + if old_reuse: + self.sd=self.reuse=old_reuse + self.sdnom=old_reuse.nom + return 0, tr("Nommage du concept refuse : un concept de meme nom existe deja") else: - # Renommage du concept : Il suffit de changer son attribut nom pour le nommer - self.sd.nom=nom - self.sdnom=nom - self.parent.updateConceptAfterEtape(self,self.sd) - self.finModif() - return 1, tr("Nommage du concept effectue") - else: - # Normalement on ne devrait pas passer ici - return 0, 'Normalement on ne devrait pas passer ici' - - def getSdprods(self,nom_sd): - """ - Fonction : retourne le concept produit par l etape de nom nom_sd - s il existe sinon None - """ - if self.sd: - if self.sd.nom == nom_sd:return self.sd - - def active(self): - """ - Rend l'etape courante active. - Il faut ajouter la sd si elle existe au contexte global du JDC - et a la liste des sd - """ - if self.actif:return - self.actif = 1 - self.initModif() - if self.sd : - try: - self.jdc.appendSdProd(self.sd) - except: - pass - CONNECTOR.Emit(self,"add",None) - CONNECTOR.Emit(self,"valid") - - def inactive(self): - """ - Rend l'etape courante inactive - Il faut supprimer la sd du contexte global du JDC - et de la liste des sd - """ - self.actif = 0 - self.initModif() - if self.sd : - self.jdc.delSdprod(self.sd) - self.jdc.deleteConceptAfterEtape(self,self.sd) - CONNECTOR.Emit(self,"supp",None) - CONNECTOR.Emit(self,"valid") - - def controlSdprods(self,d): - """ - Cette methode doit verifier que ses concepts produits ne sont pas - deja definis dans le contexte - Si c'est le cas, les concepts produits doivent etre supprimes - """ - #print ("controlSdprods etape",d.keys(),self.sd and self.sd.nom,self.nom) - if self.sd: - 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 - pass - else: - # Redefinition du concept, on l'annule - #XXX on pourrait simplement annuler son nom pour conserver les objets - # l'utilisateur n'aurait alors qu'a renommer le concept (faisable??) - self.initModif() - sd=self.sd - self.sd=self.reuse=self.sdnom=None - #supprime les references a sd dans les etapes suivantes - self.parent.deleteConceptAfterEtape(self,sd) - self.finModif() - - def supprimeSdprod(self,sd): - """ - Supprime le concept produit sd s'il est produit par l'etape - """ - if sd is not self.sd:return - if self.sd != None : - self.initModif() - self.parent.delSdprod(sd) - self.sd=None - self.finModif() - self.parent.deleteConcept(sd) - - def supprimeSdProds(self): - """ - Fonction: - Lors d'une destruction d'etape, detruit tous les concepts produits - Un operateur n a qu un concept produit - Une procedure n'en a aucun - Une macro en a en general plus d'un - """ - self.deleteRef() - #print "supprimeSdProds",self - if self.reuse is self.sd :return - # 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.delSdprod(self.sd) - self.parent.deleteConcept(self.sd) - - def close(self): - return - - def updateConcept(self,sd): - for child in self.mcListe : - child.updateConcept(sd) - - def deleteConcept(self,sd): - """ - Inputs : - - sd=concept detruit - Fonction : - Mettre a jour les mots cles de l etape et eventuellement - 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 - """ - if self.reuse and self.reuse == sd: - self.sd=self.reuse=None + # Il n'existe pas de concept de ce nom dans le voisinage de l'etape courante + # On peut donc creer le concept retourne + # Il est cree sans nom mais enregistre dans la liste des concepts existants + try: + self.getSdProd() + # Renommage du concept : Il suffit de changer son attribut nom pour le nommer + self.sd.nom = nom + self.sdnom=nom + self.parent.sdsDict[nom]=self.sd + self.parent.updateConceptAfterEtape(self,self.sd) + self.finModif() + return 1, tr("Nommage du concept effectue") + except: + return 0, tr("Nommage impossible %s", str(sys.exc_info()[1])) + else : + #Un concept produit preexiste + old_nom=self.sd.nom + if old_nom.find('sansnom') : + # Dans le cas ou old_nom == sansnom, isValid retourne 0 alors que ... + # par contre si le concept existe et qu'il s'appelle sansnom c'est que l'etape est valide + # on peut donc le nommer sans test prealable + if self.parent.getSdAutourEtape(nom,self): + return 0, tr("Nommage du concept refuse : un concept de meme nom existe deja") + else: + # Renommage du concept : Il suffit de changer son attribut nom pour le nommer + self.sd.nom=nom + self.sdnom=nom + self.parent.updateConceptAfterEtape(self,self.sd) + self.finModif() + return 1, tr("Nommage du concept effectue") + if self.isValid() : + # Normalement l appel de isValid a mis a jour le concept produit (son type) + # Il suffit de specifier l attribut nom de sd pour le nommer si le nom n est pas + # deja attribue + if self.parent.getSdAutourEtape(nom,self): + return 0, tr("Nommage du concept refuse : un concept de meme nom existe deja") + else: + # Renommage du concept : Il suffit de changer son attribut nom pour le nommer + self.sd.nom=nom + self.sdnom=nom + self.parent.updateConceptAfterEtape(self,self.sd) + self.finModif() + return 1, tr("Nommage du concept effectue") + else: + # Normalement on ne devrait pas passer ici + return 0, 'Normalement on ne devrait pas passer ici' + + def getSdprods(self,nom_sd): + """ + Fonction : retourne le concept produit par l etape de nom nom_sd + s il existe sinon None + """ + if self.sd: + if self.sd.nom == nom_sd:return self.sd + + def active(self): + """ + Rend l'etape courante active. + Il faut ajouter la sd si elle existe au contexte global du JDC + et a la liste des sd + """ + if self.actif:return + self.actif = 1 self.initModif() - for child in self.mcListe : - child.deleteConcept(sd) - - def replaceConcept(self,old_sd,sd): - """ - Inputs : - - old_sd=concept remplace - - sd = nouveau concept - Fonction : - Mettre a jour les mots cles de l etape et eventuellement - le concept produit si reuse - suite au remplacement du concept old_sd - """ - if self.reuse and self.reuse == old_sd: - self.sd=self.reuse=sd + if self.sd : + try: + self.jdc.appendSdProd(self.sd) + except: + pass + CONNECTOR.Emit(self,"add",None) + CONNECTOR.Emit(self,"valid") + + def inactive(self): + """ + Rend l'etape courante inactive + Il faut supprimer la sd du contexte global du JDC + et de la liste des sd + """ + self.actif = 0 self.initModif() - for child in self.mcListe : - child.replaceConcept(old_sd,sd) - - def resetContext(self): - pass - - def getNomsSdOperReentrant(self): - """ - Retourne la liste des noms de concepts utilisesa l'interieur de la commande - qui sont du type que peut retourner cette commande - """ - liste_sd = self.getSd_utilisees() - l_noms = [] - if type(self.definition.sd_prod) == types.FunctionType: - d=self.creeDictValeurs(self.mcListe) - try: - classe_sd_prod = self.definition.sd_prod(*(), **d) - except: - return [] - else: - classe_sd_prod = self.definition.sd_prod - for sd in liste_sd : - if sd.__class__ is classe_sd_prod : l_noms.append(sd.nom) - l_noms.sort() - return l_noms - - def getGenealogiePrecise(self): - return [self.nom] - - def getNomDsXML(self): - # en xml on a un choice - index=0 - for e in self.parent.etapes : - if e == self : break - if e.nom == self.nom : index+=1 - nomDsXML = self.nom + "[" + str(index) + "]" - return nomDsXML - - - def getGenealogie(self): - """ - Retourne la liste des noms des ascendants de l'objet self - en s'arretant a la premiere ETAPE rencontree - """ - return [self.nom] - - def verifExistenceSd(self): - """ - Verifie que les structures de donnees utilisees dans self existent bien dans le contexte - avant etape, sinon enleve la referea ces concepts - """ - #print "verifExistenceSd",self.sd - for motcle in self.mcListe : - motcle.verifExistenceSd() - - def updateMcGlobal(self): - """ - Met a jour les mots cles globaux enregistres dans l'etape - et dans le jdc parent. - Une etape ne peut pas etre globale. Elle se contente de passer - la requete a ses fils apres avoir reinitialise le dictionnaire - des mots cles globaux. - """ - self.mc_globaux={} - I_MCCOMPO.MCCOMPO.updateMcGlobal(self) - - def updateConditionBloc(self): - """ - Realise l'update des blocs conditionnels fils de self - """ - self._updateConditionBloc() - - def getObjetCommentarise(self,format): - """ - Cette methode retourne un objet commande commentarisee - representant la commande self - """ - import generator - g=generator.plugins[format]() - texte_commande = g.gener(self,format='beautifie') - # Il faut enlever la premiere ligne vide de texte_commande que - # rajoute le generator - # on construit l'objet COMMANDE_COMM repesentatif de self mais non - # enregistre dans le jdc (pas ajoute dans jdc.etapes) - parent=self.parent - pos=self.parent.etapes.index(self) - # on ajoute une fin à la commande pour pouvoir en commenter 2 - texte_commande+='\nFin Commentaire' - commande_comment = commande_comm.COMMANDE_COMM(texte=texte_commande, - reg='non', - parent=parent) - self.parent.suppEntite(self) - parent.addEntite(commande_comment,pos) - - return commande_comment - - def modified(self): - """Le contenu de l'etape (mots cles, ...) a ete modifie""" - if self.nom=="DETRUIRE": - self.parent.controlContextApres(self) - - - + if self.sd : + self.jdc.delSdprod(self.sd) + self.jdc.deleteConceptAfterEtape(self,self.sd) + CONNECTOR.Emit(self,"supp",None) + CONNECTOR.Emit(self,"valid") + + def controlSdprods(self,d): + """ + Cette methode doit verifier que ses concepts produits ne sont pas + deja definis dans le contexte + Si c'est le cas, les concepts produits doivent etre supprimes + """ + #print ("controlSdprods etape",d.keys(),self.sd and self.sd.nom,self.nom) + if self.sd: + 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 + pass + else: + # Redefinition du concept, on l'annule + #XXX on pourrait simplement annuler son nom pour conserver les objets + # l'utilisateur n'aurait alors qu'a renommer le concept (faisable??) + self.initModif() + sd=self.sd + self.sd=self.reuse=self.sdnom=None + #supprime les references a sd dans les etapes suivantes + self.parent.deleteConceptAfterEtape(self,sd) + self.finModif() + + def supprimeSdprod(self,sd): + """ + Supprime le concept produit sd s'il est produit par l'etape + """ + if sd is not self.sd:return + if self.sd != None : + self.initModif() + self.parent.delSdprod(sd) + self.sd=None + self.finModif() + self.parent.deleteConcept(sd) + + def supprimeSdProds(self): + """ + Fonction: + Lors d'une destruction d'etape, detruit tous les concepts produits + Un operateur n a qu un concept produit + Une procedure n'en a aucun + Une macro en a en general plus d'un + """ + self.deleteRef() + #print "supprimeSdProds",self + if self.reuse is self.sd :return + # 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.delSdprod(self.sd) + self.parent.deleteConcept(self.sd) + + def close(self): + return + + def updateConcept(self,sd): + for child in self.mcListe : + child.updateConcept(sd) + + def deleteConcept(self,sd): + """ + Inputs : + - sd=concept detruit + Fonction : + Mettre a jour les mots cles de l etape et eventuellement + 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 + """ + if self.reuse and self.reuse == sd: + self.sd=self.reuse=None + self.initModif() + for child in self.mcListe : + child.deleteConcept(sd) + + def replaceConcept(self,old_sd,sd): + """ + Inputs : + - old_sd=concept remplace + - sd = nouveau concept + Fonction : + Mettre a jour les mots cles de l etape et eventuellement + le concept produit si reuse + suite au remplacement du concept old_sd + """ + if self.reuse and self.reuse == old_sd: + self.sd=self.reuse=sd + self.initModif() + for child in self.mcListe : + child.replaceConcept(old_sd,sd) + + def resetContext(self): + pass + + def getNomsSdOperReentrant(self): + """ + Retourne la liste des noms de concepts utilisesa l'interieur de la commande + qui sont du type que peut retourner cette commande + """ + liste_sd = self.getSd_utilisees() + l_noms = [] + if type(self.definition.sd_prod) == types.FunctionType: + d=self.creeDictValeurs(self.mcListe) + try: + classe_sd_prod = self.definition.sd_prod(*(), **d) + except: + return [] + else: + classe_sd_prod = self.definition.sd_prod + for sd in liste_sd : + if sd.__class__ is classe_sd_prod : l_noms.append(sd.nom) + l_noms.sort() + return l_noms + + def getGenealogiePrecise(self): + return [self.nom] + + def getNomDsXML(self): + # en xml on a un choice + index=0 + for e in self.parent.etapes : + if e == self : break + if e.nom == self.nom : index+=1 + nomDsXML = self.nom + "[" + str(index) + "]" + return nomDsXML + + + def getGenealogie(self): + """ + Retourne la liste des noms des ascendants de l'objet self + en s'arretant a la premiere ETAPE rencontree + """ + return [self.nom] + + def verifExistenceSd(self): + """ + Verifie que les structures de donnees utilisees dans self existent bien dans le contexte + avant etape, sinon enleve la referea ces concepts + """ + #print "verifExistenceSd",self.sd + for motcle in self.mcListe : + motcle.verifExistenceSd() + + def updateMcGlobal(self): + """ + Met a jour les mots cles globaux enregistres dans l'etape + et dans le jdc parent. + Une etape ne peut pas etre globale. Elle se contente de passer + la requete a ses fils apres avoir reinitialise le dictionnaire + des mots cles globaux. + """ + self.mc_globaux={} + I_MCCOMPO.MCCOMPO.updateMcGlobal(self) + + def updateConditionBloc(self): + """ + Realise l'update des blocs conditionnels fils de self + """ + self._updateConditionBloc() + + def getObjetCommentarise(self,format): + """ + Cette methode retourne un objet commande commentarisee + representant la commande self + """ + import generator + g=generator.plugins[format]() + texte_commande = g.gener(self,format='beautifie') + # Il faut enlever la premiere ligne vide de texte_commande que + # rajoute le generator + # on construit l'objet COMMANDE_COMM repesentatif de self mais non + # enregistre dans le jdc (pas ajoute dans jdc.etapes) + parent=self.parent + pos=self.parent.etapes.index(self) + # on ajoute une fin à la commande pour pouvoir en commenter 2 + texte_commande+='\nFin Commentaire' + commande_comment = commande_comm.COMMANDE_COMM(texte=texte_commande, + reg='non', + parent=parent) + self.parent.suppEntite(self) + parent.addEntite(commande_comment,pos) + + return commande_comment + + def modified(self): + """Le contenu de l'etape (mots cles, ...) a ete modifie""" + if self.nom=="DETRUIRE": + self.parent.controlContextApres(self) + + + #ATTENTION SURCHARGE: a garder en synchro ou a reintegrer dans le Noyau - def buildSd(self,nom): - """ - Methode de Noyau surchargee pour poursuivre malgre tout - si une erreur se produit pendant la creation du concept produit - """ - try: - sd=Noyau.N_ETAPE.ETAPE.buildSd(self,nom) - except AsException as 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 possibilites : - # 1. on annule la sd associee a self - # 2. on la conserve mais il faut la retourner - # En plus il faut rendre coherents sdnom et sd.nom - self.sd=None - self.sdnom=None - self.state="unchanged" - self.valid=0 - - return self.sd + def buildSd(self,nom): + """ + Methode de Noyau surchargee pour poursuivre malgre tout + si une erreur se produit pendant la creation du concept produit + """ + try: + sd=Noyau.N_ETAPE.ETAPE.buildSd(self,nom) + except AsException as 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 possibilites : + # 1. on annule la sd associee a self + # 2. on la conserve mais il faut la retourner + # En plus il faut rendre coherents sdnom et sd.nom + self.sd=None + self.sdnom=None + self.state="unchanged" + self.valid=0 + + return self.sd #ATTENTION SURCHARGE: cette methode doit etre gardee en synchronisation avec Noyau - def makeRegister(self): - """ - Initialise les attributs jdc, id, niveau et realise les - enregistrements necessaires - Pour EFICAS, on tient compte des niveaux - Surcharge la methode makeRegister du package Noyau - """ - if self.parent : - self.jdc = self.parent.getJdcRoot() - self.id= self.parent.register(self) - self.UserError=self.jdc.UserError - if self.definition.niveau : - # La definition est dans un niveau. En plus on - # l'enregistre dans le niveau - self.nom_niveau_definition = self.definition.niveau.nom - self.niveau = self.parent.dict_niveaux[self.nom_niveau_definition] - self.niveau.register(self) - else: - # La definition est au niveau global - self.nom_niveau_definition = 'JDC' - self.niveau=self.parent - else: - self.jdc = self.parent =None - self.id=None - self.niveau=None - self.UserError="UserError" - - def report(self): - cr= Validation.V_ETAPE.ETAPE.report(self) - #rafraichisst de la validite de l'etape (probleme avec l'ordre dans les macros : etape puis mots cles) - self.isValid() - if not self.isValid() and self.nom == "INCLUDE" : - self.cr.fatal('Etape : {} ligne : {} {}'.format(self.nom, self.appel[0], tr("\n Include Invalide. \n ne sera pas pris en compte"))) - return cr - + def makeRegister(self): + """ + Initialise les attributs jdc, id, niveau et realise les + enregistrements necessaires + Pour EFICAS, on tient compte des niveaux + Surcharge la methode makeRegister du package Noyau + """ + if self.parent : + self.jdc = self.parent.getJdcRoot() + self.id= self.parent.register(self) + self.UserError=self.jdc.UserError + if self.definition.niveau : + # La definition est dans un niveau. En plus on + # l'enregistre dans le niveau + self.nom_niveau_definition = self.definition.niveau.nom + self.niveau = self.parent.dict_niveaux[self.nom_niveau_definition] + self.niveau.register(self) + else: + # La definition est au niveau global + self.nom_niveau_definition = 'JDC' + self.niveau=self.parent + else: + self.jdc = self.parent =None + self.id=None + self.niveau=None + self.UserError="UserError" + + def report(self): + cr= Validation.V_ETAPE.ETAPE.report(self) + #rafraichisst de la validite de l'etape (probleme avec l'ordre dans les macros : etape puis mots cles) + self.isValid() + if not self.isValid() and self.nom == "INCLUDE" : + self.cr.fatal('Etape : {} ligne : {} {}'.format(self.nom, self.appel[0], tr("\n Include Invalide. \n ne sera pas pris en compte"))) + return cr diff --git a/Ihm/I_EVAL.py b/Ihm/I_EVAL.py index 426c9c88..db69b30e 100644 --- a/Ihm/I_EVAL.py +++ b/Ihm/I_EVAL.py @@ -20,22 +20,21 @@ """ class EVAL : - """ - """ - def __init__(self,str): - """ - L'objet EVAL est initialise avec une chaine de caracteres (str) - """ - self.valeur = str - self.val=None + """ + """ + def __init__(self,str): + """ + L'objet EVAL est initialise avec une chaine de caracteres (str) + """ + self.valeur = str + self.val=None - def __repr__(self): - return 'EVAL("""'+self.valeur+'""")' - - def accept(self,visitor): - """ - Cette methode permet de parcourir l'arborescence des objets - en utilisant le pattern VISITEUR - """ - visitor.visitEVAL(self) + def __repr__(self): + return 'EVAL("""'+self.valeur+'""")' + def accept(self,visitor): + """ + Cette methode permet de parcourir l'arborescence des objets + en utilisant le pattern VISITEUR + """ + visitor.visitEVAL(self) diff --git a/Ihm/I_EXCLUS.py b/Ihm/I_EXCLUS.py index d1ddee60..c17411a3 100644 --- a/Ihm/I_EXCLUS.py +++ b/Ihm/I_EXCLUS.py @@ -24,17 +24,16 @@ from __future__ import absolute_import from . import I_REGLE class EXCLUS(I_REGLE.REGLE): - def purgeListe(self,liste_a_purger,listeMcPresents): - regle_active=0 - for mc_present in listeMcPresents: - if mc_present in self.mcs: - regle_active=1 - break - if not regle_active : return liste_a_purger - - for mc in self.mcs: - # Il ne faut pas purger un mot cle present. Sa cardinalite est verifiee par ailleurs - if mc in liste_a_purger and mc not in listeMcPresents: - liste_a_purger.remove(mc) - return liste_a_purger + def purgeListe(self,liste_a_purger,listeMcPresents): + regle_active=0 + for mc_present in listeMcPresents: + if mc_present in self.mcs: + regle_active=1 + break + if not regle_active : return liste_a_purger + for mc in self.mcs: + # Il ne faut pas purger un mot cle present. Sa cardinalite est verifiee par ailleurs + if mc in liste_a_purger and mc not in listeMcPresents: + liste_a_purger.remove(mc) + return liste_a_purger diff --git a/Ihm/I_FICHIER.py b/Ihm/I_FICHIER.py index 94478178..087ac9f1 100644 --- a/Ihm/I_FICHIER.py +++ b/Ihm/I_FICHIER.py @@ -22,21 +22,20 @@ import types class Fichier: - def __init__(self,filtre='All Files (*)',existence='NonExistant',repertoire=None): - self.filtre=filtre - self.existence=existence - self.repertoire=repertoire + def __init__(self,filtre='All Files (*)',existence='NonExistant',repertoire=None): + self.filtre=filtre + self.existence=existence + self.repertoire=repertoire - def __convert__(self,valeur): - # Attention ne verifie pas grand chose - if type(valeur) != bytes and type(valeur) != str: - return None - return valeur + def __convert__(self,valeur): + # Attention ne verifie pas grand chose + if type(valeur) != bytes and type(valeur) != str: + return None + return valeur - def info(self): - return "Fichier de Type %s et %s" % (self.filtre,self.existence) - - __repr__=info - __str__=info + def info(self): + return "Fichier de Type %s et %s" % (self.filtre,self.existence) + __repr__=info + __str__=info diff --git a/Ihm/I_FONCTION.py b/Ihm/I_FONCTION.py index 9efb621b..cc30dcb6 100644 --- a/Ihm/I_FONCTION.py +++ b/Ihm/I_FONCTION.py @@ -24,21 +24,21 @@ from Extensions.i18n import tr from Extensions.eficas_exception import EficasException class FONCTION(ASSD): - def __init__(self,etape=None,sd=None,reg='oui'): - if reg=='oui': - self.jdc.registerFonction(self) + def __init__(self,etape=None,sd=None,reg='oui'): + if reg=='oui': + self.jdc.registerFonction(self) - def getFormule(self): - """ - Retourne une formule decrivant self sous la forme d'un tuple : - (nom,type_retourne,arguments,corps) - """ - if hasattr(self.etape,'getFormule'): - # on est dans le cas d'une formule Aster - return self.etape.getFormule() - else: - # on est dans le cas d'une fonction - return (self.nom,'REEL','(REEL:x)','''bidon''') + def getFormule(self): + """ + Retourne une formule decrivant self sous la forme d'un tuple : + (nom,type_retourne,arguments,corps) + """ + if hasattr(self.etape,'getFormule'): + # on est dans le cas d'une formule Aster + return self.etape.getFormule() + else: + # on est dans le cas d'une fonction + return (self.nom,'REEL','(REEL:x)','''bidon''') # On ajoute la classe formule pour etre coherent avec la # modification de C Durand sur la gestion des formules dans le superviseur @@ -46,27 +46,25 @@ class FONCTION(ASSD): class fonction(FONCTION) : pass from Extensions import param2 -class formule(FONCTION) : - def __call__(self,*val): - if len(val) != len(self.nompar): - raise TypeError(" %s() takes exactly %d argument (%d given)" % (self.nom,len(self.nompar),len(val))) - return param2.Unop2(self.nom,self.realCall,val) - - def realCall(self,*val): - if hasattr(self.parent,'contexte_fichier_init'): - context=self.parent.contexte_fichier_init - else : context={} - i=0 - for param in self.nompar : - context[param]=val[i] - i=i+1 - try : - res=eval(self.expression,self.jdc.const_context, context) - except : - print (75 * '!') - print ('! ' + "Erreur evaluation formule %s" % self.nom + 20*'!') - print (75 * '!') - raise EficasException - return res - +class formule(FONCTION) : + def __call__(self,*val): + if len(val) != len(self.nompar): + raise TypeError(" %s() takes exactly %d argument (%d given)" % (self.nom,len(self.nompar),len(val))) + return param2.Unop2(self.nom,self.realCall,val) + def realCall(self,*val): + if hasattr(self.parent,'contexte_fichier_init'): + context=self.parent.contexte_fichier_init + else : context={} + i=0 + for param in self.nompar : + context[param]=val[i] + i=i+1 + try : + res=eval(self.expression,self.jdc.const_context, context) + except : + print (75 * '!') + print ('! ' + "Erreur evaluation formule %s" % self.nom + 20*'!') + print (75 * '!') + raise EficasException + return res diff --git a/Ihm/I_FORM_ETAPE.py b/Ihm/I_FORM_ETAPE.py index b97ac8f8..cb47551e 100644 --- a/Ihm/I_FORM_ETAPE.py +++ b/Ihm/I_FORM_ETAPE.py @@ -59,15 +59,15 @@ class FORM_ETAPE(MACRO_ETAPE): return None,None,None type_retourne="REEL" if len(self.mcListe) > 0: - child = self.mcListe[0] # child est un MCSIMP - corps = child.getVal() + child = self.mcListe[0] # child est un MCSIMP + corps = child.getVal() else: - corps = None + corps = None if len(self.mcListe) > 1: - child = self.mcListe[1] - l_args= child.getVal() + child = self.mcListe[1] + l_args= child.getVal() else : - l_args=None + l_args=None return type_retourne,l_args,corps def getNom(self): @@ -258,8 +258,8 @@ class FORM_ETAPE(MACRO_ETAPE): if sd: sd.nom = formule[0] - # bidouille PN - # Il faut que formule soit constituee de + # bidouille PN + # Il faut que formule soit constituee de # nom de la formule # type retourne # parametres @@ -269,19 +269,19 @@ class FORM_ETAPE(MACRO_ETAPE): self.buildMc() self.mcListe=[] if len(formule) < 4 : - return 0 + return 0 arguments=formule[3] if arguments[0] == '(' : - arguments=arguments[1:] + arguments=arguments[1:] if arguments[-1] == ')' : - arguments=arguments[:-1] + arguments=arguments[:-1] self.arguments=tuple(arguments.split(',')) mocles={"NOM_PARA":self.arguments} if formule[1] == "REEL": - mocles["VALE"]=formule[2] + mocles["VALE"]=formule[2] if formule[1] == "COMPLEXE": - mocles["VALE_C"]=formule[2] + mocles["VALE_C"]=formule[2] for k,v in self.definition.entites.items(): if not k in mocles : continue @@ -289,7 +289,7 @@ class FORM_ETAPE(MACRO_ETAPE): child.valeur=mocles[k] child.state = 'modified' self.mcListe.append(child) - + self.corps = formule[2] self.type_retourne = formule[1] sd = self.getSdProd() @@ -326,18 +326,18 @@ class FORM_ETAPE(MACRO_ETAPE): return def deleteConcept(self,sd): - """ + """ Inputs : - sd=concept detruit Fonction : Mettre a jour les mots cles de l etape et eventuellement 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, - sauf les objets FORM_ETAPE qui doivent verifier que le concept detruit n'est pas + sauf les objets FORM_ETAPE qui doivent verifier que le concept detruit n'est pas utilise dans le corps de la fonction """ self.initModif() - + def replaceConcept(self,old_sd,sd): """ Inputs : @@ -348,4 +348,3 @@ class FORM_ETAPE(MACRO_ETAPE): utilise dans le corps de la fonction """ self.initModif() - diff --git a/Ihm/I_JDC.py b/Ihm/I_JDC.py index 0f217679..6c72ce63 100644 --- a/Ihm/I_JDC.py +++ b/Ihm/I_JDC.py @@ -45,974 +45,974 @@ except NameError: basestring = str class LASSD: - pass + pass class JDC(I_OBJECT.OBJECT): - """ - """ - def __init__(self): - self.editmode=0 - self.etapes_niveaux=[] - self.niveau=self - self.params=[] - self.fonctions=[] - self._etape_context=None - self.recorded_units={} - self.old_recorded_units={} - - - def getIndex(self,objet): - """ - Retourne la position d'objet dans la liste self - """ - return self.etapes.index(objet) - - def getSdAvantDuBonType(self,etape,types_permis): - """ - Retourne la liste des concepts avant etape d'un type acceptable - """ - #print ('getSdAvantDuBonType ', types_permis) - d=self.getContexteAvant(etape) - - l=[] - for k,v in d.items(): - #if type(v) != types.InstanceType and not isinstance(v,object): continue - if not isinstance(v,object): continue - # On considere que seul assd indique un type quelconque pas CO - elif self.assd in types_permis : - if v.etape.sdnom != "sansnom" : l.append(k) - elif self.estPermis(v,types_permis): - if v.etape.sdnom != "sansnom" : l.append(k) - l.sort() - return l - - def getSdCreeParObjet(self,classeAChercher): - l=[] - for v in list(self.sdsDict.keys()): - if (isinstance(self.sdsDict[v], classeAChercher)) : - l.append(self.sdsDict[v]) - return l - - #def getSdCreeParObjetAvecFiltre(self,objectAssdMultiple): - # classeAChercher = objectAssdMultiple.definition.type - # filtre = objectAssdMultiple.definition.filtre - # print ('getSdCreeParObjetAvecFiltre', classeAChercher, filtre) - # l=[] - # from Noyau.N_BLOC import blocUtils - # globs = self and self.condition_context or {} - #dicoValeurs = self.creeDictCondition(mcListe, condition=1) - #creeDictValeurs - #dico = blocUtils() - #print (dico) - #for v in list(self.sdsDict.keys()): - # if (isinstance(self.sdsDict[v], classeAChercher)) : - # l.append(self.sdsDict[v]) - #return l - - def getVariables(self,etape): - etapeStop=etape - l=[] - for etapeTraitee in self.etapes : - if etapeTraitee==etapeStop: - break - if etapeTraitee.nom == 'VARIABLE' : - variable=etapeTraitee.getMocle('ModelVariable') - if variable != None : - l.append(variable.nom) - return l - - def getDistributions(self,etape): - etapeStop=etape - l=[] - for etapeTraitee in self.etapes : - if etapeTraitee==etapeStop: break - if etapeTraitee.nom == 'DISTRIBUTION' and etapeTraitee.sd !=None : l.append(etapeTraitee.sd.nom) - return l - - - #def set_Copules_recalcule_etat(self): - # for etapeTraitee in self.etapes : - # if etapeTraitee.nom == 'CORRELATION' : - #Matrix=etapeTraitee.getChild('Matrix') - #if Matrix !=None : - # Correlation=etapeTraitee.getChild('CorrelationMatrix') - # if Correlation !=None : Correlation.state='arecalculer' - # Matrix.state='arecalculer' - - #def recalculeEtatCorrelation(self): - # for etapeTraitee in self.etapes : - # if etapeTraitee.nom == 'CORRELATION' : - #Matrix=etapeTraitee.getChild('Matrix') - #if Matrix !=None : - # Matrix.state='arecalculer' - # Correlation=Matrix.getChild('CorrelationMatrix') - # if Correlation !=None : Correlation.state='arecalculer' - # Correlation.isValid() - # Matrix.isValid() - # etapeTraitee.state='arecalculer' - # if etapeTraitee.state=='arecalculer': etapeTraitee.isValid() - - def recalculeEtatCorrelation(self): - for etapeTraitee in self.etapes : - if etapeTraitee.nom == 'CORRELATION' : - Correlation=etapeTraitee.getChild('CorrelationMatrix') - if Correlation !=None : - Correlation.state='arecalculer' - Correlation.isValid() - etapeTraitee.isValid() - - def recalculeValiditeApresChangementGlobalJdc(self, motClef): - #print ("je passe dans recalculeValiditeApresChangementGlobalJdc") + """ + """ + def __init__(self): + self.editmode=0 + self.etapes_niveaux=[] + self.niveau=self + self.params=[] + self.fonctions=[] + self._etape_context=None + self.recorded_units={} + self.old_recorded_units={} + + + def getIndex(self,objet): + """ + Retourne la position d'objet dans la liste self + """ + return self.etapes.index(objet) + + def getSdAvantDuBonType(self,etape,types_permis): + """ + Retourne la liste des concepts avant etape d'un type acceptable + """ + #print ('getSdAvantDuBonType ', types_permis) + d=self.getContexteAvant(etape) + + l=[] + for k,v in d.items(): + #if type(v) != types.InstanceType and not isinstance(v,object): continue + if not isinstance(v,object): continue + # On considere que seul assd indique un type quelconque pas CO + elif self.assd in types_permis : + if v.etape.sdnom != "sansnom" : l.append(k) + elif self.estPermis(v,types_permis): + if v.etape.sdnom != "sansnom" : l.append(k) + l.sort() + return l + + def getSdCreeParObjet(self,classeAChercher): + l=[] + for v in list(self.sdsDict.keys()): + if (isinstance(self.sdsDict[v], classeAChercher)) : + l.append(self.sdsDict[v]) + return l + + #def getSdCreeParObjetAvecFiltre(self,objectAssdMultiple): + # classeAChercher = objectAssdMultiple.definition.type + # filtre = objectAssdMultiple.definition.filtre + # print ('getSdCreeParObjetAvecFiltre', classeAChercher, filtre) + # l=[] + # from Noyau.N_BLOC import blocUtils + # globs = self and self.condition_context or {} + #dicoValeurs = self.creeDictCondition(mcListe, condition=1) + #creeDictValeurs + #dico = blocUtils() + #print (dico) + #for v in list(self.sdsDict.keys()): + # if (isinstance(self.sdsDict[v], classeAChercher)) : + # l.append(self.sdsDict[v]) + #return l + + def getVariables(self,etape): + etapeStop=etape + l=[] + for etapeTraitee in self.etapes : + if etapeTraitee==etapeStop: + break + if etapeTraitee.nom == 'VARIABLE' : + variable=etapeTraitee.getMocle('ModelVariable') + if variable != None : + l.append(variable.nom) + return l + + def getDistributions(self,etape): + etapeStop=etape + l=[] + for etapeTraitee in self.etapes : + if etapeTraitee==etapeStop: break + if etapeTraitee.nom == 'DISTRIBUTION' and etapeTraitee.sd !=None : l.append(etapeTraitee.sd.nom) + return l + + + #def set_Copules_recalcule_etat(self): + # for etapeTraitee in self.etapes : + # if etapeTraitee.nom == 'CORRELATION' : + #Matrix=etapeTraitee.getChild('Matrix') + #if Matrix !=None : + # Correlation=etapeTraitee.getChild('CorrelationMatrix') + # if Correlation !=None : Correlation.state='arecalculer' + # Matrix.state='arecalculer' + + #def recalculeEtatCorrelation(self): + # for etapeTraitee in self.etapes : + # if etapeTraitee.nom == 'CORRELATION' : + #Matrix=etapeTraitee.getChild('Matrix') + #if Matrix !=None : + # Matrix.state='arecalculer' + # Correlation=Matrix.getChild('CorrelationMatrix') + # if Correlation !=None : Correlation.state='arecalculer' + # Correlation.isValid() + # Matrix.isValid() + # etapeTraitee.state='arecalculer' + # if etapeTraitee.state=='arecalculer': etapeTraitee.isValid() + + def recalculeEtatCorrelation(self): + for etapeTraitee in self.etapes : + if etapeTraitee.nom == 'CORRELATION' : + Correlation=etapeTraitee.getChild('CorrelationMatrix') + if Correlation !=None : + Correlation.state='arecalculer' + Correlation.isValid() + etapeTraitee.isValid() + + def recalculeValiditeApresChangementGlobalJdc(self, motClef): + #print ("je passe dans recalculeValiditeApresChangementGlobalJdc") try : - liste=self.getJdcRoot().cata.dict_condition[motClef.nom] + liste=self.getJdcRoot().cata.dict_condition[motClef.nom] except : - liste=() + liste=() for etapeTraitee in self.etapes : - if etapeTraitee.nom not in liste: continue - etapeTraitee.state='arecalculer' - etapeTraitee.deepUpdateConditionBloc() - etapeTraitee.isValid() - #print (etapeTraitee.nom ,etapeTraitee.isValid()) - - def activeBlocsGlobaux(self): - for nomMotClef in self.mc_globaux : - motClef=self.mc_globaux[nomMotClef] - if nomMotClef in list(self.cata.dict_condition.keys()): - liste=self.cata.dict_condition[nomMotClef] - else : liste=() - for etapeTraitee in self.etapes : - if etapeTraitee.nom not in liste: continue - etapeTraitee.state='arecalculer' - etapeTraitee.deepUpdateConditionBlocApresCreation() - etapeTraitee.isValid() - - - - #def forceRecalculBloc(self,objet): - # Attention : certains objets deviennent None quand on recalcule - # les conditions d existence des blocs - # if objet != None: objet.state='arecalculer' - # if hasattr(objet,'listeMcPresents'): - # for childNom in objet.listeMcPresents(): - # child=objet.getChild(childNom) - # if hasattr(objet,'_updateConditionBloc'):objet._updateConditionBloc() - # self.forceRecalculBloc(child) - - - def getSdAvantDuBonTypePourTypeDeBase(self,etape,type): - """ - Retourne la liste des concepts avant etape d'1 type de base acceptable - Attention different de la routine precedente : 1 seul type passe en parametre - Teste sur issubclass et par sur le type permis - """ - d=self.getContexteAvant(etape) - l=[] - try : - typeverif=self.cata.__dict__[type] - except : - return l - for k,v in d.items(): - if issubclass(v.__class__,typeverif): - l.append(k) - l.sort() - return l - - def chercheListAvant(self,etape,valeur): - d=self.getContexteAvant(etape) - for k,v in d.items(): - if issubclass(v.__class__,LASSD): - if k == valeur : - return k - # Attention pour enlever les . a la fin des pretendus reels - if k == valeur[0:-1] : - return v - return None - - def estPermis(self,v,types_permis): - for type_ok in types_permis: - if type_ok in ('R','I','C','TXM') and v in self.params : - return 1 - elif type_ok == 'R' and v.__class__.__name__ == 'reel' : - return 1 - elif type_ok == 'I' and v.__class__.__name__ == 'entier' : - return 1 - elif type_ok == 'C' and v.__class__.__name__ == 'complexe' : - return 1 - elif type_ok == 'TXM' and v.__class__.__name__ == 'chaine' : - return 1 - elif type(type_ok) != type and not isinstance(type_ok,type): - continue - elif v.__class__ == type_ok or issubclass(v.__class__,type_ok): - return 1 - return 0 - - def addEntite(self,name,pos): - """ - Ajoute une entite : - Si name est le nom d une commande ou un commentaire ajoute - une etape au JDC - Sinon remonte une erreur - """ - self.initModif() - self.editmode=1 - if name == "COMMENTAIRE" : - from Extensions import commentaire - # ajout d'un commentaire - self.setCurrentStep() - ind = 1 - for child in self.etapes : - if isinstance(child,commentaire.COMMENTAIRE): - ind = ind+1 - objet = commentaire.COMMENTAIRE('',parent=self) - objet.nom = "_comm_"+repr(ind) - if pos == None : pos = 0 - self.etapes.insert(pos,objet) - self.resetContext() - self.editmode=0 - self.activeEtapes() - CONNECTOR.Emit(self,"add",objet) - self.finModif() - return objet - elif name == "PARAMETRE": - # ajout d'un parametre - self.setCurrentStep() - nom_param = '_param_'+str(len(self.params)+1) - objet = parametre.PARAMETRE(nom=nom_param) - if pos == None : pos = 0 - self.etapes.insert(pos,objet) + if etapeTraitee.nom not in liste: continue + etapeTraitee.state='arecalculer' + etapeTraitee.deepUpdateConditionBloc() + etapeTraitee.isValid() + #print (etapeTraitee.nom ,etapeTraitee.isValid()) + + def activeBlocsGlobaux(self): + for nomMotClef in self.mc_globaux : + motClef=self.mc_globaux[nomMotClef] + if nomMotClef in list(self.cata.dict_condition.keys()): + liste=self.cata.dict_condition[nomMotClef] + else : liste=() + for etapeTraitee in self.etapes : + if etapeTraitee.nom not in liste: continue + etapeTraitee.state='arecalculer' + etapeTraitee.deepUpdateConditionBlocApresCreation() + etapeTraitee.isValid() + + + + #def forceRecalculBloc(self,objet): + # Attention : certains objets deviennent None quand on recalcule + # les conditions d existence des blocs + # if objet != None: objet.state='arecalculer' + # if hasattr(objet,'listeMcPresents'): + # for childNom in objet.listeMcPresents(): + # child=objet.getChild(childNom) + # if hasattr(objet,'_updateConditionBloc'):objet._updateConditionBloc() + # self.forceRecalculBloc(child) + + + def getSdAvantDuBonTypePourTypeDeBase(self,etape,type): + """ + Retourne la liste des concepts avant etape d'1 type de base acceptable + Attention different de la routine precedente : 1 seul type passe en parametre + Teste sur issubclass et par sur le type permis + """ + d=self.getContexteAvant(etape) + l=[] + try : + typeverif=self.cata.__dict__[type] + except : + return l + for k,v in d.items(): + if issubclass(v.__class__,typeverif): + l.append(k) + l.sort() + return l + + def chercheListAvant(self,etape,valeur): + d=self.getContexteAvant(etape) + for k,v in d.items(): + if issubclass(v.__class__,LASSD): + if k == valeur : + return k + # Attention pour enlever les . a la fin des pretendus reels + if k == valeur[0:-1] : + return v + return None + + def estPermis(self,v,types_permis): + for type_ok in types_permis: + if type_ok in ('R','I','C','TXM') and v in self.params : + return 1 + elif type_ok == 'R' and v.__class__.__name__ == 'reel' : + return 1 + elif type_ok == 'I' and v.__class__.__name__ == 'entier' : + return 1 + elif type_ok == 'C' and v.__class__.__name__ == 'complexe' : + return 1 + elif type_ok == 'TXM' and v.__class__.__name__ == 'chaine' : + return 1 + elif type(type_ok) != type and not isinstance(type_ok,type): + continue + elif v.__class__ == type_ok or issubclass(v.__class__,type_ok): + return 1 + return 0 + + def addEntite(self,name,pos): + """ + Ajoute une entite : + Si name est le nom d une commande ou un commentaire ajoute + une etape au JDC + Sinon remonte une erreur + """ + self.initModif() + self.editmode=1 + if name == "COMMENTAIRE" : + from Extensions import commentaire + # ajout d'un commentaire + self.setCurrentStep() + ind = 1 + for child in self.etapes : + if isinstance(child,commentaire.COMMENTAIRE): + ind = ind+1 + objet = commentaire.COMMENTAIRE('',parent=self) + objet.nom = "_comm_"+repr(ind) + if pos == None : pos = 0 + self.etapes.insert(pos,objet) + self.resetContext() + self.editmode=0 + self.activeEtapes() + CONNECTOR.Emit(self,"add",objet) + self.finModif() + return objet + elif name == "PARAMETRE": + # ajout d'un parametre + self.setCurrentStep() + nom_param = '_param_'+str(len(self.params)+1) + objet = parametre.PARAMETRE(nom=nom_param) + if pos == None : pos = 0 + self.etapes.insert(pos,objet) + self.resetContext() + self.editmode=0 + self.activeEtapes() + CONNECTOR.Emit(self,"add",objet) + self.finModif() + return objet + elif name == "PARAMETRE_EVAL": + # ajout d'un parametre EVAL + self.setCurrentStep() + nom_param = '_param_'+str(len(self.params)+1) + objet = parametre_eval.PARAMETRE_EVAL(nom=nom_param) + if pos == None : pos = 0 + self.etapes.insert(pos,objet) + self.resetContext() + self.editmode=0 + self.activeEtapes() + CONNECTOR.Emit(self,"add",objet) + self.finModif() + return objet + elif not( isinstance(name, basestring)): + #elif type(name)==types.InstanceType: + #elif isinstance(name,object): + # on est dans le cas ou on veut ajouter une commande deja + # existante (par copie donc) + # on est donc necessairement en mode editeur ... + objet = name + # Il ne faut pas oublier de reaffecter le parent d'obj (si copie) + from Extensions import commentaire + if not( isinstance (objet,commentaire.COMMENTAIRE)): + objet.reparent(self) + self.setCurrentStep() + if isinstance(objet,ETAPE): + if objet.nom_niveau_definition == 'JDC': + # l'objet depend directement du JDC + objet.niveau = self + else: + # l'etape depend d'un niveau et non directement du JDC : + # il faut l'enregistrer dans le niveau de parent + objet.parent.dict_niveaux[objet.nom_niveau_definition].register(objet) + objet.niveau = objet.parent.dict_niveaux[objet.nom_niveau_definition] + self.etapes.insert(pos,objet) + self.resetContext() + # il faut verifier que les concepts utilises par objet existent bien + # a ce niveau d'arborescence + objet.verifExistenceSd() + objet.updateMcGlobal() + self.editmode=0 + self.activeEtapes() + CONNECTOR.Emit(self,"add",objet) + self.finModif() + return objet + else : + # On veut ajouter une nouvelle commande + try: + self.setCurrentStep() + cmd=self.getCmd(name) + # L'appel a make_objet n'a pas pour effet d'enregistrer l'etape + # aupres du step courant car editmode vaut 1 + # Par contre elle a le bon parent grace a setCurrentStep + e=cmd.make_objet() + if pos == None : pos = 0 + self.etapes.insert(pos,e) + self.resetCurrentStep() + self.resetContext() + self.editmode=0 + self.activeEtapes() + self.enregistreEtapePyxb(e,pos) + # PN fait ds self.activeEtapes + CONNECTOR.Emit(self,"add",e) + self.finModif() + return e + except AsException as e: + traceback.print_exc() + self.resetCurrentStep() + self.editmode=0 + raise AsException(tr("Impossible d'ajouter la commande")+name + '\n') + except: + #else : + traceback.print_exc() + self.resetCurrentStep() + self.editmode=0 + raise AsException(tr("Impossible d ajouter la commande")+name) + + def close(self): + #print "JDC.close",self + for etape in self.etapes: + if hasattr(etape,"close"):etape.close() + CONNECTOR.Emit(self,"close") + + def setCurrentStep(self): + CONTEXT.unsetCurrentStep() + CONTEXT.setCurrentStep(self) + + def resetCurrentStep(self): + CONTEXT.unsetCurrentStep() + + def listeMcPresents(self): + return [] + + def getSdAvantEtape(self,nom_sd,etape): + return self.getContexteAvant(etape).get(nom_sd,None) + + def getSdApresEtapeAvecDetruire(self,nom_sd,sd,etape,avec='non'): + """ + Cette methode retourne la SD sd de nom nom_sd qui est eventuellement + definie apres etape en tenant compte des concepts detruits + Si avec vaut 'non' exclut etape de la recherche + """ + #print "JDC.getSdApresEtapeAvecDetruire",nom_sd,sd + ietap=self.etapes.index(etape) + if avec == 'non':ietap=ietap+1 + d={nom_sd:sd} + for e in self.etapes[ietap:]: + if e.isActif(): + e.updateContext(d) + autre_sd=d.get(nom_sd,None) + if autre_sd is None: + # Le concept a ete detruit. On interrompt la recherche car il n'y a + # pas eu de redefinition du concept (il n'y a pas de conflit potentiel). + return None + if autre_sd is not sd : + # L'etape produit un concept different de meme nom. La situation n'est + # pas saine (sauf peut etre si reuse ???) + if hasattr(e,'reuse') and e.reuse == autre_sd: + # Le concept etant reutilise, on interrompt la recherche. + # On considere qu'il n'y a pas de nouveau concept defini + # meme si dans les etapes suivantes le concept est detruit + # et un concept de meme nom cree. + # AVERIFIER : avec reuse le concept devrait etre le meme + # le passage par ici est tres improbable + return None + else: + # Le concept est produit par l'etape (Il y a conflit potentiel). + # Le concept est redefini par une etape posterieure. + return autre_sd + # Pas de destruction du concept ni de redefinition. On retourne le + # concept initial + return sd + + def getSdApresEtape(self,nom_sd,etape,avec='non'): + """ + Cette methode retourne la SD de nom nom_sd qui est eventuellement + definie apres etape + Si avec vaut 'non' exclut etape de la recherche + """ + ietap=self.etapes.index(etape) + if avec == 'non':ietap=ietap+1 + for e in self.etapes[ietap:]: + sd=e.getSdprods(nom_sd) + if sd: + if hasattr(e,'reuse'): + if e.reuse != sd: + return sd + return None + + def getSdAutourEtape(self,nom_sd,etape,avec='non'): + """ + Fonction: retourne la SD de nom nom_sd qui est eventuellement + definie avant ou apres etape + Permet de verifier si un concept de meme nom existe dans le perimetre + d'une etape + Si avec vaut 'non' exclut etape de la recherche + """ + sd=self.getSdAvantEtape(nom_sd,etape) + if sd:return sd + sd=self.getSdApresEtape(nom_sd,etape,avec) + if sd:return sd + # Pour tenir compte des UserASSD # et des UserASSDMultiple a affiner + if nom_sd in self.sdsDict.keys() : + sd=self.sdsDict[nom_sd] + return sd + + def getContexte_apres(self,etape): + """ + Retourne le dictionnaire des concepts connus apres etape + On tient compte des commandes qui modifient le contexte + comme DETRUIRE ou les macros + Si etape == None, on retourne le contexte en fin de JDC + """ + if not etape: return self.getContexteAvant(etape) + + d=self.getContexteAvant(etape) + if etape.isActif():etape.updateContext(d) + self.index_etape_courante=self.index_etape_courante+1 + return d + + def activeEtapes(self): + """ + """ + for etape in self.etapes: + etape.active() + + def deplaceEntite(self,indexNoeudACopier,indexNoeudOuColler,pos): + """ + Pour le cut + """ + if indexNoeudACopier==indexNoeudOuColler:return + etapeACopier=self.etapes[indexNoeudACopier] + try : + sd=self.etapes[indexNoeudACopier].sd + except : + sd=None + if pos=='before' and indexNoeudOuColler==0 : + self.etapes2=[etapeACopier,]+self.etapes[0:indexNoeudACopier]+self.etapes[indexNoeudACopier+1:] + elif indexNoeudACopier < indexNoeudOuColler : + self.etapes2=self.etapes[0:indexNoeudACopier]+self.etapes[indexNoeudACopier+1:indexNoeudOuColler+1]+[etapeACopier,]+self.etapes[indexNoeudOuColler+1:] + else: + self.etapes2=self.etapes[0:indexNoeudOuColler+1]+[etapeACopier,]+self.etapes[indexNoeudOuColler+1:indexNoeudACopier]+self.etapes[indexNoeudACopier+1:] + self.etapes=self.etapes2 + if indexNoeudACopier < indexNoeudOuColler : + self.deleteConceptEntreEtapes(indexNoeudACopier,indexNoeudOuColler,sd) self.resetContext() - self.editmode=0 + for e in self.etapes : + e.state = 'modified' + self.controlContextApres(None) + return 1 + + + def suppEntite(self,etape) : + """ + Cette methode a pour fonction de supprimer une etape dans + un jeu de commandes + Retourne 1 si la suppression a pu etre effectuee, + Retourne 0 dans le cas contraire + """ + #PN correction de bugs + if etape not in self.etapes: return 0 + + self.initModif() + index_etape=self.etapes.index(etape) + + #etape.delObjPyxb() + self.etapes.remove(etape) + + if etape.niveau is not self: + # Dans ce cas l'etape est enregistree dans un niveau + # Il faut la desenregistrer + etape.niveau.unregister(etape) + + etape.supprimeSdProds() + etape.supprimeUserAssd() + etape.close() + etape.supprime() self.activeEtapes() - CONNECTOR.Emit(self,"add",objet) - self.finModif() - return objet - elif name == "PARAMETRE_EVAL": - # ajout d'un parametre EVAL - self.setCurrentStep() - nom_param = '_param_'+str(len(self.params)+1) - objet = parametre_eval.PARAMETRE_EVAL(nom=nom_param) - if pos == None : pos = 0 - self.etapes.insert(pos,objet) + + # Apres suppression de l'etape il faut controler que les etapes + # suivantes ne produisent pas des concepts DETRUITS dans op_init de etape + if index_etape > 0: + index_etape=index_etape-1 + etape=self.etapes[index_etape] + else: + etape=None + self.controlContextApres(etape) + self.resetContext() - self.editmode=0 - self.activeEtapes() - CONNECTOR.Emit(self,"add",objet) + CONNECTOR.Emit(self,"supp",etape) self.finModif() - return objet - elif not( isinstance(name, basestring)): - #elif type(name)==types.InstanceType: - #elif isinstance(name,object): - # on est dans le cas ou on veut ajouter une commande deja - # existante (par copie donc) - # on est donc necessairement en mode editeur ... - objet = name - # Il ne faut pas oublier de reaffecter le parent d'obj (si copie) - from Extensions import commentaire - if not( isinstance (objet,commentaire.COMMENTAIRE)): - objet.reparent(self) - self.setCurrentStep() - if isinstance(objet,ETAPE): - if objet.nom_niveau_definition == 'JDC': - # l'objet depend directement du JDC - objet.niveau = self - else: - # l'etape depend d'un niveau et non directement du JDC : - # il faut l'enregistrer dans le niveau de parent - objet.parent.dict_niveaux[objet.nom_niveau_definition].register(objet) - objet.niveau = objet.parent.dict_niveaux[objet.nom_niveau_definition] - self.etapes.insert(pos,objet) - self.resetContext() - # il faut verifier que les concepts utilises par objet existent bien - # a ce niveau d'arborescence - objet.verifExistenceSd() - objet.updateMcGlobal() - self.editmode=0 + return 1 + + def controlContextApres(self,etape): + """ + Cette methode verifie que les etapes apres l'etape etape + ont bien des concepts produits acceptables (pas de conflit de + nom principalement) + Si des concepts produits ne sont pas acceptables ils sont supprimes. + Effectue les verifications sur les etapes du jdc mais aussi sur les + jdc parents s'ils existent. + """ + #print ("controlContextApres",self,etape) + #Regularise les etapes du jdc apres l'etape etape + self.controlJdcContextApres(etape) + + def controlJdcContextApres(self,etape): + """ + Methode semblable a controlContextApres mais ne travaille + que sur les etapes et sous etapes du jdc + """ + #print ("controlJdcContextApres",self,etape) + if etape is None: + # on demarre de la premiere etape + index_etape=0 + else: + index_etape=self.etapes.index(etape)+1 + + try: + etape=self.etapes[index_etape] + except: + #derniere etape du jdc : rien a faire + return + + context=self.getContexteAvant(etape) + for e in self.etapes[index_etape:]: + e.controlSdprods(context) + e.updateContext(context) + + def analyse(self): + self.compile() + self.execCompile() + if not self.cr.estvide():return self.activeEtapes() - CONNECTOR.Emit(self,"add",objet) + if self.mc_globaux != {} : self.activeBlocsGlobaux() + + def analyseXML(self): + #print ('analyseXML') + #print (self.procedure) + self.setCurrentContext() + self.analyseFromXML() + + def registerParametre(self,param): + """ + Cette methode sert a ajouter un parametre dans la liste des parametres + """ + self.params.append(param) + + def registerFonction(self,fonction): + """ + Cette methode sert a ajouter une fonction dans la liste des fonctions + """ + self.fonctions.append(fonction) + + def deleteParam(self,param): + """ + Supprime le parametre param de la liste des parametres + et du contexte gobal + """ + if param in self.params : self.params.remove(param) + if param.nom in self.g_context : del self.g_context[param.nom] + + def getParametresFonctionsAvantEtape(self,etape): + """ + Retourne deux elements : + - une liste contenant les noms des parametres (constantes ou EVAL) + definis avant etape + - une liste contenant les formules definies avant etape + """ + l_constantes = [] + l_fonctions = [] + # on recupere le contexte avant etape + # on ne peut mettre dans les deux listes que des elements de ce contexte + d=self.getContexteAvant(etape) + # construction de l_constantes + for param in self.params: + nom = param.nom + if not nom : continue + if nom in d: l_constantes.append(nom) + # construction de l_fonctions + for form in self.fonctions: + nom = form.nom + if not nom : continue + if nom in d: l_fonctions.append(form.getFormule()) + + # on ajoute les concepts produits par DEFI_VALEUR + # XXX On pourrait peut etre faire plutot le test sur le type + # de concept : entier, reel, complexe, etc. + for k,v in d.items(): + if hasattr(v,'etape') and v.etape.nom in ('DEFI_VALEUR',): + l_constantes.append(k) + + # on retourne les deux listes + return l_constantes,l_fonctions + + def getNbEtapesAvant(self,niveau): + """ + Retourne le nombre d etapes avant le debut de niveau + """ + nb=0 + for niv in self.etapes_niveaux: + if niv == niveau:break + nb=nb+len(niv.etapes) + return nb + + def initModif(self): + """ + Methode appelee au moment ou une modification va etre faite afin de + declencher d'eventuels traitements pre-modification + """ + #print "initModif",self + self.state = 'modified' + + def finModif(self): + #print "finModif",self + CONNECTOR.Emit(self,"valid") + self.isValid() + pass + + def deepUpdateConditionBloc(self,motClef=None): + self.getJdcRoot().recalculeValiditeApresChangementGlobalJdc(motClef) + #raise EficasException(tr("Pas implemente")) + + def updateConditionBloc(self): + # pour le moment, on ne fait rien + raise EficasException(tr("Pas implemente")) + + def getListeMcInconnus(self): + """ + Retourne une liste contenant les mots-cles inconnus a la relecture du JDC + """ + # cette liste a le format suivant : [etape,(bloc,mcfact,...),nom_mc,valeur_mc] + l_mc = [] + for etape in self.etapes : + if etape.isActif() : + if not etape.isValid() : + l = etape.getListeMcInconnus() + if l : l_mc.extend(l) + return l_mc + + def getGenealogiePrecise(self): + return [] + + def getGenealogie(self): + """ + Retourne la liste des noms des ascendants de l'objet self + jusqu'a la premiere ETAPE parent. + """ + return [] + + def getListeCmd(self): + """ + Retourne la liste des commandes du catalogue + """ + return self.niveau.definition.getListeCmd() + + def getGroups(self): + """ + Retourne la liste des groupes + """ + return self.niveau.definition.liste_groupes,self.niveau.definition.dict_groupes + + def setEtapeContext(self,etape): + """ + Positionne l'etape qui sera utilisee dans NommerSdProd pour + decider si le concept passe pourra etre nomme + """ + self._etape_context=etape + + def resetContext(self): + """ + Cette methode reinitialise le contexte glissant pour pouvoir + tenir compte des modifications de l'utilisateur : craation + de commandes, nommage de concepts, etc. + """ + #print "resetContext",self,self.nom + self.currentContext={} + self.index_etape_courante=0 + ind={} + for i,etape in enumerate(self.etapes): + ind[etape]=i + self.index_etapes=ind + + # for etape in self.etapes: + # etape.resetContext() + + def delSdprod(self,sd): + """ + Supprime la SD sd de la liste des sd et des dictionnaires de contexte + """ + #print "delSdprod",self,sd + #print "delSdprod",self.sds + #print "delSdprod",self.g_context + #print "delSdprod",self.sdsDict + #if sd in self.sds : self.sds.remove(sd) + if sd.nom in self.g_context : del self.g_context[sd.nom] + if sd.nom in self.sdsDict : del self.sdsDict[sd.nom] + + def delParam(self,param): + """ + Supprime le parametre param de la liste des paramatres + et du contexte gobal + """ + if param in self.params : self.params.remove(param) + if param.nom in self.g_context : del self.g_context[param.nom] + + def delFonction(self,fonction): + """ + Supprime la fonction fonction de la liste des fonctions + et du contexte gobal + """ + if fonction in self.fonctions : self.fonctions.remove(fonction) + if fonction.nom in self.g_context: del self.g_context[fonction.nom] + + def appendSdProd(self,sd): + """ + Ajoute la SD sd a la liste des sd en verifiant au prealable qu'une SD de + meme nom n'existe pas deja + """ + if sd == None or sd.nom == None:return + o=self.sdsDict.get(sd.nom,None) + if isinstance(o,ASSD): + raise AsException(tr("Nom de concept deja defini "+ sd.nom)) + self.sdsDict[sd.nom]=sd + self.g_context[sd.nom] = sd + #if sd not in self.sds : self.sds.append(sd) + + def appendParam(self,param): + """ + Ajoute le parametre param a la liste des params + et au contexte global + """ + # il faudrait verifier qu'un parametre de meme nom n'existe pas deja !!! + if param not in self.params : self.params.append(param) + self.g_context[param.nom]=param + + def appendFonction(self,fonction): + """ + Ajoute la fonction fonction a la liste des fonctions + et au contexte global + """ + # il faudrait verifier qu'une fonction de meme nom n'existe pas deja !!! + if fonction not in self.fonctions : self.fonctions.append(fonction) + self.g_context[fonction.nom]=fonction + + def deleteConcept(self,sd): + """ + Inputs : + - sd=concept detruit + Fonction : + Mettre a jour les etapes du JDC suite a la disparition du + concept sd + Seuls les mots cles simples MCSIMP font un traitement autre + que de transmettre aux fils + """ + for etape in self.etapes : + etape.deleteConcept(sd) + #PN PN PN pour les matrices ???? + #self.getVariables_avant(etape) + + def replaceConceptAfterEtape(self,etape,old_sd,sd): + """ + Met a jour les etapes du JDC qui sont apres etape en fonction + du remplacement du concept sd + """ + index = self.etapes.index(etape)+1 + if index == len(self.etapes) : + return # etape est la derniere etape du jdc ...on ne fait rien ! + for child in self.etapes[index:]: + child.replaceConcept(old_sd,sd) + + def updateConceptAfterEtape(self,etape,sd): + """ + Met a jour les etapes du JDC qui sont apres etape en fonction + de la modification (principalement nommage) du concept sd + """ + if etape is None: + #On traite toutes les etapes + index=0 + else: + index = self.etapes.index(etape)+1 + if index == len(self.etapes) : + return # etape est la derniere etape du jdc ...on ne fait rien ! + for child in self.etapes[index:]: + child.updateConcept(sd) + + def dumpState(self): + #print(("JDC.state: ",self.state)) + for etape in self.etapes : + print((etape.nom+".state: ",etape.state)) + + def changeUnit(self,unit,etape,old_unit): + #print "changeUnit",unit,etape,old_unit + #print id(self.recorded_units),self.recorded_units + #if self.recorded_units.has_key(old_unit):del self.recorded_units[old_unit] + self.recordUnit(unit,etape) + + def recordUnit(self,unit,etape): + """Enregistre les unites logiques incluses et les infos relatives a l'etape""" + #print "recordUnit",unit,etape + if unit is None: + # Cas de POURSUITE + self.recorded_units[None]=(etape.fichier_ini ,etape.fichier_text,etape.recorded_units) + else: + self.recorded_units[unit]=(etape.fichier_ini ,etape.fichier_text,etape.recorded_units) + #print id(self.recorded_units),self.recorded_units + #print self.recorded_units.get(None,(None,"",{}))[2] + #print self.recorded_units.get(None,(None,"",{}))[2].get(None,(None,"",{})) + + def changeFichier(self,fichier): self.finModif() - return objet - else : - # On veut ajouter une nouvelle commande - try: - self.setCurrentStep() - cmd=self.getCmd(name) - # L'appel a make_objet n'a pas pour effet d'enregistrer l'etape - # aupres du step courant car editmode vaut 1 - # Par contre elle a le bon parent grace a setCurrentStep - e=cmd.make_objet() - if pos == None : pos = 0 - self.etapes.insert(pos,e) - self.resetCurrentStep() - self.resetContext() - self.editmode=0 - self.activeEtapes() - self.enregistreEtapePyxb(e,pos) - # PN fait ds self.activeEtapes - CONNECTOR.Emit(self,"add",e) - self.finModif() - return e - except AsException as e: - traceback.print_exc() - self.resetCurrentStep() - self.editmode=0 - raise AsException(tr("Impossible d'ajouter la commande")+name + '\n') + + def evalInContext(self,valeur,etape): + """ Tente d'evaluer valeur dans le contexte courant de etape + Retourne le parametre valeur inchange si l'evaluation est impossible + """ + #contexte initial du jdc + context=self.condition_context.copy() + #contexte courant des concepts. Il contient les parametres + context.update(self.getContexteAvant(etape)) + try : + objet = eval(valeur,context) + return objet except: - #else : - traceback.print_exc() - self.resetCurrentStep() - self.editmode=0 - raise AsException(tr("Impossible d ajouter la commande")+name) - - def close(self): - #print "JDC.close",self - for etape in self.etapes: - if hasattr(etape,"close"):etape.close() - CONNECTOR.Emit(self,"close") - - def setCurrentStep(self): - CONTEXT.unsetCurrentStep() - CONTEXT.setCurrentStep(self) - - def resetCurrentStep(self): - CONTEXT.unsetCurrentStep() - - def listeMcPresents(self): - return [] - - def getSdAvantEtape(self,nom_sd,etape): - return self.getContexteAvant(etape).get(nom_sd,None) - - def getSdApresEtapeAvecDetruire(self,nom_sd,sd,etape,avec='non'): - """ - Cette methode retourne la SD sd de nom nom_sd qui est eventuellement - definie apres etape en tenant compte des concepts detruits - Si avec vaut 'non' exclut etape de la recherche - """ - #print "JDC.getSdApresEtapeAvecDetruire",nom_sd,sd - ietap=self.etapes.index(etape) - if avec == 'non':ietap=ietap+1 - d={nom_sd:sd} - for e in self.etapes[ietap:]: - if e.isActif(): - e.updateContext(d) - autre_sd=d.get(nom_sd,None) - if autre_sd is None: - # Le concept a ete detruit. On interrompt la recherche car il n'y a - # pas eu de redefinition du concept (il n'y a pas de conflit potentiel). - return None - if autre_sd is not sd : - # L'etape produit un concept different de meme nom. La situation n'est - # pas saine (sauf peut etre si reuse ???) - if hasattr(e,'reuse') and e.reuse == autre_sd: - # Le concept etant reutilise, on interrompt la recherche. - # On considere qu'il n'y a pas de nouveau concept defini - # meme si dans les etapes suivantes le concept est detruit - # et un concept de meme nom cree. - # AVERIFIER : avec reuse le concept devrait etre le meme - # le passage par ici est tres improbable - return None - else: - # Le concept est produit par l'etape (Il y a conflit potentiel). - # Le concept est redefini par une etape posterieure. - return autre_sd - # Pas de destruction du concept ni de redefinition. On retourne le - # concept initial - return sd - - def getSdApresEtape(self,nom_sd,etape,avec='non'): - """ - Cette methode retourne la SD de nom nom_sd qui est eventuellement - definie apres etape - Si avec vaut 'non' exclut etape de la recherche - """ - ietap=self.etapes.index(etape) - if avec == 'non':ietap=ietap+1 - for e in self.etapes[ietap:]: - sd=e.getSdprods(nom_sd) - if sd: - if hasattr(e,'reuse'): - if e.reuse != sd: - return sd - return None - - def getSdAutourEtape(self,nom_sd,etape,avec='non'): - """ - Fonction: retourne la SD de nom nom_sd qui est eventuellement - definie avant ou apres etape - Permet de verifier si un concept de meme nom existe dans le perimetre - d'une etape - Si avec vaut 'non' exclut etape de la recherche - """ - sd=self.getSdAvantEtape(nom_sd,etape) - if sd:return sd - sd=self.getSdApresEtape(nom_sd,etape,avec) - if sd:return sd - # Pour tenir compte des UserASSD # et des UserASSDMultiple a affiner - if nom_sd in self.sdsDict.keys() : - sd=self.sdsDict[nom_sd] - return sd - - def getContexte_apres(self,etape): - """ - Retourne le dictionnaire des concepts connus apres etape - On tient compte des commandes qui modifient le contexte - comme DETRUIRE ou les macros - Si etape == None, on retourne le contexte en fin de JDC - """ - if not etape: return self.getContexteAvant(etape) - - d=self.getContexteAvant(etape) - if etape.isActif():etape.updateContext(d) - self.index_etape_courante=self.index_etape_courante+1 - return d - - def activeEtapes(self): - """ - """ - for etape in self.etapes: - etape.active() - - def deplaceEntite(self,indexNoeudACopier,indexNoeudOuColler,pos): - """ - Pour le cut - """ - if indexNoeudACopier==indexNoeudOuColler:return - etapeACopier=self.etapes[indexNoeudACopier] - try : - sd=self.etapes[indexNoeudACopier].sd - except : - sd=None - if pos=='before' and indexNoeudOuColler==0 : - self.etapes2=[etapeACopier,]+self.etapes[0:indexNoeudACopier]+self.etapes[indexNoeudACopier+1:] - elif indexNoeudACopier < indexNoeudOuColler : - self.etapes2=self.etapes[0:indexNoeudACopier]+self.etapes[indexNoeudACopier+1:indexNoeudOuColler+1]+[etapeACopier,]+self.etapes[indexNoeudOuColler+1:] - else: - self.etapes2=self.etapes[0:indexNoeudOuColler+1]+[etapeACopier,]+self.etapes[indexNoeudOuColler+1:indexNoeudACopier]+self.etapes[indexNoeudACopier+1:] - self.etapes=self.etapes2 - if indexNoeudACopier < indexNoeudOuColler : - self.deleteConceptEntreEtapes(indexNoeudACopier,indexNoeudOuColler,sd) - self.resetContext() - for e in self.etapes : - e.state = 'modified' - self.controlContextApres(None) - return 1 - - - def suppEntite(self,etape) : - """ - Cette methode a pour fonction de supprimer une etape dans - un jeu de commandes - Retourne 1 si la suppression a pu etre effectuee, - Retourne 0 dans le cas contraire - """ - #PN correction de bugs - if etape not in self.etapes: return 0 - - self.initModif() - index_etape=self.etapes.index(etape) - - #etape.delObjPyxb() - self.etapes.remove(etape) - - if etape.niveau is not self: - # Dans ce cas l'etape est enregistree dans un niveau - # Il faut la desenregistrer - etape.niveau.unregister(etape) - - etape.supprimeSdProds() - etape.supprimeUserAssd() - etape.close() - etape.supprime() - self.activeEtapes() - - # Apres suppression de l'etape il faut controler que les etapes - # suivantes ne produisent pas des concepts DETRUITS dans op_init de etape - if index_etape > 0: - index_etape=index_etape-1 - etape=self.etapes[index_etape] - else: - etape=None - self.controlContextApres(etape) - - self.resetContext() - CONNECTOR.Emit(self,"supp",etape) - self.finModif() - return 1 - - def controlContextApres(self,etape): - """ - Cette methode verifie que les etapes apres l'etape etape - ont bien des concepts produits acceptables (pas de conflit de - nom principalement) - Si des concepts produits ne sont pas acceptables ils sont supprimes. - Effectue les verifications sur les etapes du jdc mais aussi sur les - jdc parents s'ils existent. - """ - #print ("controlContextApres",self,etape) - #Regularise les etapes du jdc apres l'etape etape - self.controlJdcContextApres(etape) - - def controlJdcContextApres(self,etape): - """ - Methode semblable a controlContextApres mais ne travaille - que sur les etapes et sous etapes du jdc - """ - #print ("controlJdcContextApres",self,etape) - if etape is None: - # on demarre de la premiere etape - index_etape=0 - else: - index_etape=self.etapes.index(etape)+1 - - try: - etape=self.etapes[index_etape] - except: - #derniere etape du jdc : rien a faire - return - - context=self.getContexteAvant(etape) - for e in self.etapes[index_etape:]: - e.controlSdprods(context) - e.updateContext(context) - - def analyse(self): - self.compile() - self.execCompile() - if not self.cr.estvide():return - self.activeEtapes() - if self.mc_globaux != {} : self.activeBlocsGlobaux() - - def analyseXML(self): - #print ('analyseXML') - #print (self.procedure) - self.setCurrentContext() - self.analyseFromXML() - - def registerParametre(self,param): - """ - Cette methode sert a ajouter un parametre dans la liste des parametres - """ - self.params.append(param) - - def registerFonction(self,fonction): - """ - Cette methode sert a ajouter une fonction dans la liste des fonctions - """ - self.fonctions.append(fonction) - - def deleteParam(self,param): - """ - Supprime le parametre param de la liste des parametres - et du contexte gobal - """ - if param in self.params : self.params.remove(param) - if param.nom in self.g_context : del self.g_context[param.nom] - - def getParametresFonctionsAvantEtape(self,etape): - """ - Retourne deux elements : - - une liste contenant les noms des parametres (constantes ou EVAL) - definis avant etape - - une liste contenant les formules definies avant etape - """ - l_constantes = [] - l_fonctions = [] - # on recupere le contexte avant etape - # on ne peut mettre dans les deux listes que des elements de ce contexte - d=self.getContexteAvant(etape) - # construction de l_constantes - for param in self.params: - nom = param.nom - if not nom : continue - if nom in d: l_constantes.append(nom) - # construction de l_fonctions - for form in self.fonctions: - nom = form.nom - if not nom : continue - if nom in d: l_fonctions.append(form.getFormule()) - - # on ajoute les concepts produits par DEFI_VALEUR - # XXX On pourrait peut etre faire plutot le test sur le type - # de concept : entier, reel, complexe, etc. - for k,v in d.items(): - if hasattr(v,'etape') and v.etape.nom in ('DEFI_VALEUR',): - l_constantes.append(k) - - # on retourne les deux listes - return l_constantes,l_fonctions - - def getNbEtapesAvant(self,niveau): - """ - Retourne le nombre d etapes avant le debut de niveau - """ - nb=0 - for niv in self.etapes_niveaux: - if niv == niveau:break - nb=nb+len(niv.etapes) - return nb - - def initModif(self): - """ - Methode appelee au moment ou une modification va etre faite afin de - declencher d'eventuels traitements pre-modification - """ - #print "initModif",self - self.state = 'modified' - - def finModif(self): - #print "finModif",self - CONNECTOR.Emit(self,"valid") - self.isValid() - pass - - def deepUpdateConditionBloc(self,motClef=None): - self.getJdcRoot().recalculeValiditeApresChangementGlobalJdc(motClef) - #raise EficasException(tr("Pas implemente")) - - def updateConditionBloc(self): - # pour le moment, on ne fait rien - raise EficasException(tr("Pas implemente")) - - def getListeMcInconnus(self): - """ - Retourne une liste contenant les mots-cles inconnus a la relecture du JDC - """ - # cette liste a le format suivant : [etape,(bloc,mcfact,...),nom_mc,valeur_mc] - l_mc = [] - for etape in self.etapes : - if etape.isActif() : - if not etape.isValid() : - l = etape.getListeMcInconnus() - if l : l_mc.extend(l) - return l_mc - - def getGenealogiePrecise(self): - return [] - - def getGenealogie(self): - """ - Retourne la liste des noms des ascendants de l'objet self - jusqu'a la premiere ETAPE parent. - """ - return [] - - def getListeCmd(self): - """ - Retourne la liste des commandes du catalogue - """ - return self.niveau.definition.getListeCmd() - - def getGroups(self): - """ - Retourne la liste des groupes - """ - return self.niveau.definition.liste_groupes,self.niveau.definition.dict_groupes - - def setEtapeContext(self,etape): - """ - Positionne l'etape qui sera utilisee dans NommerSdProd pour - decider si le concept passe pourra etre nomme - """ - self._etape_context=etape - - def resetContext(self): - """ - Cette methode reinitialise le contexte glissant pour pouvoir - tenir compte des modifications de l'utilisateur : craation - de commandes, nommage de concepts, etc. - """ - #print "resetContext",self,self.nom - self.currentContext={} - self.index_etape_courante=0 - ind={} - for i,etape in enumerate(self.etapes): - ind[etape]=i - self.index_etapes=ind - - # for etape in self.etapes: - # etape.resetContext() - - def delSdprod(self,sd): - """ - Supprime la SD sd de la liste des sd et des dictionnaires de contexte - """ - #print "delSdprod",self,sd - #print "delSdprod",self.sds - #print "delSdprod",self.g_context - #print "delSdprod",self.sdsDict - #if sd in self.sds : self.sds.remove(sd) - if sd.nom in self.g_context : del self.g_context[sd.nom] - if sd.nom in self.sdsDict : del self.sdsDict[sd.nom] - - def delParam(self,param): - """ - Supprime le parametre param de la liste des paramatres - et du contexte gobal - """ - if param in self.params : self.params.remove(param) - if param.nom in self.g_context : del self.g_context[param.nom] - - def delFonction(self,fonction): - """ - Supprime la fonction fonction de la liste des fonctions - et du contexte gobal - """ - if fonction in self.fonctions : self.fonctions.remove(fonction) - if fonction.nom in self.g_context: del self.g_context[fonction.nom] - - def appendSdProd(self,sd): - """ - Ajoute la SD sd a la liste des sd en verifiant au prealable qu'une SD de - meme nom n'existe pas deja - """ - if sd == None or sd.nom == None:return - o=self.sdsDict.get(sd.nom,None) - if isinstance(o,ASSD): - raise AsException(tr("Nom de concept deja defini "+ sd.nom)) - self.sdsDict[sd.nom]=sd - self.g_context[sd.nom] = sd - #if sd not in self.sds : self.sds.append(sd) - - def appendParam(self,param): - """ - Ajoute le parametre param a la liste des params - et au contexte global - """ - # il faudrait verifier qu'un parametre de meme nom n'existe pas deja !!! - if param not in self.params : self.params.append(param) - self.g_context[param.nom]=param - - def appendFonction(self,fonction): - """ - Ajoute la fonction fonction a la liste des fonctions - et au contexte global - """ - # il faudrait verifier qu'une fonction de meme nom n'existe pas deja !!! - if fonction not in self.fonctions : self.fonctions.append(fonction) - self.g_context[fonction.nom]=fonction - - def deleteConcept(self,sd): - """ - Inputs : - - sd=concept detruit - Fonction : - Mettre a jour les etapes du JDC suite a la disparition du - concept sd - Seuls les mots cles simples MCSIMP font un traitement autre - que de transmettre aux fils - """ - for etape in self.etapes : - etape.deleteConcept(sd) - #PN PN PN pour les matrices ???? - #self.getVariables_avant(etape) - - def replaceConceptAfterEtape(self,etape,old_sd,sd): - """ - Met a jour les etapes du JDC qui sont apres etape en fonction - du remplacement du concept sd - """ - index = self.etapes.index(etape)+1 - if index == len(self.etapes) : - return # etape est la derniere etape du jdc ...on ne fait rien ! - for child in self.etapes[index:]: - child.replaceConcept(old_sd,sd) - - def updateConceptAfterEtape(self,etape,sd): - """ - Met a jour les etapes du JDC qui sont apres etape en fonction - de la modification (principalement nommage) du concept sd - """ - if etape is None: - #On traite toutes les etapes - index=0 - else: - index = self.etapes.index(etape)+1 - if index == len(self.etapes) : - return # etape est la derniere etape du jdc ...on ne fait rien ! - for child in self.etapes[index:]: - child.updateConcept(sd) - - def dumpState(self): - #print(("JDC.state: ",self.state)) - for etape in self.etapes : - print((etape.nom+".state: ",etape.state)) - - def changeUnit(self,unit,etape,old_unit): - #print "changeUnit",unit,etape,old_unit - #print id(self.recorded_units),self.recorded_units - #if self.recorded_units.has_key(old_unit):del self.recorded_units[old_unit] - self.recordUnit(unit,etape) - - def recordUnit(self,unit,etape): - """Enregistre les unites logiques incluses et les infos relatives a l'etape""" - #print "recordUnit",unit,etape - if unit is None: - # Cas de POURSUITE - self.recorded_units[None]=(etape.fichier_ini ,etape.fichier_text,etape.recorded_units) - else: - self.recorded_units[unit]=(etape.fichier_ini ,etape.fichier_text,etape.recorded_units) - #print id(self.recorded_units),self.recorded_units - #print self.recorded_units.get(None,(None,"",{}))[2] - #print self.recorded_units.get(None,(None,"",{}))[2].get(None,(None,"",{})) - - def changeFichier(self,fichier): - self.finModif() - - def evalInContext(self,valeur,etape): - """ Tente d'evaluer valeur dans le contexte courant de etape - Retourne le parametre valeur inchange si l'evaluation est impossible - """ - #contexte initial du jdc - context=self.condition_context.copy() - #contexte courant des concepts. Il contient les parametres - context.update(self.getContexteAvant(etape)) - try : - objet = eval(valeur,context) - return objet - except: - #traceback.print_exc() - pass - return valeur + #traceback.print_exc() + pass + return valeur #ATTENTION SURCHARGE : cette methode doit etre gardee en synchronisation avec celle de Noyau - def supprime(self): - Noyau.N_JDC.JDC.supprime(self) - for etape in self.etapes: - etape.supprime() - self.appliEficas=None - self.g_context={} - self.const_context={} - self.sdsDict={} - self.mc_globaux={} - self.currentContext={} - self.condition_context={} - self.etapes_niveaux=[] - self.niveau=None - self.params=[] - self.fonctions=[] - self._etape_context=None - self.etapes=[] - + def supprime(self): + Noyau.N_JDC.JDC.supprime(self) + for etape in self.etapes: + etape.supprime() + self.appliEficas=None + self.g_context={} + self.const_context={} + self.sdsDict={} + self.mc_globaux={} + self.currentContext={} + self.condition_context={} + self.etapes_niveaux=[] + self.niveau=None + self.params=[] + self.fonctions=[] + self._etape_context=None + self.etapes=[] + #ATTENTION SURCHARGE : cette methode doit etre gardee en synchronisation avec celle de Noyau - def register(self,etape): - """ - Cette methode ajoute etape dans la liste - des etapes self.etapes et retourne l identificateur d'etape - fourni par l appel a gRegister - - A quoi sert editmode ? - - Si editmode vaut 1, on est en mode edition de JDC. On cherche - a enregistrer une etape que l'on a creee avec eficas (en passant - par addEntite) auquel cas on ne veut recuperer que son numero - d'enregistrement et c'est addEntite qui l'enregistre dans - self.etapes a la bonne place... - - Si editmode vaut 0, on est en mode relecture d'un fichier de - commandes et on doit enregistrer l'etape a la fin de self.etapes - (dans ce cas l'ordre des etapes est bien l'ordre chronologique - de leur creation ) - """ - #import traceback - #traceback.print_stack() - if not self.editmode: - self.etapes.append(etape) - self.index_etapes[etape] = len(self.etapes) - 1 - else: - pass - return self.gRegister(etape) + def register(self,etape): + """ + Cette methode ajoute etape dans la liste + des etapes self.etapes et retourne l identificateur d'etape + fourni par l appel a gRegister + + A quoi sert editmode ? + - Si editmode vaut 1, on est en mode edition de JDC. On cherche + a enregistrer une etape que l'on a creee avec eficas (en passant + par addEntite) auquel cas on ne veut recuperer que son numero + d'enregistrement et c'est addEntite qui l'enregistre dans + self.etapes a la bonne place... + - Si editmode vaut 0, on est en mode relecture d'un fichier de + commandes et on doit enregistrer l'etape a la fin de self.etapes + (dans ce cas l'ordre des etapes est bien l'ordre chronologique + de leur creation ) + """ + #import traceback + #traceback.print_stack() + if not self.editmode: + self.etapes.append(etape) + self.index_etapes[etape] = len(self.etapes) - 1 + else: + pass + return self.gRegister(etape) #ATTENTION SURCHARGE : cette methode doit etre gardee en synchronisation avec celle de Noyau - def nommerSDProd(self,sd,sdnom,restrict='non'): - """ - Nomme la SD apres avoir verifie que le nommage est possible : - nom non utilise - Si le nom est deja utilise, leve une exception - Met le concept cree dans le concept global g_context - """ - # XXX En mode editeur dans EFICAS, le nommage doit etre gere differemment - # Le dictionnaire g_context ne represente pas le contexte - # effectif avant une etape. - # Il faut utiliser getContexteAvant avec indication de l'etape - # traitee. - # Cette etape est indiquee par l'attribut _etape_context qui a ete - # positionne prealablement par un appel a setEtapeContext - - if CONTEXT.debug : print(("JDC.nommerSDProd ",sd,sdnom)) - - if self._etape_context: - o=self.getContexteAvant(self._etape_context).get(sdnom,None) - else: - o=self.sdsDict.get(sdnom,None) - - if isinstance(o,ASSD): - raise AsException(tr(" Nom de concept deja defini : "+ sdnom)) - - # ATTENTION : Il ne faut pas ajouter sd dans sds car il s y trouve deja. - # Ajoute a la creation (appel de regSD). - #print (' je pass ici, pour ', sdnom, self.sdsDict) - self.sdsDict[sdnom]=sd - sd.nom=sdnom - - # En plus si restrict vaut 'non', on insere le concept dans le contexte du JDC - if restrict == 'non': - self.g_context[sdnom]=sd - - def deleteConceptEntreEtapes(self,index1,index2,sd): - if index2 <= index1 :return - for child in self.etapes[index1:index2]: - child.deleteConcept(sd) - - def deleteConceptAfterEtape(self,etape,sd): - """ - Met a jour les etapes du JDC qui sont apres etape en fonction - de la disparition du concept sd - """ - index = self.etapes.index(etape)+1 - if index == len(self.etapes) : - return # etape est la derniere etape du jdc ...on ne fait rien ! - for child in self.etapes[index:]: - child.deleteConcept(sd) + def nommerSDProd(self,sd,sdnom,restrict='non'): + """ + Nomme la SD apres avoir verifie que le nommage est possible : + nom non utilise + Si le nom est deja utilise, leve une exception + Met le concept cree dans le concept global g_context + """ + # XXX En mode editeur dans EFICAS, le nommage doit etre gere differemment + # Le dictionnaire g_context ne represente pas le contexte + # effectif avant une etape. + # Il faut utiliser getContexteAvant avec indication de l'etape + # traitee. + # Cette etape est indiquee par l'attribut _etape_context qui a ete + # positionne prealablement par un appel a setEtapeContext + + if CONTEXT.debug : print(("JDC.nommerSDProd ",sd,sdnom)) + + if self._etape_context: + o=self.getContexteAvant(self._etape_context).get(sdnom,None) + else: + o=self.sdsDict.get(sdnom,None) + + if isinstance(o,ASSD): + raise AsException(tr(" Nom de concept deja defini : "+ sdnom)) + + # ATTENTION : Il ne faut pas ajouter sd dans sds car il s y trouve deja. + # Ajoute a la creation (appel de regSD). + #print (' je pass ici, pour ', sdnom, self.sdsDict) + self.sdsDict[sdnom]=sd + sd.nom=sdnom + + # En plus si restrict vaut 'non', on insere le concept dans le contexte du JDC + if restrict == 'non': + self.g_context[sdnom]=sd + + def deleteConceptEntreEtapes(self,index1,index2,sd): + if index2 <= index1 :return + for child in self.etapes[index1:index2]: + child.deleteConcept(sd) + + def deleteConceptAfterEtape(self,etape,sd): + """ + Met a jour les etapes du JDC qui sont apres etape en fonction + de la disparition du concept sd + """ + index = self.etapes.index(etape)+1 + if index == len(self.etapes) : + return # etape est la derniere etape du jdc ...on ne fait rien ! + for child in self.etapes[index:]: + child.deleteConcept(sd) #ATTENTION SURCHARGE : les methodes ci-dessus surchargent des methodes de Noyau et Validation : a reintegrer - def getFile(self,unite=None,fic_origine=''): - """ - Retourne le nom du fichier correspondant a un numero d'unite - logique (entier) ainsi que le source contenu dans le fichier - """ - if self.appliEficas is not None: - # Si le JDC est relie a une appliEficascation maitre, on delegue la recherche - file,text= self.appliEficas.getFile(unite,fic_origine) - else: - file = None - if unite != None: - if os.path.exists(u"fort."+str(unite)): - file= "fort."+str(unite) - if file == None : - raise AsException(tr("Impossible de trouver le fichier correspondant a l'unite "+str( unite))) - if not os.path.exists(file): - raise AsException(str(unite)+ tr(" n'est pas un fichier existant")) - fproc=open(file,'r') - text=fproc.read() - fproc.close() - #if file == None : return None,None - text=text.replace('\r\n','\n') - if file: - linecache.cache[file]=0,0,text.split('\n'),file - return file,text - - def isValid(self,cr='non'): - if hasattr(self,'valid'): old_valid=self.valid - else:old_valid=0 - valid=Validation.V_JDC.JDC.isValid(self,cr) - if valid != old_valid: - CONNECTOR.Emit(self,"valid") - return valid - - def getLNomsEtapes(self): - """ - Retourne la liste des noms des etapes de self - """ - l=[] - for etape in self.etapes: - l.append(etape.nom) - return l + def getFile(self,unite=None,fic_origine=''): + """ + Retourne le nom du fichier correspondant a un numero d'unite + logique (entier) ainsi que le source contenu dans le fichier + """ + if self.appliEficas is not None: + # Si le JDC est relie a une appliEficascation maitre, on delegue la recherche + file,text= self.appliEficas.getFile(unite,fic_origine) + else: + file = None + if unite != None: + if os.path.exists(u"fort."+str(unite)): + file= "fort."+str(unite) + if file == None : + raise AsException(tr("Impossible de trouver le fichier correspondant a l'unite "+str( unite))) + if not os.path.exists(file): + raise AsException(str(unite)+ tr(" n'est pas un fichier existant")) + fproc=open(file,'r') + text=fproc.read() + fproc.close() + #if file == None : return None,None + text=text.replace('\r\n','\n') + if file: + linecache.cache[file]=0,0,text.split('\n'),file + return file,text + + def isValid(self,cr='non'): + if hasattr(self,'valid'): old_valid=self.valid + else:old_valid=0 + valid=Validation.V_JDC.JDC.isValid(self,cr) + if valid != old_valid: + CONNECTOR.Emit(self,"valid") + return valid + + def getLNomsEtapes(self): + """ + Retourne la liste des noms des etapes de self + """ + l=[] + for etape in self.etapes: + l.append(etape.nom) + return l diff --git a/Ihm/I_JDC_CATA.py b/Ihm/I_JDC_CATA.py index b8de9558..99913cbd 100644 --- a/Ihm/I_JDC_CATA.py +++ b/Ihm/I_JDC_CATA.py @@ -21,22 +21,22 @@ from __future__ import absolute_import from Noyau import N_JDC_CATA class JDC_CATA: - def __init__(self): - self.l_noms_entites=[] + def __init__(self): + self.l_noms_entites=[] - def getListeCmd(self): - self.l_noms_entites.sort() - return self.l_noms_entites + def getListeCmd(self): + self.l_noms_entites.sort() + return self.l_noms_entites - def getDocu(self): - return + def getDocu(self): + return #ATTENTION SURCHARGE: cette methode doit etre synchronisee avec celle du Noyau - def enregistre(self,commande): - """ - Cette methode surcharge la methode de la classe du Noyau - Marche avec Noyau - """ - N_JDC_CATA.JDC_CATA.enregistre(self,commande) - self.l_noms_entites.append(commande.nom) + def enregistre(self,commande): + """ + Cette methode surcharge la methode de la classe du Noyau + Marche avec Noyau + """ + N_JDC_CATA.JDC_CATA.enregistre(self,commande) + self.l_noms_entites.append(commande.nom) diff --git a/Ihm/I_LASSD.py b/Ihm/I_LASSD.py index bdeba371..744d70ad 100644 --- a/Ihm/I_LASSD.py +++ b/Ihm/I_LASSD.py @@ -19,5 +19,5 @@ # class LASSD: - def __repr__(self): - return self.getName() + def __repr__(self): + return self.getName() diff --git a/Ihm/I_MACRO_ETAPE.py b/Ihm/I_MACRO_ETAPE.py index 2f4771f1..ad13cf48 100644 --- a/Ihm/I_MACRO_ETAPE.py +++ b/Ihm/I_MACRO_ETAPE.py @@ -46,758 +46,758 @@ import Accas # attention aux imports circulaires class MACRO_ETAPE(I_ETAPE.ETAPE): - def __init__(self): - self.typret=None - #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="" - self.recorded_units={} - - def getSdprods(self,nom_sd): - """ - Fonction : retourne le concept produit par l etape de nom nom_sd - s il existe sinon None - """ - if self.sd and self.sd.nom == nom_sd :return self.sd - for co in self.sdprods: - if co.nom == nom_sd:return co - if type(self.definition.op_init) == types.FunctionType: - d={} - self.definition.op_init(*(self,d)) - return d.get(nom_sd,None) - return None - - def getContexteJdc(self,fichier,text,doitEtreValide=1): - """ - Interprete text comme un texte de jdc et retourne le contexte final. - - 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 - --> utilisee par ops.POURSUITE et INCLUDE - """ - print ("getContexteJdc",self,self.nom, text) - # On recupere l'etape courante - step=CONTEXT.getCurrentStep() - self.text_included_converted=0 - try: - #if 1 : - # on essaie de creer un objet JDC auxiliaire avec un contexte initial - # Attention getContexteAvant 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. - context_ini = self.parent.getContexteAvant(self).copy() - - # Indispensable avant de creer un nouveau JDC - CONTEXT.unsetCurrentStep() - args=self.jdc.args - prefix_include=None - if hasattr(self,'prefix'): - prefix_include=self.prefix - # 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. - # En principe si la memorisation est faite au bon moment il n'est pas necessaire - # de prendre cette precaution mais ce n'est pas vrai partout. - old_recorded_units=self.recorded_units.copy() - - # on supprime l'ancien jdc_aux s'il existe - if hasattr(self,'jdc_aux') and self.jdc_aux: - self.jdc_aux.supprime_aux() - - if fichier is None:fichier="SansNom" - - # Il faut convertir le texte inclus en fonction du format - # sauf les INCLUDE_MATERIAU - self.text_converted=0 - self.text_error="" - if self.nom != "INCLUDE_MATERIAU": - format=self.jdc.appliEficas.format_fichier - #on force a python pour Carmel - if format=="CARMEL3D" : format="python" - import convert - if format in convert.plugins : - # Le convertisseur existe on l'utilise - p=convert.plugins[format]() - p.text=text - text=p.convert('exec',self.jdc.appliEficas) - #Si le fichier ne peut pas etre converti, le cr n'est pas vide - #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 - - - if hasattr(self,'sd') and self.sd != None : context_ini[self.sd.nom]=self.sd - j=self.JdC_aux( procedure=text, nom=fichier, - appliEficas=self.jdc.appliEficas, - cata=self.jdc.cata, - cata_ord_dico=self.jdc.cata_ordonne_dico, - context_ini = context_ini, - jdc_pere=self.jdc,etape_include=self, - prefix_include=prefix_include, - recorded_units=self.recorded_units, - old_recorded_units=old_recorded_units,**args) - - j.analyse() - if not j.cr.estvide(): self.text_included_converted=0 - else : self.text_included_converted=1 - self.text_included_error=str(j.cr) - # 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.unsetCurrentStep() - CONTEXT.setCurrentStep(step) - return None - - - if not j.cr.estvide() and doitEtreValide: - # Erreurs dans l'INCLUDE. On garde la memoire du fichier - # mais on n'insere pas les concepts - # On retablit l'etape courante step - #print (j.cr) - #print ("valid ",j.isValid()) - CONTEXT.unsetCurrentStep() - CONTEXT.setCurrentStep(step) - raise EficasException(tr("Impossible de relire le fichier %s \n ")+ str(j.cr)) - - - if not j.isValid() and doitEtreValide: - # L'INCLUDE n'est pas valide. - # on produit un rapport d'erreurs - cr=j.report() - #print ('cr', cr) - # On retablit l'etape courante step - CONTEXT.unsetCurrentStep() - CONTEXT.setCurrentStep(step) - self.jdc.cr.fatal("Le fichier include contient des erreurs ") - raise EficasException(tr("Le fichier include contient des erreurs ")) - - - # Si aucune erreur rencontree - # ou qu on accepte un jdc incomplet - # On recupere le contexte de l'include verifie - try: - j_context=j.getVerifContexte() - #print j_context.keys() - #print j.g_context.keys() - except: - # On retablit l'etape courante step - CONTEXT.unsetCurrentStep() - CONTEXT.setCurrentStep(step) - raise EficasException(" ") - - # 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 presents dans le contexte initial - # On ajoute egalement le concept produit dans le sdsDict du parent - # 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 k in context_ini) or (context_ini[k] != v): - self.g_context[k]=v - self.parent.sdsDict[k]=v - - #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 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 - if k in j_context:continue - if isinstance(v,ASSD):continue - if isinstance(v,I_ENTITE.ENTITE):continue - if isinstance(v,I_OBJECT.OBJECT):continue - if callable(v):continue - self.g_context[k]=param2.Variable(k,v) - - print (j) - print (dir(j)) - print (j.currentContext) - # On recupere le contexte courant - self.currentContext=j.currentContext - print ('kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkmmmmmmmmmmmmmmmmmmmmmm') - self.index_etape_courante=j.index_etape_courante - print ('kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkmmmmmmmmmmmmmmmmmmmmmm') - self.jdc_aux=j - print ('kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkmmmmmmmmmmmmmmmmmmmmmm') - - # On retablit l'etape courante step - CONTEXT.unsetCurrentStep() - print ('kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkmmmmmmmmmmmmmmmmmmmmmm') - CONTEXT.setCurrentStep(step) - print ('kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkmmmmmmmmmmmmmmmmmmmmmm') - - print ('kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkmmmmmmmmmmmmmmmmmmmmmm') - return j_context - - def reevalueSdJdc(self): - """ - Avec la liste des SD qui ont ete supprimees, propage la - disparition de ces SD dans toutes les etapes et descendants - """ - #print "reevalueSdJdc" - l_sd_supp,l_sd_repl = self.diffContextes() - for sd in l_sd_supp: - self.parent.deleteConceptAfterEtape(self,sd) - for old_sd,sd in l_sd_repl: - self.parent.replaceConceptAfterEtape(self,old_sd,sd) - - def diffContextes(self): - """ - 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 - """ - if not hasattr(self,'old_contexte_fichier_init'):return [],[] - l_sd_suppressed = [] - l_sd_replaced = [] - 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: - if isinstance(self.old_contexte_fichier_init[old_key],ASSD): - # Un concept de meme nom existe - old_class=self.old_contexte_fichier_init[old_key].__class__ - if not isinstance(self.contexte_fichier_init[old_key],old_class): - # S'il n'est pas d'une classe derivee, on le supprime - l_sd_suppressed.append(self.old_contexte_fichier_init[old_key]) + def __init__(self): + self.typret=None + #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="" + self.recorded_units={} + + def getSdprods(self,nom_sd): + """ + Fonction : retourne le concept produit par l etape de nom nom_sd + s il existe sinon None + """ + if self.sd and self.sd.nom == nom_sd :return self.sd + for co in self.sdprods: + if co.nom == nom_sd:return co + if type(self.definition.op_init) == types.FunctionType: + d={} + self.definition.op_init(*(self,d)) + return d.get(nom_sd,None) + return None + + def getContexteJdc(self,fichier,text,doitEtreValide=1): + """ + Interprete text comme un texte de jdc et retourne le contexte final. + + 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 + --> utilisee par ops.POURSUITE et INCLUDE + """ + print ("getContexteJdc",self,self.nom, text) + # On recupere l'etape courante + step=CONTEXT.getCurrentStep() + self.text_included_converted=0 + try: + #if 1 : + # on essaie de creer un objet JDC auxiliaire avec un contexte initial + # Attention getContexteAvant 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. + context_ini = self.parent.getContexteAvant(self).copy() + + # Indispensable avant de creer un nouveau JDC + CONTEXT.unsetCurrentStep() + args=self.jdc.args + prefix_include=None + if hasattr(self,'prefix'): + prefix_include=self.prefix + # 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. + # En principe si la memorisation est faite au bon moment il n'est pas necessaire + # de prendre cette precaution mais ce n'est pas vrai partout. + old_recorded_units=self.recorded_units.copy() + + # on supprime l'ancien jdc_aux s'il existe + if hasattr(self,'jdc_aux') and self.jdc_aux: + self.jdc_aux.supprime_aux() + + if fichier is None:fichier="SansNom" + + # Il faut convertir le texte inclus en fonction du format + # sauf les INCLUDE_MATERIAU + self.text_converted=0 + self.text_error="" + if self.nom != "INCLUDE_MATERIAU": + format=self.jdc.appliEficas.format_fichier + #on force a python pour Carmel + if format=="CARMEL3D" : format="python" + import convert + if format in convert.plugins : + # Le convertisseur existe on l'utilise + p=convert.plugins[format]() + p.text=text + text=p.convert('exec',self.jdc.appliEficas) + #Si le fichier ne peut pas etre converti, le cr n'est pas vide + #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 + + + if hasattr(self,'sd') and self.sd != None : context_ini[self.sd.nom]=self.sd + j=self.JdC_aux( procedure=text, nom=fichier, + appliEficas=self.jdc.appliEficas, + cata=self.jdc.cata, + cata_ord_dico=self.jdc.cata_ordonne_dico, + context_ini = context_ini, + jdc_pere=self.jdc,etape_include=self, + prefix_include=prefix_include, + recorded_units=self.recorded_units, + old_recorded_units=old_recorded_units,**args) + + j.analyse() + if not j.cr.estvide(): self.text_included_converted=0 + else : self.text_included_converted=1 + self.text_included_error=str(j.cr) + # 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.unsetCurrentStep() + CONTEXT.setCurrentStep(step) + return None + + + if not j.cr.estvide() and doitEtreValide: + # Erreurs dans l'INCLUDE. On garde la memoire du fichier + # mais on n'insere pas les concepts + # On retablit l'etape courante step + #print (j.cr) + #print ("valid ",j.isValid()) + CONTEXT.unsetCurrentStep() + CONTEXT.setCurrentStep(step) + raise EficasException(tr("Impossible de relire le fichier %s \n ")+ str(j.cr)) + + + if not j.isValid() and doitEtreValide: + # L'INCLUDE n'est pas valide. + # on produit un rapport d'erreurs + cr=j.report() + #print ('cr', cr) + # On retablit l'etape courante step + CONTEXT.unsetCurrentStep() + CONTEXT.setCurrentStep(step) + self.jdc.cr.fatal("Le fichier include contient des erreurs ") + raise EficasException(tr("Le fichier include contient des erreurs ")) + + + # Si aucune erreur rencontree + # ou qu on accepte un jdc incomplet + # On recupere le contexte de l'include verifie + try: + j_context=j.getVerifContexte() + #print j_context.keys() + #print j.g_context.keys() + except: + # On retablit l'etape courante step + CONTEXT.unsetCurrentStep() + CONTEXT.setCurrentStep(step) + raise EficasException(" ") + + # 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 presents dans le contexte initial + # On ajoute egalement le concept produit dans le sdsDict du parent + # 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 k in context_ini) or (context_ini[k] != v): + self.g_context[k]=v + self.parent.sdsDict[k]=v + + #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 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 + if k in j_context:continue + if isinstance(v,ASSD):continue + if isinstance(v,I_ENTITE.ENTITE):continue + if isinstance(v,I_OBJECT.OBJECT):continue + if callable(v):continue + self.g_context[k]=param2.Variable(k,v) + + print (j) + print (dir(j)) + print (j.currentContext) + # On recupere le contexte courant + self.currentContext=j.currentContext + print ('kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkmmmmmmmmmmmmmmmmmmmmmm') + self.index_etape_courante=j.index_etape_courante + print ('kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkmmmmmmmmmmmmmmmmmmmmmm') + self.jdc_aux=j + print ('kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkmmmmmmmmmmmmmmmmmmmmmm') + + # On retablit l'etape courante step + CONTEXT.unsetCurrentStep() + print ('kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkmmmmmmmmmmmmmmmmmmmmmm') + CONTEXT.setCurrentStep(step) + print ('kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkmmmmmmmmmmmmmmmmmmmmmm') + + print ('kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkmmmmmmmmmmmmmmmmmmmmmm') + return j_context + + def reevalueSdJdc(self): + """ + Avec la liste des SD qui ont ete supprimees, propage la + disparition de ces SD dans toutes les etapes et descendants + """ + #print "reevalueSdJdc" + l_sd_supp,l_sd_repl = self.diffContextes() + for sd in l_sd_supp: + self.parent.deleteConceptAfterEtape(self,sd) + for old_sd,sd in l_sd_repl: + self.parent.replaceConceptAfterEtape(self,old_sd,sd) + + def diffContextes(self): + """ + 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 + """ + if not hasattr(self,'old_contexte_fichier_init'):return [],[] + l_sd_suppressed = [] + l_sd_replaced = [] + 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: - l_sd_replaced.append((self.old_contexte_fichier_init[old_key],self.contexte_fichier_init[old_key])) - return l_sd_suppressed,l_sd_replaced - - def controlSdprods(self,d): - """ - Cette methode doit verifier que les concepts produits par la - commande ne sont pas incompatibles avec le contexte fourni (d). - Si c'est le cas, le concept produit doit etre supprime - Si la macro a elle meme des etapes, elle doit propager - le traitement (voir methode controlJdcContextApres de I_JDC) - """ - #print ("I_MACRO_ETAPE.controlSdprods",d.keys(),self,self.nom,self.sd and self.sd.nom) - if self.sd: - 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 - pass - else: - # Redefinition du concept, on l'annule - #XXX on pourrait simplement annuler son nom pour conserver les objets - # l'utilisateur n'aurait alors qu'a renommer le concept (faisable??) - self.initModif() - sd=self.sd - self.sd=self.reuse=self.sdnom=None - self.parent.deleteConceptAfterEtape(self,sd) - self.finModif() - - # On verifie les concepts a droite du signe = - self.initModif() - sdprods=self.sdprods[:] - self.sdprods=[] - for co in sdprods: - 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.deleteConcept(co) - #supprime les references a co dans les etapes suivantes - self.parent.deleteConceptAfterEtape(self,co) - else: - self.sdprods.append(co) - self.finModif() - - for e in self.etapes: - e.controlSdprods(d) - e.updateContext(d) - - def supprimeSdprod(self,sd): - """ - Supprime le concept produit sd s'il est produit par l'etape - """ - print ('supprimeSdprod de MACRO_ETAPE') - if sd in self.sdprods: - self.initModif() - self.parent.delSdprod(sd) - self.sdprods.remove(sd) - self.finModif() - self.parent.deleteConcept(sd) - return - - if sd is not self.sd :return - if self.sd is not None : - self.initModif() - self.parent.delSdprod(sd) - self.sd=None - self.finModif() - self.parent.deleteConcept(sd) - - def supprimeSdProds(self): - """ - Fonction: Lors de la destruction de la macro-etape, detruit tous les concepts produits - Un operateur n a qu un concept produit - Une procedure n'en a aucun - Une macro en a en general plus d'un - """ - #print "supprimeSdProds" - if self.reuse is not self.sd : - # 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.delSdprod(self.sd) - self.parent.deleteConcept(self.sd) - # On detruit les concepts a droite du signe = - for co in self.sdprods: - self.parent.delSdprod(co) - self.parent.deleteConcept(co) - # Si la macro a des etapes et des concepts inclus, on les detruit - for nom_sd,co in self.g_context.items(): - if not isinstance(co,ASSD):continue - self.parent.delSdprod(co) - self.parent.deleteConcept(co) - # On met g_context a blanc - self.g_context={} - - def close(self): - #print "close",self - if hasattr(self,"jdc_aux") and self.jdc_aux: - # La macro a un jdc auxiliaire inclus. On demande sa fermeture - self.jdc_aux.close() - - def resetContext(self): - if hasattr(self,"jdc_aux") and self.jdc_aux: - # La macro a un jdc auxiliaire inclus. On demande la reinitialisation du contexte - self.jdc_aux.resetContext() - - def updateConcept(self,sd): - I_ETAPE.ETAPE.updateConcept(self,sd) - for etape in self.etapes: - etape.updateConcept(sd) - - def deleteConcept(self,sd): - """ - Fonction : Mettre a jour les mots cles de l etape et eventuellement - 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 - """ - #print "deleteConcept",sd - I_ETAPE.ETAPE.deleteConcept(self,sd) - for etape in self.etapes: - etape.deleteConcept(sd) - - def replaceConcept(self,old_sd,sd): - """ - Fonction : Mettre a jour les mots cles de l etape et le concept produit si reuse - suite au remplacement du concept old_sd par sd - """ - #print "replaceConcept",old_sd,sd - I_ETAPE.ETAPE.replaceConcept(self,old_sd,sd) - for etape in self.etapes: - etape.replaceConcept(old_sd,sd) - - def changeFichierInit(self,new_fic,text): - """ - Tente de changer le fichier include. Le precedent include est conserve - dans old_xxx - """ - if not hasattr(self,'fichier_ini'): - self.fichier_ini=None - self.fichier_text=None - self.fichier_err="Le fichier n'est pas defini" - self.contexte_fichier_init={} - self.recorded_units={} - self.jdc_aux=None - self.fichier_unite="PasDefini" - import Extensions.jdc_include - self.JdC_aux=Extensions.jdc_include.JdC_include - - self.old_fic = self.fichier_ini - self.old_text = self.fichier_text - self.old_err = self.fichier_err - self.old_context=self.contexte_fichier_init - self.old_units=self.recorded_units - self.old_etapes=self.etapes - self.old_jdc_aux=self.jdc_aux - - self.fichier_ini = new_fic - self.fichier_text=text - - try: - self.makeContexteInclude(new_fic,text) - except: - 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 passe - # on peut poursuivre le traitement - self.initModif() - self.state="undetermined" - self.fichier_err=None - # On enregistre la modification de fichier - self.recordUnite() - # Le contexte du parent doit etre reinitialise car les concepts produits ont change - self.parent.resetContext() - - # Si des concepts ont disparu lors du changement de fichier, on demande leur suppression - self.old_contexte_fichier_init=self.old_context - self.reevalueSdJdc() - - self.finModif() - if self.old_jdc_aux: - self.old_jdc_aux.close() - - def restoreFichierInit(self): - """ - Restaure le fichier init enregistre dans old_xxx - """ - self.fichier_ini=self.old_fic - self.fichier_text=self.old_text - self.fichier_err=self.old_err - self.contexte_fichier_init=self.old_context - self.recorded_units=self.old_units - self.etapes=self.old_etapes - self.jdc_aux=self.old_jdc_aux - - def forceFichierInit(self): - """ - Force le remplacement du fichier init meme si le remplacant est en erreur - """ - # 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 presents dans le contexte initial - # On ajoute egalement le concept produit dans le sdsDict du parent - # sans verification car on est sur (verification integree) que - # le nommage est possible - j_context=self.jdc_aux.getContexteAvant(None) - self.g_context.clear() - context_ini=self.jdc_aux.context_ini - for k,v in j_context.items(): - if not k in context_ini or context_ini[k] != v: - self.g_context[k]=v - self.parent.sdsDict[k]=v - # On recupere le contexte courant - self.currentContext=self.jdc_aux.currentContext - self.index_etape_courante=self.jdc_aux.index_etape_courante - self.contexte_fichier_init = j_context - self.fichier_err = None - - # On enregistre la modification de fichier - self.initModif() - self.state="undetermined" - self.recordUnite() - # Le contexte du parent doit etre reinitialise car les concepts produits ont change - self.parent.resetContext() - - # On remplace les anciens concepts par les nouveaux (y compris ajouts - # et suppression) et on propage les modifications aux etapes precedentes et suivantes - # reevalueSdJdc construit la liste des differences entre les contextes contexte_fichier_init - # et old_contexte_fichier_init et effectue les destructions et remplacements de concept - # necessaires - self.old_contexte_fichier_init=self.old_context - self.reevalueSdJdc() - self.finModif() - if self.old_jdc_aux: - self.old_jdc_aux.close() - - self.jdc_aux.forceContexte(self.g_context) - - def buildInclude(self,fichier,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.recorded_units=self.parent.recorded_units - self.buildJdcaux(fichier,text) - - def buildPoursuite(self,fichier,text): - import Extensions.jdc_include - self.JdC_aux=Extensions.jdc_include.JdC_poursuite - # une poursuite a sa propre table d'unites - self.recorded_units={} - self.buildJdcaux(fichier,text) - - - def buildIncludeInclude(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) - - - def buildIncludeEtape(self,text,doitEtreValide = 0): - import Extensions.jdc_include - self.JdC_aux=Extensions.jdc_include.JdC_include - # un include partage la table des unites avec son parent (jdc) - #self.buildJdcauxInclude(text) - # Attention fonctionne pour import_Zone de MT - # a adapter eventuellement - try : - #if 1 : - contexte = self.getContexteJdc(None,text,doitEtreValide) - except EficasException: - return 0 - - for e in self.etapes: - e.niveau=self.niveau - e.parent=self.parent - e.state='change' - - index=self.jdc.etapes.index(self) - self.jdc.etapes=self.jdc.etapes[:index+1]+self.etapes+self.jdc.etapes[index+1:] - - self.g_context={} - self.etapes=[] - self.jdc.resetContext() - self.jdc_aux=None - CONTEXT.unsetCurrentStep() - return 1 - - - def buildJdcauxInclude(self,text): - - try : - contexte = self.getContexteJdc(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.unsetCurrentStep() - - def buildJdcaux(self,fichier,text): - """ - Cree un jdc auxiliaire initialise avec text. - Initialise le nom du fichier associe avec fichier - N'enregistre pas d'association unite <-> fichier - """ - self.fichier_ini = fichier - self.fichier_text= text - self.fichier_unite=None - self.fichier_err = None - try: - contexte = self.getContexteJdc(fichier,text) - if contexte is None : - # Impossible de construire le jdc auxiliaire (sortie par None) - # On simule une sortie par exception - raise EficasException(tr("Impossible de construire le jeu de commandes correspondant au fichier")) - else: - # La construction du jdc auxiliaire est allee au bout - self.contexte_fichier_init = contexte - self.initModif() - self.finModif() - except: - # Impossible de construire le jdc auxiliaire (sortie par exception) - l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1]) - if self.jdc.editor is not None: - self.jdc.editor.afficheAlerte(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 = ''.join(l) - self.contexte_fichier_init={} - self.initModif() - self.finModif() - raise EficasException(" ") - - def makeContexteInclude(self,fichier,text): - """ - Cette methode sert a craer un contexte en interpratant un texte source Python. - """ - print ("makeContexteInclude",fichier) - # on recupere le contexte d'un nouveau jdc dans lequel on interprete text - contexte = self.getContexteJdc(fichier,text) - print (contexte) - if contexte == None : - 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 getContexteJdc) - # 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 makeContexteInclude",fichier) - - def reevalueFichierInitObsolete(self): - """Recalcule les concepts produits par le fichier enregistre""" - #print "reevalue_fichier_init" - old_context=self.contexte_fichier_init - try: - self.makeContexteInclude(self.fichier_ini ,self.fichier_text) - except: - l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1]) - self.fichier_err = ''.join(l) - self.g_context={} - self.etapes=[] - self.jdc_aux=None - self.old_contexte_fichier_init=old_context - self.contexte_fichier_init={} - self.reevalueSdJdc() - return - - # L'evaluation s'est bien passee - self.fichier_err = None - self.old_contexte_fichier_init=old_context - self.reevalueSdJdc() - - def updateFichierInit(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 ete memorisees prealablement - L'include a ete initialise precedemment. Le jdc auxiliaire existe. - """ - #print "updateFichierInit",unite,self.fichier_unite - self.old_contexte_fichier_init=self.contexte_fichier_init - old_fichier_ini=self.fichier_ini - if not hasattr(self,"jdc_aux"):self.jdc_aux=None - old_jdc_aux=self.jdc_aux - - #print "updateFichierInit",self,self.parent,self.parent.recorded_units - - if self.fichier_unite is None: - # L'unite n'etait pas definie precedemment. On ne change que l'unite - #print "updateFichierInit","pas de changement dans include" - self.fichier_unite=unite - return - elif unite == self.fichier_unite : - # L'unite n'a pas change - #print "updateFichierInit","pas de changement dans include 3" - return - elif unite != self.fichier_unite : - # L'unite etait definie precedemment. On remplace l'include - # - f,text=self.getFileMemo(unite=unite,fic_origine=self.parent.nom) - if f is None: - # Le fichier associe n'a pas pu etre defini - # on change l'unite associee mais pas l'include - #print "updateFichierInit","pas de changement dans include 2" - self.fichier_unite=unite + if isinstance(self.old_contexte_fichier_init[old_key],ASSD): + # Un concept de meme nom existe + old_class=self.old_contexte_fichier_init[old_key].__class__ + if not isinstance(self.contexte_fichier_init[old_key],old_class): + # S'il n'est pas d'une classe derivee, on le supprime + l_sd_suppressed.append(self.old_contexte_fichier_init[old_key]) + else: + l_sd_replaced.append((self.old_contexte_fichier_init[old_key],self.contexte_fichier_init[old_key])) + return l_sd_suppressed,l_sd_replaced + + def controlSdprods(self,d): + """ + Cette methode doit verifier que les concepts produits par la + commande ne sont pas incompatibles avec le contexte fourni (d). + Si c'est le cas, le concept produit doit etre supprime + Si la macro a elle meme des etapes, elle doit propager + le traitement (voir methode controlJdcContextApres de I_JDC) + """ + #print ("I_MACRO_ETAPE.controlSdprods",d.keys(),self,self.nom,self.sd and self.sd.nom) + if self.sd: + 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 + pass + else: + # Redefinition du concept, on l'annule + #XXX on pourrait simplement annuler son nom pour conserver les objets + # l'utilisateur n'aurait alors qu'a renommer le concept (faisable??) + self.initModif() + sd=self.sd + self.sd=self.reuse=self.sdnom=None + self.parent.deleteConceptAfterEtape(self,sd) + self.finModif() + + # On verifie les concepts a droite du signe = + self.initModif() + sdprods=self.sdprods[:] + self.sdprods=[] + for co in sdprods: + 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.deleteConcept(co) + #supprime les references a co dans les etapes suivantes + self.parent.deleteConceptAfterEtape(self,co) + else: + self.sdprods.append(co) + self.finModif() + + for e in self.etapes: + e.controlSdprods(d) + e.updateContext(d) + + def supprimeSdprod(self,sd): + """ + Supprime le concept produit sd s'il est produit par l'etape + """ + print ('supprimeSdprod de MACRO_ETAPE') + if sd in self.sdprods: + self.initModif() + self.parent.delSdprod(sd) + self.sdprods.remove(sd) + self.finModif() + self.parent.deleteConcept(sd) return - else: - self.fichier_ini = f - self.fichier_text=text - self.fichier_unite=unite - #print "updateFichierInit",self.recorded_units - - #print "updateFichierInit",self.fichier_ini,self.fichier_text,self.fichier_unite - if old_fichier_ini == self.fichier_ini: - # Le fichier inclus n'a pas change. On ne recree pas le contexte - # mais on enregistre le changement d'association unite <-> fichier - #print "updateFichierInit.fichier inchange",self.jdc_aux.context_ini - self.parent.recordUnit(unite,self) - return + if sd is not self.sd :return + if self.sd is not None : + self.initModif() + self.parent.delSdprod(sd) + self.sd=None + self.finModif() + self.parent.deleteConcept(sd) + + def supprimeSdProds(self): + """ + Fonction: Lors de la destruction de la macro-etape, detruit tous les concepts produits + Un operateur n a qu un concept produit + Une procedure n'en a aucun + Une macro en a en general plus d'un + """ + #print "supprimeSdProds" + if self.reuse is not self.sd : + # 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.delSdprod(self.sd) + self.parent.deleteConcept(self.sd) + # On detruit les concepts a droite du signe = + for co in self.sdprods: + self.parent.delSdprod(co) + self.parent.deleteConcept(co) + # Si la macro a des etapes et des concepts inclus, on les detruit + for nom_sd,co in self.g_context.items(): + if not isinstance(co,ASSD):continue + self.parent.delSdprod(co) + self.parent.deleteConcept(co) + # On met g_context a blanc + self.g_context={} - try: + def close(self): + #print "close",self + if hasattr(self,"jdc_aux") and self.jdc_aux: + # La macro a un jdc auxiliaire inclus. On demande sa fermeture + self.jdc_aux.close() + + def resetContext(self): + if hasattr(self,"jdc_aux") and self.jdc_aux: + # La macro a un jdc auxiliaire inclus. On demande la reinitialisation du contexte + self.jdc_aux.resetContext() + + def updateConcept(self,sd): + I_ETAPE.ETAPE.updateConcept(self,sd) + for etape in self.etapes: + etape.updateConcept(sd) + + def deleteConcept(self,sd): + """ + Fonction : Mettre a jour les mots cles de l etape et eventuellement + 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 + """ + #print "deleteConcept",sd + I_ETAPE.ETAPE.deleteConcept(self,sd) + for etape in self.etapes: + etape.deleteConcept(sd) + + def replaceConcept(self,old_sd,sd): + """ + Fonction : Mettre a jour les mots cles de l etape et le concept produit si reuse + suite au remplacement du concept old_sd par sd + """ + #print "replaceConcept",old_sd,sd + I_ETAPE.ETAPE.replaceConcept(self,old_sd,sd) + for etape in self.etapes: + etape.replaceConcept(old_sd,sd) + + def changeFichierInit(self,new_fic,text): + """ + Tente de changer le fichier include. Le precedent include est conserve + dans old_xxx + """ + if not hasattr(self,'fichier_ini'): + self.fichier_ini=None + self.fichier_text=None + self.fichier_err="Le fichier n'est pas defini" + self.contexte_fichier_init={} + self.recorded_units={} + self.jdc_aux=None + self.fichier_unite="PasDefini" + import Extensions.jdc_include + self.JdC_aux=Extensions.jdc_include.JdC_include + + self.old_fic = self.fichier_ini + self.old_text = self.fichier_text + self.old_err = self.fichier_err + self.old_context=self.contexte_fichier_init + self.old_units=self.recorded_units + self.old_etapes=self.etapes + self.old_jdc_aux=self.jdc_aux + + self.fichier_ini = new_fic + self.fichier_text=text + + try: + self.makeContexteInclude(new_fic,text) + except: + 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 passe + # on peut poursuivre le traitement + self.initModif() + self.state="undetermined" self.fichier_err=None - self.makeContexteInclude(self.fichier_ini,self.fichier_text) - # Les 3 attributs fichier_ini fichier_text recorded_units doivent etre corrects - # avant d'appeler changeUnit - except: - # Erreurs lors de l'evaluation de text dans un JDC auxiliaire - 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=''.join(l) - self.fichier_err=''.join(l) + # On enregistre la modification de fichier + self.recordUnite() + # Le contexte du parent doit etre reinitialise car les concepts produits ont change + self.parent.resetContext() + + # Si des concepts ont disparu lors du changement de fichier, on demande leur suppression + self.old_contexte_fichier_init=self.old_context + self.reevalueSdJdc() + + self.finModif() + if self.old_jdc_aux: + self.old_jdc_aux.close() + + def restoreFichierInit(self): + """ + Restaure le fichier init enregistre dans old_xxx + """ + self.fichier_ini=self.old_fic + self.fichier_text=self.old_text + self.fichier_err=self.old_err + self.contexte_fichier_init=self.old_context + self.recorded_units=self.old_units + self.etapes=self.old_etapes + self.jdc_aux=self.old_jdc_aux + + def forceFichierInit(self): + """ + Force le remplacement du fichier init meme si le remplacant est en erreur + """ + # 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 presents dans le contexte initial + # On ajoute egalement le concept produit dans le sdsDict du parent + # sans verification car on est sur (verification integree) que + # le nommage est possible + j_context=self.jdc_aux.getContexteAvant(None) + self.g_context.clear() + context_ini=self.jdc_aux.context_ini + for k,v in j_context.items(): + if not k in context_ini or context_ini[k] != v: + self.g_context[k]=v + self.parent.sdsDict[k]=v + # On recupere le contexte courant + self.currentContext=self.jdc_aux.currentContext + self.index_etape_courante=self.jdc_aux.index_etape_courante + self.contexte_fichier_init = j_context + self.fichier_err = None + + # On enregistre la modification de fichier + self.initModif() + self.state="undetermined" + self.recordUnite() + # Le contexte du parent doit etre reinitialise car les concepts produits ont change + self.parent.resetContext() + + # On remplace les anciens concepts par les nouveaux (y compris ajouts + # et suppression) et on propage les modifications aux etapes precedentes et suivantes + # reevalueSdJdc construit la liste des differences entre les contextes contexte_fichier_init + # et old_contexte_fichier_init et effectue les destructions et remplacements de concept + # necessaires + self.old_contexte_fichier_init=self.old_context + self.reevalueSdJdc() + self.finModif() + if self.old_jdc_aux: + self.old_jdc_aux.close() + + self.jdc_aux.forceContexte(self.g_context) + + def buildInclude(self,fichier,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.recorded_units=self.parent.recorded_units + self.buildJdcaux(fichier,text) + + def buildPoursuite(self,fichier,text): + import Extensions.jdc_include + self.JdC_aux=Extensions.jdc_include.JdC_poursuite + # une poursuite a sa propre table d'unites + self.recorded_units={} + self.buildJdcaux(fichier,text) + + + def buildIncludeInclude(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) + + + def buildIncludeEtape(self,text,doitEtreValide = 0): + import Extensions.jdc_include + self.JdC_aux=Extensions.jdc_include.JdC_include + # un include partage la table des unites avec son parent (jdc) + #self.buildJdcauxInclude(text) + # Attention fonctionne pour import_Zone de MT + # a adapter eventuellement + try : + #if 1 : + contexte = self.getContexteJdc(None,text,doitEtreValide) + except EficasException: + return 0 + + for e in self.etapes: + e.niveau=self.niveau + e.parent=self.parent + e.state='change' + + index=self.jdc.etapes.index(self) + self.jdc.etapes=self.jdc.etapes[:index+1]+self.etapes+self.jdc.etapes[index+1:] + self.g_context={} self.etapes=[] + self.jdc.resetContext() self.jdc_aux=None - self.contexte_fichier_init={} + CONTEXT.unsetCurrentStep() + return 1 + + + def buildJdcauxInclude(self,text): + + try : + contexte = self.getContexteJdc(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.unsetCurrentStep() + + def buildJdcaux(self,fichier,text): + """ + Cree un jdc auxiliaire initialise avec text. + Initialise le nom du fichier associe avec fichier + N'enregistre pas d'association unite <-> fichier + """ + self.fichier_ini = fichier + self.fichier_text= text + self.fichier_unite=None + self.fichier_err = None + try: + contexte = self.getContexteJdc(fichier,text) + if contexte is None : + # Impossible de construire le jdc auxiliaire (sortie par None) + # On simule une sortie par exception + raise EficasException(tr("Impossible de construire le jeu de commandes correspondant au fichier")) + else: + # La construction du jdc auxiliaire est allee au bout + self.contexte_fichier_init = contexte + self.initModif() + self.finModif() + except: + # Impossible de construire le jdc auxiliaire (sortie par exception) + l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1]) + if self.jdc.editor is not None: + self.jdc.editor.afficheAlerte(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 = ''.join(l) + self.contexte_fichier_init={} + self.initModif() + self.finModif() + raise EficasException(" ") + + def makeContexteInclude(self,fichier,text): + """ + Cette methode sert a craer un contexte en interpratant un texte source Python. + """ + print ("makeContexteInclude",fichier) + # on recupere le contexte d'un nouveau jdc dans lequel on interprete text + contexte = self.getContexteJdc(fichier,text) + print (contexte) + if contexte == None : + 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 getContexteJdc) + # 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 makeContexteInclude",fichier) + + def reevalueFichierInitObsolete(self): + """Recalcule les concepts produits par le fichier enregistre""" + #print "reevalue_fichier_init" + old_context=self.contexte_fichier_init + try: + self.makeContexteInclude(self.fichier_ini ,self.fichier_text) + except: + l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1]) + self.fichier_err = ''.join(l) + self.g_context={} + self.etapes=[] + self.jdc_aux=None + self.old_contexte_fichier_init=old_context + self.contexte_fichier_init={} + self.reevalueSdJdc() + return + + # L'evaluation s'est bien passee + self.fichier_err = None + self.old_contexte_fichier_init=old_context + self.reevalueSdJdc() + + def updateFichierInit(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 ete memorisees prealablement + L'include a ete initialise precedemment. Le jdc auxiliaire existe. + """ + #print "updateFichierInit",unite,self.fichier_unite + self.old_contexte_fichier_init=self.contexte_fichier_init + old_fichier_ini=self.fichier_ini + if not hasattr(self,"jdc_aux"):self.jdc_aux=None + old_jdc_aux=self.jdc_aux + + #print "updateFichierInit",self,self.parent,self.parent.recorded_units + + if self.fichier_unite is None: + # L'unite n'etait pas definie precedemment. On ne change que l'unite + #print "updateFichierInit","pas de changement dans include" + self.fichier_unite=unite + return + elif unite == self.fichier_unite : + # L'unite n'a pas change + #print "updateFichierInit","pas de changement dans include 3" + return + elif unite != self.fichier_unite : + # L'unite etait definie precedemment. On remplace l'include + # + f,text=self.getFileMemo(unite=unite,fic_origine=self.parent.nom) + if f is None: + # Le fichier associe n'a pas pu etre defini + # on change l'unite associee mais pas l'include + #print "updateFichierInit","pas de changement dans include 2" + self.fichier_unite=unite + return + else: + self.fichier_ini = f + self.fichier_text=text + self.fichier_unite=unite + #print "updateFichierInit",self.recorded_units + + #print "updateFichierInit",self.fichier_ini,self.fichier_text,self.fichier_unite + + if old_fichier_ini == self.fichier_ini: + # Le fichier inclus n'a pas change. On ne recree pas le contexte + # mais on enregistre le changement d'association unite <-> fichier + #print "updateFichierInit.fichier inchange",self.jdc_aux.context_ini + self.parent.recordUnit(unite,self) + return - if old_jdc_aux: - old_jdc_aux.close() - self.parent.recordUnit(unite,self) - # Le contexte du parent doit etre reinitialise car les concepts - # produits ont change - self.parent.resetContext() - # Si des concepts ont disparu lors du changement de fichier, on - # demande leur suppression - self.reevalueSdJdc() - #print "updateFichierInit",self.jdc_aux.context_ini.keys() - - def recordUnite(self): - #print "recordUnite",self.nom - if self.nom == "POURSUITE": - self.parent.recordUnit(None,self) - else: - if hasattr(self,'fichier_unite') : - self.parent.recordUnit(self.fichier_unite,self) - - def getFileMemo(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 - """ - #print "getFileMemo",unite,fic_origine,self,self.parent - #print self.parent.recorded_units - if unite is None: - # On est dans le cas d'une poursuite. On ne reutilise aucune unite de parent - units={} - else: - # On est dans le cas d'un include. On reutilise toutes les unites de parent - units=self.parent.recorded_units - - if unite in self.parent.recorded_units: - f,text,units=self.parent.recorded_units[unite] - elif self.jdc : - 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.getFile(unite=unite, fic_origine=fic_origine) - else: - f,text=None,None - - self.recorded_units=units - if f is None and self.jdc.editor: - self.jdc.editor.afficheAlerte(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 updateContext(self,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 - """ - #print ("updateContext",self,self.nom,d.keys()) - if hasattr(self,"jdc_aux") and self.jdc_aux: - #ATTENTION: updateContext NE DOIT PAS appeler resetContext - # car il appelle directement ou indirectement updateContext - # equivalent a resetContext. Evite les recursions + try: + self.fichier_err=None + self.makeContexteInclude(self.fichier_ini,self.fichier_text) + # Les 3 attributs fichier_ini fichier_text recorded_units doivent etre corrects + # avant d'appeler changeUnit + except: + # Erreurs lors de l'evaluation de text dans un JDC auxiliaire + 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=''.join(l) + self.fichier_err=''.join(l) + self.g_context={} + self.etapes=[] + self.jdc_aux=None + self.contexte_fichier_init={} + + if old_jdc_aux: + old_jdc_aux.close() + self.parent.recordUnit(unite,self) + # Le contexte du parent doit etre reinitialise car les concepts + # produits ont change + self.parent.resetContext() + # Si des concepts ont disparu lors du changement de fichier, on + # demande leur suppression + self.reevalueSdJdc() + #print "updateFichierInit",self.jdc_aux.context_ini.keys() + + def recordUnite(self): + #print "recordUnite",self.nom + if self.nom == "POURSUITE": + self.parent.recordUnit(None,self) + else: + if hasattr(self,'fichier_unite') : + self.parent.recordUnit(self.fichier_unite,self) + + def getFileMemo(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 + """ + #print "getFileMemo",unite,fic_origine,self,self.parent + #print self.parent.recorded_units + if unite is None: + # On est dans le cas d'une poursuite. On ne reutilise aucune unite de parent + units={} + else: + # On est dans le cas d'un include. On reutilise toutes les unites de parent + units=self.parent.recorded_units + + if unite in self.parent.recorded_units: + f,text,units=self.parent.recorded_units[unite] + elif self.jdc : + 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.getFile(unite=unite, fic_origine=fic_origine) + else: + f,text=None,None + + self.recorded_units=units + if f is None and self.jdc.editor: + self.jdc.editor.afficheAlerte(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 updateContext(self,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 + """ + #print ("updateContext",self,self.nom,d.keys()) + if hasattr(self,"jdc_aux") and self.jdc_aux: + #ATTENTION: updateContext NE DOIT PAS appeler resetContext + # car il appelle directement ou indirectement updateContext + # equivalent a resetContext. Evite les recursions self.jdc_aux.context_ini=d.copy() self.jdc_aux.currentContext={} self.jdc_aux.index_etape_courante=0 #ATTENTION: il ne faut pas utiliser self.jdc_aux.getContexteAvant #car cet appel conduit a des remontees multiples incoherentes dans le - # ou les parents. + # ou les parents. #get_context_avant appelle updateContext qui NE DOIT PAS appeler getContexteAvant #On n'a besoin que d'un update local connaissant # le contexte amont : d qui sert a reinitialiser self.context_ini @@ -805,459 +805,459 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): e.updateContext(d) return - if type(self.definition.op_init) == types.FunctionType: - print ('mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm dans updateContext') - 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 - #print "updateContext.fin",d.keys() + if type(self.definition.op_init) == types.FunctionType: + print ('mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm dans updateContext') + 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 + #print "updateContext.fin",d.keys() #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro) - def copy(self): - etape=Noyau.N_MACRO_ETAPE.MACRO_ETAPE.copy(self) - if hasattr(etape,"etapes") :etape.etapes=[] - if hasattr(etape,"jdc_aux") : - etape.jdc_aux=None - del etape.fichier_ini - return etape - - def supprime(self): - #print "supprime",self - if hasattr(self,"jdc_aux") and self.jdc_aux: - self.jdc_aux.supprime_aux() - self.jdc_aux=None - Noyau.N_MACRO_ETAPE.MACRO_ETAPE.supprime(self) + def copy(self): + etape=Noyau.N_MACRO_ETAPE.MACRO_ETAPE.copy(self) + if hasattr(etape,"etapes") :etape.etapes=[] + if hasattr(etape,"jdc_aux") : + etape.jdc_aux=None + del etape.fichier_ini + return etape + + def supprime(self): + #print "supprime",self + if hasattr(self,"jdc_aux") and self.jdc_aux: + self.jdc_aux.supprime_aux() + self.jdc_aux=None + Noyau.N_MACRO_ETAPE.MACRO_ETAPE.supprime(self) #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro) - def getFile(self,unite=None,fic_origine=''): - """Retourne le nom du fichier et le source correspondant a l'unite unite - """ - if self.jdc : - f,text=self.jdc.getFile(unite=unite,fic_origine=fic_origine) - else: - f,text=None,None - return f,text - - - def makeInclude3(self,fichier=None): - self.makeIncludeCarmel(fichier) - - - def makeIncludeCND(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.buildIncludeInclude(texte) - if CONTEXT.getCurrentStep()==None : CONTEXT.setCurrentStep(self) - reevalue=0 - - def makeIncludeCarmel(self,fichier=None): - # Pour Carmel - #print "je suis dans makeIncludeCarmel" - 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.deleteConcept(concept) - if fichier == None : - fichier=str(self.jdc.appliEficas.getFile_dictDonnees()) - if fichier == str("") : - self.fichier_ini="badfile" - self.fichier_text="" - self.fichier_err=tr("Le fichier n est pas defini") - self.parent.recordUnit(999,self) - try : - MCFils=self.getChild('FileName') - MCFils.setValeur(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.makeIncl2Except() - raise EficasException(" ") - - try: - #if 1 : - self.makeContexteInclude(self.fichier_ini ,self.fichier_text) - self.old_context_fichier_init=self.contexte_fichier_init - self.parent.recordUnit(unite,self) - try : - MCFils=self.getChild('FileName') - #MCFils.setValeur(fichier) - #on appelle pas setValeur 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.makeIncl2Except() - # Cette P*** de ligne suivante ne fonctionne que pour Aster - # si quelqu un a une idee merci de m en parler - #CONTEXT.setCurrentStep(self) - - def makeInclude2(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.deleteConcept(concept) - - if fichier == None : - fichier=str(self.jdc.appliEficas.getFileVariable()) - if fichier == str("") : - self.fichier_ini="badfile" - self.fichier_text="" - self.fichier_err=tr("Le fichier n est pas defini") - self.parent.recordUnit(999,self) - try : - MCFils=self.getChild('FileName') - MCFils.setValeur(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.makeIncl2Except() - raise EficasException(" ") - - if nbVariableOut != 1 : - print((nbVariableOut ,"nbVariableOut")) - self.makeIncl2Except(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.makeIncl2Except() - raise EficasException(" ") - - try: - print((self.fichier_ini ,self.fichier_text)) - self.makeContexteInclude(self.fichier_ini ,self.fichier_text) - self.old_context_fichier_init=self.contexte_fichier_init - self.parent.recordUnit(unite,self) - try : - MCFils=self.getChild('FileName') - MCFils.setValeur(fichier) - except : - pass - except: - self.makeIncl2Except() - - # recalcul validite pour la matrice eventuelle - if reevalue : - for e in self.jdc.etapes: - if e.nom == "VARIABLE" : - e.state="modified" - try : - mc=e.getChild('ModelVariable') - mc.state="modified" - except : - pass - if e.nom == "CORRELATION" : - e.state="modified" - try : - mc=e.getChild('Matrix') - mc.state="modified" - mcFeuille=mc.getChild('CorrelationMatrix') - mcFeuille.state="modified" - except : - pass - e.isValid() - - def makeIncl2Except(self,mess=None): - l=traceback.format_exception_only(tr("Fichier invalide"),sys.exc_info()[1]) - if self.jdc.editor is not None: - if mess == None : - self.jdc.editor.afficheAlerte(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.editor.afficheAlerte(tr("Erreur lors de l'evaluation du fichier inclus"), - message=tr(mess)) - #self.parent.recordUnit(unite,self) - self.g_context={} - self.etapes=[] - self.jdc_aux=None - self.fichier_err = ''.join(l) - self.contexte_fichier_init={} - try : + def getFile(self,unite=None,fic_origine=''): + """Retourne le nom du fichier et le source correspondant a l'unite unite + """ + if self.jdc : + f,text=self.jdc.getFile(unite=unite,fic_origine=fic_origine) + else: + f,text=None,None + return f,text + + + def makeInclude3(self,fichier=None): + self.makeIncludeCarmel(fichier) + + + def makeIncludeCND(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.buildIncludeInclude(texte) + if CONTEXT.getCurrentStep()==None : CONTEXT.setCurrentStep(self) + reevalue=0 + + def makeIncludeCarmel(self,fichier=None): + # Pour Carmel + #print "je suis dans makeIncludeCarmel" + 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.deleteConcept(concept) + if fichier == None : + fichier=str(self.jdc.appliEficas.getFile_dictDonnees()) + if fichier == str("") : + self.fichier_ini="badfile" + self.fichier_text="" + self.fichier_err=tr("Le fichier n est pas defini") + self.parent.recordUnit(999,self) + try : + MCFils=self.getChild('FileName') + MCFils.setValeur(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.makeIncl2Except() + raise EficasException(" ") + + try: + #if 1 : + self.makeContexteInclude(self.fichier_ini ,self.fichier_text) + self.old_context_fichier_init=self.contexte_fichier_init + self.parent.recordUnit(unite,self) + try : + MCFils=self.getChild('FileName') + #MCFils.setValeur(fichier) + #on appelle pas setValeur 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.makeIncl2Except() + # Cette P*** de ligne suivante ne fonctionne que pour Aster + # si quelqu un a une idee merci de m en parler + #CONTEXT.setCurrentStep(self) + + def makeInclude2(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.deleteConcept(concept) + + if fichier == None : + fichier=str(self.jdc.appliEficas.getFileVariable()) + if fichier == str("") : + self.fichier_ini="badfile" + self.fichier_text="" + self.fichier_err=tr("Le fichier n est pas defini") + self.parent.recordUnit(999,self) + try : + MCFils=self.getChild('FileName') + MCFils.setValeur(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.makeIncl2Except() + raise EficasException(" ") + + if nbVariableOut != 1 : + print((nbVariableOut ,"nbVariableOut")) + self.makeIncl2Except(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.makeIncl2Except() + raise EficasException(" ") + + try: + print((self.fichier_ini ,self.fichier_text)) + self.makeContexteInclude(self.fichier_ini ,self.fichier_text) + self.old_context_fichier_init=self.contexte_fichier_init + self.parent.recordUnit(unite,self) + try : + MCFils=self.getChild('FileName') + MCFils.setValeur(fichier) + except : + pass + except: + self.makeIncl2Except() + + # recalcul validite pour la matrice eventuelle + if reevalue : + for e in self.jdc.etapes: + if e.nom == "VARIABLE" : + e.state="modified" + try : + mc=e.getChild('ModelVariable') + mc.state="modified" + except : + pass + if e.nom == "CORRELATION" : + e.state="modified" + try : + mc=e.getChild('Matrix') + mc.state="modified" + mcFeuille=mc.getChild('CorrelationMatrix') + mcFeuille.state="modified" + except : + pass + e.isValid() + + def makeIncl2Except(self,mess=None): + l=traceback.format_exception_only(tr("Fichier invalide"),sys.exc_info()[1]) + if self.jdc.editor is not None: + if mess == None : + self.jdc.editor.afficheAlerte(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.editor.afficheAlerte(tr("Erreur lors de l'evaluation du fichier inclus"), + message=tr(mess)) + #self.parent.recordUnit(unite,self) + self.g_context={} + self.etapes=[] + self.jdc_aux=None + self.fichier_err = ''.join(l) + self.contexte_fichier_init={} + try : MCFils=self.getChild('FileName') MCFils.setValeur(None) - except : + except : pass #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro) - #def makeInclude(self, unite=None, fname=None): - def makeInclude(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 - Si l'INCLUDE est invalide, la methode doit produire une exception - Sinon on retourne None. Les concepts produits par l'INCLUDE sont - pris en compte par le JDC parent lors du calcul du contexte (appel de ???) - """ - print ("makeInclude",fname) - # 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 and not fname: - # return - # 2020 on supprime unite - # attention cependant c est utilise pour poursuite - # PNPN a revoir - if not fname : return - - if not hasattr(self,'fichier_ini') : - # Si le fichier n'est pas defini on le demande - f,text=self.getFileMemo(unite=unite, fname=fname, fic_origine=self.parent.nom) - # On memorise le fichier retourne - self.fichier_ini = f - self.fichier_text = text - self.contexte_fichier_init={} - self.fichier_unite=unite - self.fichier_err=None - try: - import Extensions.jdc_include - except: - traceback.print_exc() - raise EficasException("pb import Extensions") - self.JdC_aux=Extensions.jdc_include.JdC_include - - #print "makeInclude",self.fichier_ini,self.fichier_text - if f is None and not text: - self.fichier_err=tr("Le fichier INCLUDE n est pas defini") - self.parent.recordUnit(unite,self) - raise EficasException(self.fichier_err) - - try: - print ('iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii') - self.makeContexteInclude(self.fichier_ini ,self.fichier_text) - print ('iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii') - self.parent.recordUnit(unite,self) - print ('iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii') - except: - l=traceback.format_exception_only(tr("Fichier invalide %s",sys.exc_info()[1])) - if self.jdc.editor: - self.jdc.editor.afficheAlerte(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.recordUnit(unite,self) - self.g_context={} - self.etapes=[] - self.jdc_aux=None - self.fichier_err = ''.join(l) - self.contexte_fichier_init={} - raise EficasException(" ") - - else: - # Si le fichier est deja defini on ne reevalue pas le fichier - # et on leve une exception si une erreur a ete enregistree - self.updateFichierInit(unite) - self.fichier_unite=unite - if self.fichier_err is not None: raise EficasException(self.fichier_err) - print ('self.g_context', self.g_context) - + #def makeInclude(self, unite=None, fname=None): + def makeInclude(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 + Si l'INCLUDE est invalide, la methode doit produire une exception + Sinon on retourne None. Les concepts produits par l'INCLUDE sont + pris en compte par le JDC parent lors du calcul du contexte (appel de ???) + """ + print ("makeInclude",fname) + # 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 and not fname: + # return + # 2020 on supprime unite + # attention cependant c est utilise pour poursuite + # PNPN a revoir + if not fname : return + + if not hasattr(self,'fichier_ini') : + # Si le fichier n'est pas defini on le demande + f,text=self.getFileMemo(unite=unite, fname=fname, fic_origine=self.parent.nom) + # On memorise le fichier retourne + self.fichier_ini = f + self.fichier_text = text + self.contexte_fichier_init={} + self.fichier_unite=unite + self.fichier_err=None + try: + import Extensions.jdc_include + except: + traceback.print_exc() + raise EficasException("pb import Extensions") + self.JdC_aux=Extensions.jdc_include.JdC_include + + #print "makeInclude",self.fichier_ini,self.fichier_text + if f is None and not text: + self.fichier_err=tr("Le fichier INCLUDE n est pas defini") + self.parent.recordUnit(unite,self) + raise EficasException(self.fichier_err) + + try: + print ('iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii') + self.makeContexteInclude(self.fichier_ini ,self.fichier_text) + print ('iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii') + self.parent.recordUnit(unite,self) + print ('iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii') + except: + l=traceback.format_exception_only(tr("Fichier invalide %s",sys.exc_info()[1])) + if self.jdc.editor: + self.jdc.editor.afficheAlerte(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.recordUnit(unite,self) + self.g_context={} + self.etapes=[] + self.jdc_aux=None + self.fichier_err = ''.join(l) + self.contexte_fichier_init={} + raise EficasException(" ") + + else: + # Si le fichier est deja defini on ne reevalue pas le fichier + # et on leve une exception si une erreur a ete enregistree + self.updateFichierInit(unite) + self.fichier_unite=unite + if self.fichier_err is not None: raise EficasException(self.fichier_err) + print ('self.g_context', self.g_context) + #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro) - def makeContexte(self,fichier,text): - """ - 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 "makeContexte",fichier - # On supprime l'attribut mat qui bloque l'evaluation du source de l'INCLUDE_MATERIAU - # car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini - if hasattr(self,'mat'):del self.mat - if not hasattr(self,'fichier_ini') or self.fichier_ini != fichier or self.fichier_mater != self.nom_mater: - # le fichier est nouveau ou change - self.fichier_ini =fichier - self.fichier_unite =fichier - self.fichier_mater=self.nom_mater - self.fichier_text=text - self.fichier_err=None - self.contexte_fichier_init={} - # On specifie la classe a utiliser pour le JDC auxiliaire - try: - import Extensions.jdc_include - self.JdC_aux=Extensions.jdc_include.JdC_include - except: - raise EficasException(" ") - try: - self.makeContexteInclude(self.fichier_ini ,self.fichier_text) - 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(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: - self.parent.g_context[self.nom_mater]=None - self.g_context[self.nom_mater]=None - #------------- - self.etapes=[] - self.jdc_aux=None - self.contexte_fichier_init={} - raise EficasException(" ") - else: - # le fichier est le meme on ne le reevalue pas - # et on leve une exception si une erreur a ete enregistree - if self.fichier_err is not None: raise EficasException(self.fichier_err) + def makeContexte(self,fichier,text): + """ + 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 "makeContexte",fichier + # On supprime l'attribut mat qui bloque l'evaluation du source de l'INCLUDE_MATERIAU + # car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini + if hasattr(self,'mat'):del self.mat + if not hasattr(self,'fichier_ini') or self.fichier_ini != fichier or self.fichier_mater != self.nom_mater: + # le fichier est nouveau ou change + self.fichier_ini =fichier + self.fichier_unite =fichier + self.fichier_mater=self.nom_mater + self.fichier_text=text + self.fichier_err=None + self.contexte_fichier_init={} + # On specifie la classe a utiliser pour le JDC auxiliaire + try: + import Extensions.jdc_include + self.JdC_aux=Extensions.jdc_include.JdC_include + except: + raise EficasException(" ") + try: + self.makeContexteInclude(self.fichier_ini ,self.fichier_text) + 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(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: + self.parent.g_context[self.nom_mater]=None + self.g_context[self.nom_mater]=None + #------------- + self.etapes=[] + self.jdc_aux=None + self.contexte_fichier_init={} + raise EficasException(" ") + else: + # le fichier est le meme on ne le reevalue pas + # 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 updateSdprod(self,cr='non'): - # Cette methode peut etre appelee dans EFICAS avec des mots cles de - # la commande modifies. Ceci peut conduire a la construction ou - # a la reconstruction d'etapes dans le cas d'INCLUDE ou d'INCLUDE_MATERIAU - # Il faut donc positionner le current_step avant l'appel - CONTEXT.unsetCurrentStep() - CONTEXT.setCurrentStep(self) - valid=Validation.V_MACRO_ETAPE.MACRO_ETAPE.updateSdprod(self,cr=cr) - CONTEXT.unsetCurrentStep() - return valid - -#ATTENTION SURCHARGE: cette methode surcharge celle de Noyau a garder en synchro - def buildSd(self,nom): - """ - Methode de Noyau surchargee pour poursuivre malgre tout - si une erreur se produit pendant la creation du concept produit - """ - try: - sd=Noyau.N_MACRO_ETAPE.MACRO_ETAPE.buildSd(self,nom) - 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 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 - self.sd=None - self.sdnom=None - self.state="unchanged" - self.valid=0 - - return self.sd - -#ATTENTION SURCHARGE: cette methode surcharge celle de Noyau a garder en synchro - def makePoursuite(self): - """ Cette methode est appelee par la fonction sd_prod de la macro POURSUITE - """ - #print "makePoursuite" - if not hasattr(self,'fichier_ini') : - # Si le fichier n'est pas defini on le demande - f,text=self.getFileMemo(fic_origine=self.parent.nom) - # On memorise le fichier retourne - self.fichier_ini = f - self.fichier_unite = None - self.fichier_text = text - self.fichier_err=None - try: - import Extensions.jdc_include - except: - traceback.print_exc() - raise EficasException(" ") - self.JdC_aux=Extensions.jdc_include.JdC_poursuite - self.contexte_fichier_init={} - #print "makePoursuite",self.fichier_ini,self.fichier_text - - if f is None: - self.fichier_err="Le fichier POURSUITE n'est pas defini" - self.jdc_aux=None - self.parent.recordUnit(None,self) - raise EficasException(self.fichier_err) - - try: - self.makeContexteInclude(self.fichier_ini,self.fichier_text) - self.parent.recordUnit(None,self) - except: - l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1]) - if self.jdc.editor: - self.jdc.editor.afficheAlerte(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.recordUnit(None,self) - self.g_context={} - self.etapes=[] - self.jdc_aux=None - self.fichier_err = ''.join(l) - self.contexte_fichier_init={} - raise EficasException(" ") - - else: - # Si le fichier est deja defini on ne reevalue pas le fichier - # et on leve une exception si une erreur a ete enregistree - self.updateFichierInit(None) - if self.fichier_err is not None: raise EficasException(self.fichier_err) + def updateSdprod(self,cr='non'): + # Cette methode peut etre appelee dans EFICAS avec des mots cles de + # la commande modifies. Ceci peut conduire a la construction ou + # a la reconstruction d'etapes dans le cas d'INCLUDE ou d'INCLUDE_MATERIAU + # Il faut donc positionner le current_step avant l'appel + CONTEXT.unsetCurrentStep() + CONTEXT.setCurrentStep(self) + valid=Validation.V_MACRO_ETAPE.MACRO_ETAPE.updateSdprod(self,cr=cr) + CONTEXT.unsetCurrentStep() + return valid + +#ATTENTION SURCHARGE: cette methode surcharge celle de Noyau a garder en synchro + def buildSd(self,nom): + """ + Methode de Noyau surchargee pour poursuivre malgre tout + si une erreur se produit pendant la creation du concept produit + """ + try: + sd=Noyau.N_MACRO_ETAPE.MACRO_ETAPE.buildSd(self,nom) + 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 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 + self.sd=None + self.sdnom=None + self.state="unchanged" + self.valid=0 + + return self.sd + +#ATTENTION SURCHARGE: cette methode surcharge celle de Noyau a garder en synchro + def makePoursuite(self): + """ Cette methode est appelee par la fonction sd_prod de la macro POURSUITE + """ + #print "makePoursuite" + if not hasattr(self,'fichier_ini') : + # Si le fichier n'est pas defini on le demande + f,text=self.getFileMemo(fic_origine=self.parent.nom) + # On memorise le fichier retourne + self.fichier_ini = f + self.fichier_unite = None + self.fichier_text = text + self.fichier_err=None + try: + import Extensions.jdc_include + except: + traceback.print_exc() + raise EficasException(" ") + self.JdC_aux=Extensions.jdc_include.JdC_poursuite + self.contexte_fichier_init={} + #print "makePoursuite",self.fichier_ini,self.fichier_text + + if f is None: + self.fichier_err="Le fichier POURSUITE n'est pas defini" + self.jdc_aux=None + self.parent.recordUnit(None,self) + raise EficasException(self.fichier_err) + + try: + self.makeContexteInclude(self.fichier_ini,self.fichier_text) + self.parent.recordUnit(None,self) + except: + l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1]) + if self.jdc.editor: + self.jdc.editor.afficheAlerte(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.recordUnit(None,self) + self.g_context={} + self.etapes=[] + self.jdc_aux=None + self.fichier_err = ''.join(l) + self.contexte_fichier_init={} + raise EficasException(" ") + + else: + # Si le fichier est deja defini on ne reevalue pas le fichier + # et on leve une exception si une erreur a ete enregistree + self.updateFichierInit(None) + if self.fichier_err is not None: raise EficasException(self.fichier_err) diff --git a/Ihm/I_MCBLOC.py b/Ihm/I_MCBLOC.py index 19a2690e..26a68d5a 100644 --- a/Ihm/I_MCBLOC.py +++ b/Ihm/I_MCBLOC.py @@ -21,7 +21,5 @@ from __future__ import absolute_import from . import I_MCCOMPO class MCBLOC(I_MCCOMPO.MCCOMPO): - def getNomDsXML(self): - return self.parent.getNomDsXML() - - + def getNomDsXML(self): + return self.parent.getNomDsXML() diff --git a/Ihm/I_MCCOMPO.py b/Ihm/I_MCCOMPO.py index c983667a..133bacf0 100644 --- a/Ihm/I_MCCOMPO.py +++ b/Ihm/I_MCCOMPO.py @@ -36,484 +36,482 @@ from . import I_OBJECT from . import CONNECTOR class MCCOMPO(I_OBJECT.OBJECT): - def getLabelText(self): - """ - Retourne le label de self - utilise pour l'affichage dans l'arbre - """ - return tr(self.nom) - - def getListeMcOrdonnee(self,liste,dico): - """ - Retourne la liste ordonnee (suivant le catalogue) des mots-cles - d'une entite composee dont le chemin complet est donne sous forme - d'une liste du type :ETAPE + MCFACT ou MCBLOC + ... - il faut encore rearranger cette liste (certains mots-cles deja - presents ne doivent plus etre proposes, regles ...) - """ - return self.filtreListeMc(self.getListeMcOrdonneeBrute(liste,dico)) - - def getListeMcOrdonneeBrute(self,liste,dico): - """ - Retourne la liste ordonnee (suivant le catalogue) BRUTE des mots-cles - d'une entite composee dont le chemin complet est donne sous forme - d'une liste du type :ETAPE + MCFACT ou MCBLOC + ... - """ - for arg in liste: - objet_cata = dico[arg] - dico=objet_cata.entites - l=[] - specifique=0 - for obj in list(dico.keys()) : - if not(hasattr(dico[obj],'cache')) or dico[obj].cache==0 : - l.append(obj) + def getLabelText(self): + """ + Retourne le label de self + utilise pour l'affichage dans l'arbre + """ + return tr(self.nom) + + def getListeMcOrdonnee(self,liste,dico): + """ + Retourne la liste ordonnee (suivant le catalogue) des mots-cles + d'une entite composee dont le chemin complet est donne sous forme + d'une liste du type :ETAPE + MCFACT ou MCBLOC + ... + il faut encore rearranger cette liste (certains mots-cles deja + presents ne doivent plus etre proposes, regles ...) + """ + return self.filtreListeMc(self.getListeMcOrdonneeBrute(liste,dico)) + + def getListeMcOrdonneeBrute(self,liste,dico): + """ + Retourne la liste ordonnee (suivant le catalogue) BRUTE des mots-cles + d'une entite composee dont le chemin complet est donne sous forme + d'une liste du type :ETAPE + MCFACT ou MCBLOC + ... + """ + for arg in liste: + objet_cata = dico[arg] + dico=objet_cata.entites + l=[] + specifique=0 + for obj in list(dico.keys()) : + if not(hasattr(dico[obj],'cache')) or dico[obj].cache==0 : + l.append(obj) + else : + specifique=1 + if specifique == 1 : return l + return objet_cata.ordre_mc + + def filtreListeMc(self,liste_brute): + """ + Cette methode est appelee par EFICAS afin de presenter a + l'utilisateur la liste des enfants possibles de self actualisee + en fonction du contexte de self. En clair, sont supprimes de la + liste des possibles (fournie par la definition), les mots-cles + exclus par les regles de self et les mots-cles ne pouvant plus + etre repetes + """ + liste = copy(liste_brute) + listeMcPresents = self.listeMcPresents() + # on enleve les mots-cles non permis par les regles + for regle in self.definition.regles: + # la methode purgeListe est a developper pour chaque regle qui + # influe sur la liste de choix a proposer a l'utilisateur + # --> EXCLUS,UN_PARMI,PRESENT_ABSENT + liste = regle.purgeListe(liste,listeMcPresents) + # on enleve les mots-cles dont l'occurrence est deja atteinte + liste_copy = copy(liste) + for k in liste_copy: + objet = self.getChild(k,restreint = 'oui') + if objet != None : + # l'objet est deja present : il faut distinguer plusieurs cas + if isinstance(objet,MCSIMP): + # un mot-cle simple ne peut pas etre repete + liste.remove(k) + elif isinstance(objet,MCBLOC): + # un bloc conditionnel ne doit pas apparaitre dans la liste de choix + liste.remove(k) + elif isinstance(objet,MCFACT): + # un mot-cle facteur ne peut pas etre repete plus de self.max fois + if objet.definition.max == 1: + liste.remove(k) + elif isinstance(objet,MCList): + try : + nb_occur_maxi = objet[0].definition.max + if len(objet) >= nb_occur_maxi: + liste.remove(k) + except: + pass + else : + #XXX CCAR : les MCNUPLET ne sont pas traites + if CONTEXT.debug : print(' ',k,' est un objet de type inconnu :',type(objet)) else : - specifique=1 - if specifique == 1 : return l - return objet_cata.ordre_mc - - def filtreListeMc(self,liste_brute): - """ - Cette methode est appelee par EFICAS afin de presenter a - l'utilisateur la liste des enfants possibles de self actualisee - en fonction du contexte de self. En clair, sont supprimes de la - liste des possibles (fournie par la definition), les mots-cles - exclus par les regles de self et les mots-cles ne pouvant plus - etre repetes - """ - liste = copy(liste_brute) - listeMcPresents = self.listeMcPresents() - # on enleve les mots-cles non permis par les regles - for regle in self.definition.regles: - # la methode purgeListe est a developper pour chaque regle qui - # influe sur la liste de choix a proposer a l'utilisateur - # --> EXCLUS,UN_PARMI,PRESENT_ABSENT - liste = regle.purgeListe(liste,listeMcPresents) - # on enleve les mots-cles dont l'occurrence est deja atteinte - liste_copy = copy(liste) - for k in liste_copy: - objet = self.getChild(k,restreint = 'oui') - if objet != None : - # l'objet est deja present : il faut distinguer plusieurs cas - if isinstance(objet,MCSIMP): - # un mot-cle simple ne peut pas etre repete - liste.remove(k) - elif isinstance(objet,MCBLOC): - # un bloc conditionnel ne doit pas apparaitre dans la liste de choix - liste.remove(k) - elif isinstance(objet,MCFACT): - # un mot-cle facteur ne peut pas etre repete plus de self.max fois - if objet.definition.max == 1: - liste.remove(k) - elif isinstance(objet,MCList): - try : - nb_occur_maxi = objet[0].definition.max - if len(objet) >= nb_occur_maxi: - liste.remove(k) - except: - pass - else : - #XXX CCAR : les MCNUPLET ne sont pas traites - if CONTEXT.debug : print(' ',k,' est un objet de type inconnu :',type(objet)) - else : - # l'objet est absent : on enleve de la liste les blocs - if self.definition.entites[k].statut=='c' : - liste.remove(k) - if self.definition.entites[k].label=='BLOC': - liste.remove(k) - # Pour corriger les exces qui pourraient etre commis dans la methode purgeListe - # des regles, on essaie de compenser comme suit : - # on ajoute les mots cles facteurs presents dont l'occurence n'est pas atteinte - for k in listeMcPresents: - if k in liste:continue - objet = self.getChild(k,restreint = 'oui') - if isinstance(objet,MCFACT): - # un mot-cle facteur ne peut pas etre repete plus de self.max fois - if objet.definition.max > 1: - liste.append(k) - elif isinstance(objet,MCList): - nb_occur_maxi = objet[0].definition.max - if len(objet) < nb_occur_maxi: - liste.append(k) - return liste - - def listeMcPresents(self): - """ - Retourne la liste des noms des mots-cles fils de self presents construite - a partir de self.mcListe - """ - l=[] - for v in self.mcListe: - k=v.nom - l.append(k) - return l - - def getIndexChild(self,nom_fils): - """ - Retourne l'index dans la liste des fils de self du nouveau fils de nom nom_fils - Permet de savoir a quelle position il faut ajouter un nouveau mot-cle - """ - cata_ordonne = self.jdc.cata_ordonne_dico - liste_noms_mc_ordonnee = self.getListeMcOrdonneeBrute(self.getGenealogie(),cata_ordonne) - liste_noms_mc_presents = self.listeMcPresents() - index=0 - for nom in liste_noms_mc_ordonnee: - if nom == nom_fils:break - if nom not in liste_noms_mc_presents :continue - index=index+1 - return index - - def chercheIndiceDsLeContenu(self,objet) : - # uniquement pour Pyxb - # ajoute la taille des les Blocs - # faut -il chercher plus loin ds les petits-enfants ? - if objet.nature == 'MCList' : objet=objet[0] - leRang=0 - positionDsLaListe=0 - try : - positionDsLaListe=self.mcListe.index(objet) - positionDsLaListeDeFactSiFact =0 - except : - for mc in self.mcListe: - if mc.nature == 'MCList': - try : - positionDsLaListeDeFactSiFact=mc.index(objet) - break - except : - positionDsLaListe=positionDsLaListe+1 - else : positionDsLaListe=positionDsLaListe+1 - i=0 - while i < positionDsLaListe : - leRang= leRang + self.mcListe[i].longueurDsArbre() - i=i+1 - leRang=leRang+positionDsLaListeDeFactSiFact - return leRang - - - def ordonneListeMc(self,listeMc_a_ordonner,liste_noms_mc_ordonnee): - """ - Retourne listeMc_a_ordonner ordonnee suivant l'ordre - donne par liste_noms_mc_ordonnee - """ - liste = [] - # on transforme liste_a_ordonner en un dictionnaire (plus facile a consulter) - d_mc = {} - for mc in listeMc_a_ordonner: - d_mc[mc.nom]=mc - # on construit la liste des objets ordonnes - for nom_mc in liste_noms_mc_ordonnee: - if nom_mc in d_mc: - liste.append(d_mc.get(nom_mc)) - # on la retourne - return liste - - def suppEntite(self,objet) : - """ - Supprime le fils 'objet' de self : - Retourne 1 si la suppression a pu etre effectuee, - Retourne 0 dans le cas contraire - """ - #print ('suppEntite', self.nom,objet.nom) - if not objet in self.mcListe: - # Impossible de supprimer objet. Il n'est pas dans mcListe - return 0 - - self.initModif() - objet.delObjPyxb() - objet.deleteRef() - self.mcListe.remove(objet) - CONNECTOR.Emit(self,"supp",objet) - objet.deleteMcGlobal() - objet.updateConditionBloc() - objet.supprime() - while self.etape.doitEtreRecalculee == True : - #print (' je suis dans le while') - self.etape.doitEtreRecalculee = False - self.etape.deepUpdateConditionBlocApresSuppression() - self.etape.modified() - self.finModif() - return 1 - - def isOblig(self): - return 0 - - def addEntite(self,name,pos=None): - """ - Ajoute le mot-cle name a la liste des mots-cles de - l'objet MCCOMPOSE - """ - #print ('addEntite', name, pos) - self.initModif() - if type(name)==bytes or type(name) == str : - # on est en mode creation d'un motcle - if self.ispermis(name) == 0 : return 0 - objet=self.definition.entites[name](val=None,nom=name,parent=self) - else : - # dans ce cas on est en mode copie d'un motcle - objet = name - # Appel de la methode qui fait le menage dans les references - # sur les concepts produits (verification que les concepts existent - # dans le contexte de la commande courante). - objet.verifExistenceSd() - - # On verifie que l'ajout d'objet est autorise - if self.ispermis(objet) == 0: - self.jdc.editor.afficheAlerte(tr("Erreur"), - tr("L'objet %(v_1)s ne peut etre un fils de %(v_2)s",\ - {'v_1': objet.nom, 'v_2': self.nom})) + # l'objet est absent : on enleve de la liste les blocs + if self.definition.entites[k].statut=='c' : + liste.remove(k) + if self.definition.entites[k].label=='BLOC': + liste.remove(k) + # Pour corriger les exces qui pourraient etre commis dans la methode purgeListe + # des regles, on essaie de compenser comme suit : + # on ajoute les mots cles facteurs presents dont l'occurence n'est pas atteinte + for k in listeMcPresents: + if k in liste:continue + objet = self.getChild(k,restreint = 'oui') + if isinstance(objet,MCFACT): + # un mot-cle facteur ne peut pas etre repete plus de self.max fois + if objet.definition.max > 1: + liste.append(k) + elif isinstance(objet,MCList): + nb_occur_maxi = objet[0].definition.max + if len(objet) < nb_occur_maxi: + liste.append(k) + return liste + + def listeMcPresents(self): + """ + Retourne la liste des noms des mots-cles fils de self presents construite + a partir de self.mcListe + """ + l=[] + for v in self.mcListe: + k=v.nom + l.append(k) + return l + + def getIndexChild(self,nom_fils): + """ + Retourne l'index dans la liste des fils de self du nouveau fils de nom nom_fils + Permet de savoir a quelle position il faut ajouter un nouveau mot-cle + """ + cata_ordonne = self.jdc.cata_ordonne_dico + liste_noms_mc_ordonnee = self.getListeMcOrdonneeBrute(self.getGenealogie(),cata_ordonne) + liste_noms_mc_presents = self.listeMcPresents() + index=0 + for nom in liste_noms_mc_ordonnee: + if nom == nom_fils:break + if nom not in liste_noms_mc_presents :continue + index=index+1 + return index + + def chercheIndiceDsLeContenu(self,objet) : + # uniquement pour Pyxb + # ajoute la taille des les Blocs + # faut -il chercher plus loin ds les petits-enfants ? + if objet.nature == 'MCList' : objet=objet[0] + leRang=0 + positionDsLaListe=0 + try : + positionDsLaListe=self.mcListe.index(objet) + positionDsLaListeDeFactSiFact =0 + except : + for mc in self.mcListe: + if mc.nature == 'MCList': + try : + positionDsLaListeDeFactSiFact=mc.index(objet) + break + except : + positionDsLaListe=positionDsLaListe+1 + else : positionDsLaListe=positionDsLaListe+1 + i=0 + while i < positionDsLaListe : + leRang= leRang + self.mcListe[i].longueurDsArbre() + i=i+1 + leRang=leRang+positionDsLaListeDeFactSiFact + return leRang + + + def ordonneListeMc(self,listeMc_a_ordonner,liste_noms_mc_ordonnee): + """ + Retourne listeMc_a_ordonner ordonnee suivant l'ordre + donne par liste_noms_mc_ordonnee + """ + liste = [] + # on transforme liste_a_ordonner en un dictionnaire (plus facile a consulter) + d_mc = {} + for mc in listeMc_a_ordonner: + d_mc[mc.nom]=mc + # on construit la liste des objets ordonnes + for nom_mc in liste_noms_mc_ordonnee: + if nom_mc in d_mc: + liste.append(d_mc.get(nom_mc)) + # on la retourne + return liste + + def suppEntite(self,objet) : + """ + Supprime le fils 'objet' de self : + Retourne 1 si la suppression a pu etre effectuee, + Retourne 0 dans le cas contraire + """ + #print ('suppEntite', self.nom,objet.nom) + if not objet in self.mcListe: + # Impossible de supprimer objet. Il n'est pas dans mcListe + return 0 + + self.initModif() + objet.delObjPyxb() + objet.deleteRef() + self.mcListe.remove(objet) + CONNECTOR.Emit(self,"supp",objet) + objet.deleteMcGlobal() + objet.updateConditionBloc() + objet.supprime() + while self.etape.doitEtreRecalculee == True : + #print (' je suis dans le while') + self.etape.doitEtreRecalculee = False + self.etape.deepUpdateConditionBlocApresSuppression() + self.etape.modified() self.finModif() + return 1 + + def isOblig(self): return 0 - # On cherche s'il existe deja un mot cle de meme nom - old_obj = self.getChild(objet.nom,restreint = 'oui') - if not old_obj : - # on normalize l'objet - objet=objet.normalize() - # Le mot cle n'existe pas encore. On l'ajoute a la position - # demandee (pos) - if pos == None : - self.mcListe.append(objet) - else : - self.mcListe.insert(pos,objet) - # Il ne faut pas oublier de reaffecter le parent d'obj (si copie) - objet.reparent(self) - if self.cata.modeleMetier : - if isinstance(objet,MCList): objet[0].addObjPyxb(self.chercheIndiceDsLeContenu(objet)) - else : objet.addObjPyxb(self.chercheIndiceDsLeContenu(objet)) - CONNECTOR.Emit(self,"add",objet) - objet.updateMcGlobal() - objet.updateConditionBloc() - self.finModif() - return objet - else: - # Le mot cle existe deja. Si le mot cle est repetable, - # on cree une liste d'objets. Dans le cas contraire, - # on emet un message d'erreur. - if not old_obj.isRepetable(): - self.jdc.editor.afficheAlerte(tr("Erreur"),tr("L'objet %s ne peut pas etre repete", objet.nom)) + def addEntite(self,name,pos=None): + """ + Ajoute le mot-cle name a la liste des mots-cles de + l'objet MCCOMPOSE + """ + #print ('addEntite', name, pos) + self.initModif() + if type(name)==bytes or type(name) == str : + # on est en mode creation d'un motcle + if self.ispermis(name) == 0 : return 0 + objet=self.definition.entites[name](val=None,nom=name,parent=self) + else : + # dans ce cas on est en mode copie d'un motcle + objet = name + # Appel de la methode qui fait le menage dans les references + # sur les concepts produits (verification que les concepts existent + # dans le contexte de la commande courante). + objet.verifExistenceSd() + + # On verifie que l'ajout d'objet est autorise + if self.ispermis(objet) == 0: + self.jdc.editor.afficheAlerte(tr("Erreur"), + tr("L'objet %(v_1)s ne peut etre un fils de %(v_2)s",\ + {'v_1': objet.nom, 'v_2': self.nom})) self.finModif() return 0 - else: - # une liste d'objets de meme type existe deja - old_obj.addEntite(objet) + + # On cherche s'il existe deja un mot cle de meme nom + old_obj = self.getChild(objet.nom,restreint = 'oui') + if not old_obj : + # on normalize l'objet + objet=objet.normalize() + # Le mot cle n'existe pas encore. On l'ajoute a la position + # demandee (pos) + if pos == None : + self.mcListe.append(objet) + else : + self.mcListe.insert(pos,objet) + # Il ne faut pas oublier de reaffecter le parent d'obj (si copie) + objet.reparent(self) if self.cata.modeleMetier : - if isinstance(objet,MCList): objet[0].addObjPyxb(self.chercheIndiceDsLeContenu(objet)) - else : objet.addObjPyxb(self.chercheIndiceDsLeContenu(objet)) + if isinstance(objet,MCList): objet[0].addObjPyxb(self.chercheIndiceDsLeContenu(objet)) + else : objet.addObjPyxb(self.chercheIndiceDsLeContenu(objet)) + CONNECTOR.Emit(self,"add",objet) + objet.updateMcGlobal() + objet.updateConditionBloc() self.finModif() - return old_obj - - def ispermis(self,fils): - """ - Retourne 1 si l'objet de nom nom_fils - est bien permis, cad peut bien etre un fils de self, - Retourne 0 sinon - """ - if type(fils) == bytes or type(fils) == str : - # on veut juste savoir si self peut avoir un fils de nom 'fils' - if fils in self.definition.entites: - return 1 - else : - return 0 - #elif type(fils) == types.InstanceType: - elif isinstance(fils,object): - # fils est un objet (commande,mcf,mclist) - # on est dans le cas d'une tentative de copie de l'objet - # on veut savoir si l'objet peut bien etre un fils de self : - # la verification du nom de suffit pas (plusieurs commandes - # ont le meme mot-cle facteur AFFE ... et c'est l'utilisateur - # qui choisit le pere d'ou un risque d'erreur) - if not fils.nom in self.definition.entites: - return 0 - else: - if fils.parent.nom != self.nom : return 0 - return 1 - - def updateConcept(self,sd): - for child in self.mcListe : - child.updateConcept(sd) - - def deleteConcept(self,sd): - """ - Inputs : - - sd=concept detruit - Fonction : - Mettre a jour les fils de l objet suite a la disparition du - concept sd - Seuls les mots cles simples MCSIMP font un traitement autre que - de transmettre aux fils - """ - for child in self.mcListe : - child.deleteConcept(sd) - - def replaceConcept(self,old_sd,sd): - """ - Inputs : - - old_sd=concept remplace - - sd = nouveau concept - Fonction : - Mettre a jour les fils de l objet suite au remplacement du - concept old_sd - """ - for child in self.mcListe : - child.replaceConcept(old_sd,sd) - - def getListeMcInconnus(self): - """ - Retourne la liste des mots-cles inconnus dans self - """ - l_mc = [] - if self.reste_val != {}: - for k,v in self.reste_val.items() : - l_mc.append([self,k,v]) - for child in self.mcListe : - if child.isValid() : continue - l_child = child.getListeMcInconnus() - for mc in l_child: - l = [self] - l.extend(mc) - l_mc.append(l) - return l_mc - - def deepUpdateConditionBlocApresSuppression(self): - self._updateConditionBloc() - for mcobj in self.mcListe: - if mcobj.nature=="MCList" : - for obj in mcobj : - obj.deepUpdateConditionBlocApresSuppression() - obj.state='modified' - elif hasattr(mcobj,"deepUpdateConditionBlocApresSuppression"): - mcobj.deepUpdateConditionBlocApresSuppression() - - - def deepUpdateConditionBlocApresCreation(self): - # idem deepUpdateConditionBloc sauf qu on cherche les MC qui - # avait ete laisse de cote par la construction - # Comme on est en construction, on ne devrait pas avoir a detruire de bloc - # si on vient d un xml invalide, il faudra probablement traiter les blocs deja crees - # reste_val est au niveau du MCCompo, il faut donc tout parcourir - #print ('dans deepUpdateConditionBlocApresCreation pour', self.nom) - if self.reste_val != {} : self.buildMcApresGlobalEnCreation() - for mcobj in self.mcListe: - if mcobj.nature=="MCList" : - for obj in mcobj : - obj.deepUpdateConditionBlocApresCreation() - obj.state='modified' - elif hasattr(mcobj,"deepUpdateConditionBlocApresCreation"): - mcobj.deepUpdateConditionBlocApresCreation() - mcobj.state='modified' - self.state='modified' - - def deepUpdateConditionBloc(self): - """ - Parcourt l'arborescence des mcobject et realise l'update - des blocs conditionnels par appel de la methode updateConditionBloc - """ - self._updateConditionBloc() - for mcobj in self.mcListe: - if hasattr(mcobj,"deepUpdateConditionBloc"): - mcobj.deepUpdateConditionBloc() - mcobj.state='modified' - if self.nature == 'PROCEDURE' : - if self.doitEtreRecalculee : - self.doitEtreRecalculee = False - self.deepUpdateConditionBloc() - - def updateConditionBloc(self): - """ - Realise l'update des blocs conditionnels fils de self - et propage au parent - """ - self._updateConditionBloc() - if self.parent:self.parent.updateConditionBloc() - - def _updateConditionBloc(self): - """ - Realise l'update des blocs conditionnels fils de self - """ - dict = self.creeDictCondition(self.mcListe,condition=1) - doitEtreReecrit=False - for k,v in self.definition.entites.items(): - if v.label != 'BLOC' :continue - globs= self.jdc and self.jdc.condition_context or {} - bloc=self.getChild(k,restreint = 'oui') - presence=v.verifPresence(dict,globs) - if presence and not bloc: - # le bloc doit etre present - # mais le bloc n'est pas present et il doit etre cree - pos=self.getIndexChild(k) - self.addEntite(k,pos) - #print ("AJOUT",k,pos) - if not presence and bloc: - # le bloc devrait etre absent - # le bloc est present : il faut l'enlever - #print ("SUPPRESSION BLOC",k,bloc) - self.suppEntite(bloc) - doitEtreReecrit=True - - def verifConditionBloc(self): - """ - 2021 : obsolete ? - Evalue les conditions de tous les blocs fils possibles - (en fonction du catalogue donc de la definition) de self - et retourne deux listes : - - la premiere contient les noms des blocs a rajouter - - la seconde contient les noms des blocs a supprimer - """ - liste_ajouts = [] - liste_retraits = [] - dict = self.creeDictCondition(self.mcListe,condition=1) - for k,v in self.definition.entites.items(): - if v.label=='BLOC' : - globs= self.jdc and self.jdc.condition_context or {} - if v.verifPresence(dict,globs): - # le bloc doit etre present - if not self.getChild(k,restreint = 'oui'): - # le bloc n'est pas present et il doit etre cree - liste_ajouts.append(k) - else : - # le bloc doit etre absent - if self.getChild(k,restreint = 'oui'): - # le bloc est present : il faut l'enlever - liste_retraits.append(k) - return liste_ajouts,liste_retraits - - def verifExistenceSd(self): - """ - Verifie que les structures de donnees utilisees dans self existent bien dans le contexte - avant etape, sinon enleve la reference a ces concepts - """ - for motcle in self.mcListe : - motcle.verifExistenceSd() - - def updateMcGlobal(self): - """ - Met a jour les mots cles globaux enregistres dans l'etape parente - et dans le jdc parent. - Un mot cle compose ne peut pas etre global. Il se contente de passer - la requete a ses fils. - """ - for motcle in self.mcListe : - motcle.updateMcGlobal() - - def deleteMcGlobal(self): - for motcle in self.mcListe : - motcle.deleteMcGlobal() - # PN : je ne comprends pas les 4 lignes suivantes - # du coup je les vire - # surtout en dehors dans le for ? - # 20201217 - #try : - # print (motcle) - # motcle.updateMcGlobal() - #except : - # pass - - def supprimeUserAssd(self): - for objUserAssd in self.userASSDCrees: - objUserAssd.supprime(self) - - def initModifUp(self): - Validation.V_MCCOMPO.MCCOMPO.initModifUp(self) - CONNECTOR.Emit(self,"valid") - - + return objet + else: + # Le mot cle existe deja. Si le mot cle est repetable, + # on cree une liste d'objets. Dans le cas contraire, + # on emet un message d'erreur. + if not old_obj.isRepetable(): + self.jdc.editor.afficheAlerte(tr("Erreur"),tr("L'objet %s ne peut pas etre repete", objet.nom)) + self.finModif() + return 0 + else: + # une liste d'objets de meme type existe deja + old_obj.addEntite(objet) + if self.cata.modeleMetier : + if isinstance(objet,MCList): objet[0].addObjPyxb(self.chercheIndiceDsLeContenu(objet)) + else : objet.addObjPyxb(self.chercheIndiceDsLeContenu(objet)) + self.finModif() + return old_obj + + def ispermis(self,fils): + """ + Retourne 1 si l'objet de nom nom_fils + est bien permis, cad peut bien etre un fils de self, + Retourne 0 sinon + """ + if type(fils) == bytes or type(fils) == str : + # on veut juste savoir si self peut avoir un fils de nom 'fils' + if fils in self.definition.entites: + return 1 + else : + return 0 + #elif type(fils) == types.InstanceType: + elif isinstance(fils,object): + # fils est un objet (commande,mcf,mclist) + # on est dans le cas d'une tentative de copie de l'objet + # on veut savoir si l'objet peut bien etre un fils de self : + # la verification du nom de suffit pas (plusieurs commandes + # ont le meme mot-cle facteur AFFE ... et c'est l'utilisateur + # qui choisit le pere d'ou un risque d'erreur) + if not fils.nom in self.definition.entites: + return 0 + else: + if fils.parent.nom != self.nom : return 0 + return 1 + + def updateConcept(self,sd): + for child in self.mcListe : + child.updateConcept(sd) + + def deleteConcept(self,sd): + """ + Inputs : + - sd=concept detruit + Fonction : + Mettre a jour les fils de l objet suite a la disparition du + concept sd + Seuls les mots cles simples MCSIMP font un traitement autre que + de transmettre aux fils + """ + for child in self.mcListe : + child.deleteConcept(sd) + + def replaceConcept(self,old_sd,sd): + """ + Inputs : + - old_sd=concept remplace + - sd = nouveau concept + Fonction : + Mettre a jour les fils de l objet suite au remplacement du + concept old_sd + """ + for child in self.mcListe : + child.replaceConcept(old_sd,sd) + + def getListeMcInconnus(self): + """ + Retourne la liste des mots-cles inconnus dans self + """ + l_mc = [] + if self.reste_val != {}: + for k,v in self.reste_val.items() : + l_mc.append([self,k,v]) + for child in self.mcListe : + if child.isValid() : continue + l_child = child.getListeMcInconnus() + for mc in l_child: + l = [self] + l.extend(mc) + l_mc.append(l) + return l_mc + + def deepUpdateConditionBlocApresSuppression(self): + self._updateConditionBloc() + for mcobj in self.mcListe: + if mcobj.nature=="MCList" : + for obj in mcobj : + obj.deepUpdateConditionBlocApresSuppression() + obj.state='modified' + elif hasattr(mcobj,"deepUpdateConditionBlocApresSuppression"): + mcobj.deepUpdateConditionBlocApresSuppression() + + + def deepUpdateConditionBlocApresCreation(self): + # idem deepUpdateConditionBloc sauf qu on cherche les MC qui + # avait ete laisse de cote par la construction + # Comme on est en construction, on ne devrait pas avoir a detruire de bloc + # si on vient d un xml invalide, il faudra probablement traiter les blocs deja crees + # reste_val est au niveau du MCCompo, il faut donc tout parcourir + #print ('dans deepUpdateConditionBlocApresCreation pour', self.nom) + if self.reste_val != {} : self.buildMcApresGlobalEnCreation() + for mcobj in self.mcListe: + if mcobj.nature=="MCList" : + for obj in mcobj : + obj.deepUpdateConditionBlocApresCreation() + obj.state='modified' + elif hasattr(mcobj,"deepUpdateConditionBlocApresCreation"): + mcobj.deepUpdateConditionBlocApresCreation() + mcobj.state='modified' + self.state='modified' + + def deepUpdateConditionBloc(self): + """ + Parcourt l'arborescence des mcobject et realise l'update + des blocs conditionnels par appel de la methode updateConditionBloc + """ + self._updateConditionBloc() + for mcobj in self.mcListe: + if hasattr(mcobj,"deepUpdateConditionBloc"): + mcobj.deepUpdateConditionBloc() + mcobj.state='modified' + if self.nature == 'PROCEDURE' : + if self.doitEtreRecalculee : + self.doitEtreRecalculee = False + self.deepUpdateConditionBloc() + + def updateConditionBloc(self): + """ + Realise l'update des blocs conditionnels fils de self + et propage au parent + """ + self._updateConditionBloc() + if self.parent:self.parent.updateConditionBloc() + + def _updateConditionBloc(self): + """ + Realise l'update des blocs conditionnels fils de self + """ + dict = self.creeDictCondition(self.mcListe,condition=1) + doitEtreReecrit=False + for k,v in self.definition.entites.items(): + if v.label != 'BLOC' :continue + globs= self.jdc and self.jdc.condition_context or {} + bloc=self.getChild(k,restreint = 'oui') + presence=v.verifPresence(dict,globs) + if presence and not bloc: + # le bloc doit etre present + # mais le bloc n'est pas present et il doit etre cree + pos=self.getIndexChild(k) + self.addEntite(k,pos) + #print ("AJOUT",k,pos) + if not presence and bloc: + # le bloc devrait etre absent + # le bloc est present : il faut l'enlever + #print ("SUPPRESSION BLOC",k,bloc) + self.suppEntite(bloc) + doitEtreReecrit=True + + def verifConditionBloc(self): + """ + 2021 : obsolete ? + Evalue les conditions de tous les blocs fils possibles + (en fonction du catalogue donc de la definition) de self + et retourne deux listes : + - la premiere contient les noms des blocs a rajouter + - la seconde contient les noms des blocs a supprimer + """ + liste_ajouts = [] + liste_retraits = [] + dict = self.creeDictCondition(self.mcListe,condition=1) + for k,v in self.definition.entites.items(): + if v.label=='BLOC' : + globs= self.jdc and self.jdc.condition_context or {} + if v.verifPresence(dict,globs): + # le bloc doit etre present + if not self.getChild(k,restreint = 'oui'): + # le bloc n'est pas present et il doit etre cree + liste_ajouts.append(k) + else : + # le bloc doit etre absent + if self.getChild(k,restreint = 'oui'): + # le bloc est present : il faut l'enlever + liste_retraits.append(k) + return liste_ajouts,liste_retraits + + def verifExistenceSd(self): + """ + Verifie que les structures de donnees utilisees dans self existent bien dans le contexte + avant etape, sinon enleve la reference a ces concepts + """ + for motcle in self.mcListe : + motcle.verifExistenceSd() + + def updateMcGlobal(self): + """ + Met a jour les mots cles globaux enregistres dans l'etape parente + et dans le jdc parent. + Un mot cle compose ne peut pas etre global. Il se contente de passer + la requete a ses fils. + """ + for motcle in self.mcListe : + motcle.updateMcGlobal() + + def deleteMcGlobal(self): + for motcle in self.mcListe : + motcle.deleteMcGlobal() + # PN : je ne comprends pas les 4 lignes suivantes + # du coup je les vire + # surtout en dehors dans le for ? + # 20201217 + #try : + # print (motcle) + # motcle.updateMcGlobal() + #except : + # pass + + def supprimeUserAssd(self): + for objUserAssd in self.userASSDCrees: + objUserAssd.supprime(self) + + def initModifUp(self): + Validation.V_MCCOMPO.MCCOMPO.initModifUp(self) + CONNECTOR.Emit(self,"valid") diff --git a/Ihm/I_MCFACT.py b/Ihm/I_MCFACT.py index a95eba45..99c170b8 100644 --- a/Ihm/I_MCFACT.py +++ b/Ihm/I_MCFACT.py @@ -24,107 +24,107 @@ from . import I_MCCOMPO import Noyau class MCFACT(I_MCCOMPO.MCCOMPO): - def isRepetable(self): - """ - Indique si l'objet est repetable. - Retourne 1 si le mot-cle facteur self peut etre repete - Retourne 0 dans le cas contraire - """ - if self.definition.max > 1: - # marche avec '**' - return 1 - else : - return 0 + def isRepetable(self): + """ + Indique si l'objet est repetable. + Retourne 1 si le mot-cle facteur self peut etre repete + Retourne 0 dans le cas contraire + """ + if self.definition.max > 1: + # marche avec '**' + return 1 + else : + return 0 - def isOblig(self): - if self.definition.statut != 'o' : return 0 - objet = self.parent.getChild(self.nom) - if len(objet) > 1 : return 0 - else : return 1 + def isOblig(self): + if self.definition.statut != 'o' : return 0 + objet = self.parent.getChild(self.nom) + if len(objet) > 1 : return 0 + else : return 1 - def getMinMax(self): - """ - Retourne les valeurs min et max admissibles pour la valeur de self - """ - return self.definition.min,self.definition.max + def getMinMax(self): + """ + Retourne les valeurs min et max admissibles pour la valeur de self + """ + return self.definition.min,self.definition.max - def getNomDsXML(self): - # en xml on a une sequence si max est superieur a 1 - # sinon non - objet = self.parent.getChild(self.nom, restreint='oui') - if len(objet) > 1 : - index = objet.getIndex(self) - nom = self.nom + "[" + str(index) + "]" - else : - if self.definition.max == 1 : nom = self.nom - else : nom = self.nom+"[0]" - nomDsXML=self.parent.getNomDsXML()+"."+nom - return nomDsXML + def getNomDsXML(self): + # en xml on a une sequence si max est superieur a 1 + # sinon non + objet = self.parent.getChild(self.nom, restreint='oui') + if len(objet) > 1 : + index = objet.getIndex(self) + nom = self.nom + "[" + str(index) + "]" + else : + if self.definition.max == 1 : nom = self.nom + else : nom = self.nom+"[0]" + nomDsXML=self.parent.getNomDsXML()+"."+nom + return nomDsXML - def getLabelText(self): - """ - Retourne le label de self suivant qu'il s'agit d'un MCFACT - isole ou d'un MCFACT appartenant a une MCList : - utilisee pour l'affichage dans l'arbre - """ - objet = self.parent.getChild(self.nom, restreint='oui') - # objet peut-etre self ou une MCList qui contient self ... - if objet is None or objet is self: - return tr("Erreur - mclist inexistante : %s", self.nom) + def getLabelText(self): + """ + Retourne le label de self suivant qu'il s'agit d'un MCFACT + isole ou d'un MCFACT appartenant a une MCList : + utilisee pour l'affichage dans l'arbre + """ + objet = self.parent.getChild(self.nom, restreint='oui') + # objet peut-etre self ou une MCList qui contient self ... + if objet is None or objet is self: + return tr("Erreur - mclist inexistante : %s", self.nom) - try: - if len(objet) > 1 : - index = objet.getIndex(self)+1 # + 1 a cause de la numerotation qui commence a 0 - return tr(self.nom) +'_'+repr(index)+':' - else: - return tr(self.nom) - except: - return tr("Erreur - mot cle facteur de nom : %s", self.nom) + try: + if len(objet) > 1 : + index = objet.getIndex(self)+1 # + 1 a cause de la numerotation qui commence a 0 + return tr(self.nom) +'_'+repr(index)+':' + else: + return tr(self.nom) + except: + return tr("Erreur - mot cle facteur de nom : %s", self.nom) - def getGenealogiePrecise(self): - nom=self.getLabelText() - if nom[-1]==':' : nom=nom[0:-1] - if self.parent: - l=self.parent.getGenealogiePrecise() - l.append(nom.strip()) - return l - else: - return [nom.strip()] + def getGenealogiePrecise(self): + nom=self.getLabelText() + if nom[-1]==':' : nom=nom[0:-1] + if self.parent: + l=self.parent.getGenealogiePrecise() + l.append(nom.strip()) + return l + else: + return [nom.strip()] - def initModif(self): - """ - Met l'etat de l'objet a modified et propage au parent - qui vaut None s'il n'existe pas - """ - self.state = 'modified' - parent= hasattr(self,"alt_parent") and self.alt_parent or self.parent - if parent: - parent.initModif() + def initModif(self): + """ + Met l'etat de l'objet a modified et propage au parent + qui vaut None s'il n'existe pas + """ + self.state = 'modified' + parent= hasattr(self,"alt_parent") and self.alt_parent or self.parent + if parent: + parent.initModif() - def finModif(self): - """ - Methode appelee apres qu'une modification a ete faite afin de declencher - d'eventuels traitements post-modification - """ - #print "finModif",self - # pour les objets autres que les commandes, aucun traitement specifique - # on remonte l'info de fin de modif au parent - CONNECTOR.Emit(self,"valid") - parent= hasattr(self,"alt_parent") and self.alt_parent or self.parent - if parent: - parent.finModif() + def finModif(self): + """ + Methode appelee apres qu'une modification a ete faite afin de declencher + d'eventuels traitements post-modification + """ + #print "finModif",self + # pour les objets autres que les commandes, aucun traitement specifique + # on remonte l'info de fin de modif au parent + CONNECTOR.Emit(self,"valid") + parent= hasattr(self,"alt_parent") and self.alt_parent or self.parent + if parent: + parent.finModif() - def normalize(self): - """ Retourne le MCFACT normalise. Pour un MCFACT isole, l'objet normalise - est une MCLIST de longueur 1 qui contient ce MCFACT - """ - new_obj = self.definition.list_instance() - new_obj.init(nom=self.nom,parent=None) - new_obj.append(self) - return new_obj + def normalize(self): + """ Retourne le MCFACT normalise. Pour un MCFACT isole, l'objet normalise + est une MCLIST de longueur 1 qui contient ce MCFACT + """ + new_obj = self.definition.list_instance() + new_obj.init(nom=self.nom,parent=None) + new_obj.append(self) + return new_obj - def supprime(self): - self.alt_parent=None - Noyau.N_MCFACT.MCFACT.supprime(self) + def supprime(self): + self.alt_parent=None + Noyau.N_MCFACT.MCFACT.supprime(self) diff --git a/Ihm/I_MCLIST.py b/Ihm/I_MCLIST.py index 387126be..c036916c 100644 --- a/Ihm/I_MCLIST.py +++ b/Ihm/I_MCLIST.py @@ -25,272 +25,272 @@ from copy import copy from . import CONNECTOR class MCList: - def isMCList(self): - """ - Retourne 1 si self est une MCList (liste de mots-cles), 0 sinon (defaut) - """ - return 1 - - def getIndex(self,objet): - """ - Retourne la position d'objet dans la liste self - """ - return self.data.index(objet) - - def ajoutPossible(self): - """ - Methode booleenne qui retourne 1 si on peut encore ajouter une occurrence - de l'element que contient self, 0 sinon - """ - max = self.data[0].definition.max - if max == '**' or max == float('inf'): - return 1 - else: - if len(self) < max : + def isMCList(self): + """ + Retourne 1 si self est une MCList (liste de mots-cles), 0 sinon (defaut) + """ return 1 - else: - return 0 - - def isRepetable(self): - """ - Indique si l'objet est repetable. - Retourne 1 si le mot-cle facteur self peut etre repete - Retourne 0 dans le cas contraire - """ - if self.data[0].definition.max > 1: - # marche avec '**' - return 1 - else : - return 0 - - def isOblig(self): - """ - Une MCList n'est jamais obligatoire (meme si le MCFACT qu'elle represente l'est - """ - return self.data[0].definition.statut=='o' - - def suppEntite(self,obj): - """ - Supprime le mot cle facteur obj de la MCLIST - """ - if obj not in self: - return 0 - - self.initModif() - self.remove(obj) - CONNECTOR.Emit(self,"supp",obj) - self.updateConditionBloc() - obj.delObjPyxb() - obj.supprime() - self.etape.modified() - self.finModif() - return 1 - - def addEntite(self,obj,pos=None): - """ - Ajoute le mot cle facteur obj a la MCLIST a la position pos - Retourne None si l'ajout est impossible - """ - if type(obj)==bytes or type(obj) == str : - # on est en mode creation d'un motcle - raise EficasException(tr("traitement non-prevu")) - - if not self.ajoutPossible(): - self.jdc.editor.afficheAlerte(tr("Erreur"), - tr("L'objet %s ne peut pas etre ajoute", obj.nom)) - return None - - if self.nom != obj.nom: - return None - - if obj.isMCList(): - obj=obj.data[0] - - # traitement du copier coller seulement - # Les autres cas d'ajout sont traites dans MCFACT - self.initModif() - obj.verifExistenceSd() - obj.reparent(self.parent) - if pos is None: - self.append(obj) - else: - self.insert(pos,obj) - CONNECTOR.Emit(self,"add",obj) - self.finModif() - self.updateConditionBloc() - return obj - - def listeMcPresents(self): - return [] - - def updateConcept(self,sd): - for child in self.data : - child.updateConcept(sd) - - def deleteRef(self): - for child in self.data : - child.deleteRef() - - def deleteConcept(self,sd): - """ - Inputs : - - sd=concept detruit - Fonction : Mettre a jour les fils de l objet suite a la disparition - du concept sd - Seuls les mots cles simples MCSIMP font un traitement autre - que de transmettre aux fils - """ - for child in self.data : - child.deleteConcept(sd) - - def replaceConcept(self,old_sd,sd): - """ - Inputs : - - old_sd=concept remplace - - sd=nouveau concept - Fonction : Mettre a jour les fils de l objet suite au remplacement - du concept old_sd - """ - for child in self.data : - child.replaceConcept(old_sd,sd) - - def getDocu(self): - return self.data[0].definition.getDocu() - - def getListeMcInconnus(self): - """ - Retourne la liste des mots-cles inconnus dans self - """ - l_mc = [] - for mcfact in self.data : - if mcfact.isValid() : continue - l_child = mcfact.getListeMcInconnus() - for mc in l_child: - l = [self] - l.extend(mc) - l_mc.append(l) - return l_mc - - def verifConditionRegles(self,liste_presents): - """ - Retourne la liste des mots-cles a rajouter pour satisfaire les regles - en fonction de la liste des mots-cles presents - """ - # Sans objet pour une liste de mots cles facteurs - return [] - - def deepUpdateConditionBloc(self): - """ - Parcourt l'arborescence des mcobject et realise l'update - des blocs conditionnels par appel de la methode updateConditionBloc - """ - #print "deepUpdateConditionBloc",self - for mcfact in self.data : - mcfact.deepUpdateConditionBloc() - - def updateConditionBloc(self): - """ - Propage la mise a jour des conditions au parent. - Une liste ne fait pas de traitement sur les conditions - """ - if self.parent: self.parent.updateConditionBloc() - - def verifConditionBloc(self): - """ - Evalue les conditions de tous les blocs fils possibles - (en fonction du catalogue donc de la definition) de self et - retourne deux listes : - - la premiere contient les noms des blocs a rajouter - - la seconde contient les noms des blocs a supprimer - """ - # Sans objet pour une liste de mots cles facteurs (a voir !!!) - return [],[] - - def initModif(self): - """ - Met l'etat de l'objet a modified et propage au parent - qui vaut None s'il n'existe pas - """ - self.state = 'modified' - if self.parent: - self.parent.initModif() - - def finModif(self): - """ - Methode appelee apres qu'une modification a ete faite afin de declencher - d'eventuels traitements post-modification - """ - #print "finModif",self - CONNECTOR.Emit(self,"valid") - if self.parent: - self.parent.finModif() - - def getGenealogiePrecise(self): - if self.parent: - return self.parent.getGenealogiePrecise() - else: + + def getIndex(self,objet): + """ + Retourne la position d'objet dans la liste self + """ + return self.data.index(objet) + + def ajoutPossible(self): + """ + Methode booleenne qui retourne 1 si on peut encore ajouter une occurrence + de l'element que contient self, 0 sinon + """ + max = self.data[0].definition.max + if max == '**' or max == float('inf'): + return 1 + else: + if len(self) < max : + return 1 + else: + return 0 + + def isRepetable(self): + """ + Indique si l'objet est repetable. + Retourne 1 si le mot-cle facteur self peut etre repete + Retourne 0 dans le cas contraire + """ + if self.data[0].definition.max > 1: + # marche avec '**' + return 1 + else : + return 0 + + def isOblig(self): + """ + Une MCList n'est jamais obligatoire (meme si le MCFACT qu'elle represente l'est + """ + return self.data[0].definition.statut=='o' + + def suppEntite(self,obj): + """ + Supprime le mot cle facteur obj de la MCLIST + """ + if obj not in self: + return 0 + + self.initModif() + self.remove(obj) + CONNECTOR.Emit(self,"supp",obj) + self.updateConditionBloc() + obj.delObjPyxb() + obj.supprime() + self.etape.modified() + self.finModif() + return 1 + + def addEntite(self,obj,pos=None): + """ + Ajoute le mot cle facteur obj a la MCLIST a la position pos + Retourne None si l'ajout est impossible + """ + if type(obj)==bytes or type(obj) == str : + # on est en mode creation d'un motcle + raise EficasException(tr("traitement non-prevu")) + + if not self.ajoutPossible(): + self.jdc.editor.afficheAlerte(tr("Erreur"), + tr("L'objet %s ne peut pas etre ajoute", obj.nom)) + return None + + if self.nom != obj.nom: + return None + + if obj.isMCList(): + obj=obj.data[0] + + # traitement du copier coller seulement + # Les autres cas d'ajout sont traites dans MCFACT + self.initModif() + obj.verifExistenceSd() + obj.reparent(self.parent) + if pos is None: + self.append(obj) + else: + self.insert(pos,obj) + CONNECTOR.Emit(self,"add",obj) + self.finModif() + self.updateConditionBloc() + return obj + + def listeMcPresents(self): return [] - def getGenealogie(self): - """ - Retourne la liste des noms des ascendants. - Un objet MCList n'est pas enregistre dans la genealogie. - XXX Meme si le MCFACT fils ne l'est pas lui non plus ???? - """ - if self.parent: - return self.parent.getGenealogie() - else: + def updateConcept(self,sd): + for child in self.data : + child.updateConcept(sd) + + def deleteRef(self): + for child in self.data : + child.deleteRef() + + def deleteConcept(self,sd): + """ + Inputs : + - sd=concept detruit + Fonction : Mettre a jour les fils de l objet suite a la disparition + du concept sd + Seuls les mots cles simples MCSIMP font un traitement autre + que de transmettre aux fils + """ + for child in self.data : + child.deleteConcept(sd) + + def replaceConcept(self,old_sd,sd): + """ + Inputs : + - old_sd=concept remplace + - sd=nouveau concept + Fonction : Mettre a jour les fils de l objet suite au remplacement + du concept old_sd + """ + for child in self.data : + child.replaceConcept(old_sd,sd) + + def getDocu(self): + return self.data[0].definition.getDocu() + + def getListeMcInconnus(self): + """ + Retourne la liste des mots-cles inconnus dans self + """ + l_mc = [] + for mcfact in self.data : + if mcfact.isValid() : continue + l_child = mcfact.getListeMcInconnus() + for mc in l_child: + l = [self] + l.extend(mc) + l_mc.append(l) + return l_mc + + def verifConditionRegles(self,liste_presents): + """ + Retourne la liste des mots-cles a rajouter pour satisfaire les regles + en fonction de la liste des mots-cles presents + """ + # Sans objet pour une liste de mots cles facteurs return [] - def getListeMcOrdonneeBrute(self,liste,dico): - """ - Retourne la liste ordonnee (suivant le catalogue) BRUTE des mots-cles - d'une entite composee dont le chemin complet est donne sous forme - d'une liste du type :ETAPE + MCFACT ou MCBLOC + ... - """ - for arg in liste: - objet_cata = dico[arg] - dico=objet_cata.entites - return objet_cata.ordre_mc - - def verifExistenceSd(self): - """ - Verifie que les structures de donnees utilisees dans self existent bien dans le contexte - avant etape, sinon enleve la reference a ces concepts - """ - for motcle in self.data : - motcle.verifExistenceSd() - - def getFr(self): - """ - Retourne la chaine d'aide contenue dans le catalogue - en tenant compte de la langue - """ - try : - return self.data[0].getFr() - except: - return '' - - def normalize(self): - """ - Retourne l'objet normalise. Une liste est deja normalisee - """ - return self - - def updateMcGlobal(self): - """ - Met a jour les mots cles globaux enregistres dans l'etape parente - et dans le jdc parent. - Une liste ne peut pas etre globale. Elle se contente de passer - la requete a ses fils. - """ - for motcle in self.data : - motcle.updateMcGlobal() - - def deleteMcGlobal(self): - for motcle in self.data : - motcle.deleteMcGlobal() - - - #def __del__(self): - # print "__del__",self + def deepUpdateConditionBloc(self): + """ + Parcourt l'arborescence des mcobject et realise l'update + des blocs conditionnels par appel de la methode updateConditionBloc + """ + #print "deepUpdateConditionBloc",self + for mcfact in self.data : + mcfact.deepUpdateConditionBloc() + + def updateConditionBloc(self): + """ + Propage la mise a jour des conditions au parent. + Une liste ne fait pas de traitement sur les conditions + """ + if self.parent: self.parent.updateConditionBloc() + + def verifConditionBloc(self): + """ + Evalue les conditions de tous les blocs fils possibles + (en fonction du catalogue donc de la definition) de self et + retourne deux listes : + - la premiere contient les noms des blocs a rajouter + - la seconde contient les noms des blocs a supprimer + """ + # Sans objet pour une liste de mots cles facteurs (a voir !!!) + return [],[] + + def initModif(self): + """ + Met l'etat de l'objet a modified et propage au parent + qui vaut None s'il n'existe pas + """ + self.state = 'modified' + if self.parent: + self.parent.initModif() + + def finModif(self): + """ + Methode appelee apres qu'une modification a ete faite afin de declencher + d'eventuels traitements post-modification + """ + #print "finModif",self + CONNECTOR.Emit(self,"valid") + if self.parent: + self.parent.finModif() + + def getGenealogiePrecise(self): + if self.parent: + return self.parent.getGenealogiePrecise() + else: + return [] + + def getGenealogie(self): + """ + Retourne la liste des noms des ascendants. + Un objet MCList n'est pas enregistre dans la genealogie. + XXX Meme si le MCFACT fils ne l'est pas lui non plus ???? + """ + if self.parent: + return self.parent.getGenealogie() + else: + return [] + + def getListeMcOrdonneeBrute(self,liste,dico): + """ + Retourne la liste ordonnee (suivant le catalogue) BRUTE des mots-cles + d'une entite composee dont le chemin complet est donne sous forme + d'une liste du type :ETAPE + MCFACT ou MCBLOC + ... + """ + for arg in liste: + objet_cata = dico[arg] + dico=objet_cata.entites + return objet_cata.ordre_mc + + def verifExistenceSd(self): + """ + Verifie que les structures de donnees utilisees dans self existent bien dans le contexte + avant etape, sinon enleve la reference a ces concepts + """ + for motcle in self.data : + motcle.verifExistenceSd() + + def getFr(self): + """ + Retourne la chaine d'aide contenue dans le catalogue + en tenant compte de la langue + """ + try : + return self.data[0].getFr() + except: + return '' + + def normalize(self): + """ + Retourne l'objet normalise. Une liste est deja normalisee + """ + return self + + def updateMcGlobal(self): + """ + Met a jour les mots cles globaux enregistres dans l'etape parente + et dans le jdc parent. + Une liste ne peut pas etre globale. Elle se contente de passer + la requete a ses fils. + """ + for motcle in self.data : + motcle.updateMcGlobal() + + def deleteMcGlobal(self): + for motcle in self.data : + motcle.deleteMcGlobal() + + + #def __del__(self): + # print "__del__",self diff --git a/Ihm/I_MCSIMP.py b/Ihm/I_MCSIMP.py index b63616ea..e77df2d8 100644 --- a/Ihm/I_MCSIMP.py +++ b/Ihm/I_MCSIMP.py @@ -54,811 +54,809 @@ from .I_VALIDATOR import ValError,listProto class MCSIMP(I_OBJECT.OBJECT): - def isValid(self,cr='non'): - if self.state == 'unchanged': - return self.valid - for type_permis in self.definition.type: - if hasattr(type_permis, "__class__") and type_permis.__class__.__name__ == 'Matrice': - self.monType=type_permis - return self.valideMatrice(cr=cr) - validite=Validation.V_MCSIMP.MCSIMP.isValid(self,cr=cr) - - if self.definition.siValide != None and validite: + def isValid(self,cr='non'): + if self.state == 'unchanged': + return self.valid + for type_permis in self.definition.type: + if hasattr(type_permis, "__class__") and type_permis.__class__.__name__ == 'Matrice': + self.monType=type_permis + return self.valideMatrice(cr=cr) + validite=Validation.V_MCSIMP.MCSIMP.isValid(self,cr=cr) + + if self.definition.siValide != None and validite: self.definition.siValide(self) - return validite + return validite - def getNomConcept(self): - p=self - while p.parent : - try : - nomconcept=p.getSdname() - return nomconcept - except: + def getNomConcept(self): + p=self + while p.parent : try : - nomconcept= p.object.getSdname() - return nomconcept - except : - pass - p=p.parent - return "" - - def getText(self): - """ - Retourne le texte a afficher dans l'arbre representant la valeur de l'objet - pointe par self - """ - - if self.valeur == None : - return None - elif type(self.valeur) == float : - # traitement d'un flottant isole - txt = str(self.valeur) - clefobj=self.getNomConcept() - if clefobj in self.jdc.appliEficas.dict_reels : - if self.valeur in self.jdc.appliEficas.dict_reels[clefobj]: - txt=self.jdc.appliEficas.dict_reels[clefobj][self.valeur] - elif type(self.valeur) in (list,tuple) : - if self.valeur==[] or self.valeur == (): return str(self.valeur) - # traitement des listes - txt='(' - sep='' - for val in self.valeur: - if type(val) == float : - clefobj=self.getNomConcept() - if clefobj in self.jdc.appliEficas.dict_reels: - if val in self.jdc.appliEficas.dict_reels[clefobj]: - txt=txt + sep +self.jdc.appliEficas.dict_reels[clefobj][val] - else : - txt=txt + sep + str(val) - else : - txt=txt + sep + str(val) - else: - if isinstance(val,tuple): - texteVal='(' - for i in val : - if isinstance(i, bytes) : texteVal = texteVal +"'"+str(i)+"'," - else : texteVal = texteVal + str(i)+',' - texteVal=texteVal[:-1]+')' - else : - if isinstance(val,bytes): texteVal="'"+str(val)+"'" - else :texteVal=str(val) - txt = txt + sep+ texteVal + nomconcept=p.getSdname() + return nomconcept + except: + try : + nomconcept= p.object.getSdname() + return nomconcept + except : + pass + p=p.parent + return "" + + def getText(self): + """ + Retourne le texte a afficher dans l'arbre representant la valeur de l'objet + pointe par self + """ + + if self.valeur == None : + return None + elif type(self.valeur) == float : + # traitement d'un flottant isole + txt = str(self.valeur) + clefobj=self.getNomConcept() + if clefobj in self.jdc.appliEficas.dict_reels : + if self.valeur in self.jdc.appliEficas.dict_reels[clefobj]: + txt=self.jdc.appliEficas.dict_reels[clefobj][self.valeur] + elif type(self.valeur) in (list,tuple) : + if self.valeur==[] or self.valeur == (): return str(self.valeur) + # traitement des listes + txt='(' + sep='' + for val in self.valeur: + if type(val) == float : + clefobj=self.getNomConcept() + if clefobj in self.jdc.appliEficas.dict_reels: + if val in self.jdc.appliEficas.dict_reels[clefobj]: + txt=txt + sep +self.jdc.appliEficas.dict_reels[clefobj][val] + else : + txt=txt + sep + str(val) + else : + txt=txt + sep + str(val) + else: + if isinstance(val,tuple): + texteVal='(' + for i in val : + if isinstance(i, bytes) : texteVal = texteVal +"'"+str(i)+"'," + else : texteVal = texteVal + str(i)+',' + texteVal=texteVal[:-1]+')' + else : + if isinstance(val,bytes): texteVal="'"+str(val)+"'" + else :texteVal=str(val) + txt = txt + sep+ texteVal ## if len(txt) > 200: ## #ligne trop longue, on tronque ## txt=txt+" ..." ## break - sep=',' - # cas des listes de tuples de longueur 1 - if isinstance(val,tuple) and len(self.valeur) == 1 : txt=txt+',' - txt=txt+')' - else: - # traitement des autres cas - txt = str(self.valeur) - - # txt peut etre une longue chaine sur plusieurs lignes. - # Il est possible de tronquer cette chaine au premier \n et - # de limiter la longueur de la chaine a 30 caracteres. Cependant - # ceci provoque une perte d'information pour l'utilisateur - # Pour le moment on retourne la chaine telle que - return txt - - def getVal(self): - """ - Retourne une chaine de caractere representant la valeur de self - """ - val=self.valeur - if type(val) == float : - clefobj=self.getNomConcept() - if clefobj in self.jdc.appliEficas.dict_reels : - if val in self.jdc.appliEficas.appliEficas.dict_reels[clefobj] : - return self.jdc.appliEficas.dict_reels[clefobj][val] - if type(val) != tuple : - try: - return val.getName() - except: - return val - else : - if val ==() or val == [] : return val - s='( ' - for item in val : - try : - s=s+item.getName()+',' - except: - s=s+repr(item)+',' - s=s+' )' - return s - - def waitBool(self): - for typ in self.definition.type: - try : - if typ == bool: return True - except : - pass - return False - - def waitCo(self): - """ - Methode booleenne qui retourne 1 si l'objet attend un objet ASSD - qui n'existe pas encore (type CO()), 0 sinon - """ - for typ in self.definition.type: - if type(typ) == type or isinstance(typ,type): - if issubclass(typ,CO) : - return 1 - return 0 - - def waitAssd(self): - """ - Methode booleenne qui retourne 1 si le MCS attend un objet de type ASSD ou UserASSD - ou derive, 0 sinon - """ - for typ in self.definition.type: - if type(typ) == type or isinstance(typ,type): - if issubclass(typ,ASSD) and not issubclass(typ,GEOM) : - return 1 - return 0 - - def waitUserAssd(self): - """ - Methode booleenne qui retourne 1 si le MCS attend un objet de type ASSD - ou derive, 0 sinon - """ - for typ in self.definition.type: - if type(typ) == type or isinstance(typ,type): - if issubclass(typ,UserASSD) : - return 1 - return 0 - - def waitUserAssdMultiple(self): - for typ in self.definition.type: - if type(typ) == type or isinstance(typ,type): - if issubclass(typ,UserASSDMultiple) : - return 1 - return 0 - - def waitUserAssdOrAssdMultipleEnCreation(self): - for typ in self.definition.type: - if typ == 'createObject' : - return 1 - return 0 - - - def waitAssdOrGeom(self): - """ - Retourne 1 si le mot-cle simple attend un objet de type - assd, ASSD, geom ou GEOM - Retourne 0 dans le cas contraire - """ - for typ in self.definition.type: - if type(typ) == type or isinstance(typ,type): - if typ.__name__ in ("GEOM","ASSD","geom","assd") or issubclass(typ,GEOM) : - return 1 - return 0 - - def waitGeom(self): - """ - Retourne 1 si le mot-cle simple attend un objet de type GEOM - Retourne 0 dans le cas contraire - """ - for typ in self.definition.type: - if type(typ) == type or isinstance(typ,type): - if issubclass(typ,GEOM) : return 1 - return 0 - - - def waitTxm(self): - """ - Retourne 1 si le mot-cle simple attend un objet de type TXM - Retourne 0 dans le cas contraire - """ - for typ in self.definition.type: - if typ == 'TXM' :return 1 - return 0 - - def waitTuple(self): - for ss_type in self.definition.type: - if repr(ss_type).find('Tuple') != -1 : - return 1 - return 0 - - - def getListeValeurs(self): - """ - """ - if self.valeur == None: - return [] - elif type(self.valeur) == tuple: - return list(self.valeur) - elif type(self.valeur) == list: - return self.valeur - else: - return [self.valeur] - - def isOblig(self): - return self.definition.statut=='o' - - def isImmuable(self): - return self.definition.homo=='constant' - - def isInformation(self): - return self.definition.homo=='information' - - - - def validVal(self,valeur): - """ - Verifie que la valeur passee en argument (valeur) est valide - sans modifier la valeur courante - """ - lval=listProto.adapt(valeur) - if lval is None: - valid=0 - mess=tr("None n'est pas une valeur autorisee") - else: - try: - for val in lval: + sep=',' + # cas des listes de tuples de longueur 1 + if isinstance(val,tuple) and len(self.valeur) == 1 : txt=txt+',' + txt=txt+')' + else: + # traitement des autres cas + txt = str(self.valeur) + + # txt peut etre une longue chaine sur plusieurs lignes. + # Il est possible de tronquer cette chaine au premier \n et + # de limiter la longueur de la chaine a 30 caracteres. Cependant + # ceci provoque une perte d'information pour l'utilisateur + # Pour le moment on retourne la chaine telle que + return txt + + def getVal(self): + """ + Retourne une chaine de caractere representant la valeur de self + """ + val=self.valeur + if type(val) == float : + clefobj=self.getNomConcept() + if clefobj in self.jdc.appliEficas.dict_reels : + if val in self.jdc.appliEficas.appliEficas.dict_reels[clefobj] : + return self.jdc.appliEficas.dict_reels[clefobj][val] + if type(val) != tuple : + try: + return val.getName() + except: + return val + else : + if val ==() or val == [] : return val + s='( ' + for item in val : + try : + s=s+item.getName()+',' + except: + s=s+repr(item)+',' + s=s+' )' + return s + + def waitBool(self): + for typ in self.definition.type: + try : + if typ == bool: return True + except : + pass + return False + + def waitCo(self): + """ + Methode booleenne qui retourne 1 si l'objet attend un objet ASSD + qui n'existe pas encore (type CO()), 0 sinon + """ + for typ in self.definition.type: + if type(typ) == type or isinstance(typ,type): + if issubclass(typ,CO) : + return 1 + return 0 + + def waitAssd(self): + """ + Methode booleenne qui retourne 1 si le MCS attend un objet de type ASSD ou UserASSD + ou derive, 0 sinon + """ + for typ in self.definition.type: + if type(typ) == type or isinstance(typ,type): + if issubclass(typ,ASSD) and not issubclass(typ,GEOM) : + return 1 + return 0 + + def waitUserAssd(self): + """ + Methode booleenne qui retourne 1 si le MCS attend un objet de type ASSD + ou derive, 0 sinon + """ + for typ in self.definition.type: + if type(typ) == type or isinstance(typ,type): + if issubclass(typ,UserASSD) : + return 1 + return 0 + + def waitUserAssdMultiple(self): + for typ in self.definition.type: + if type(typ) == type or isinstance(typ,type): + if issubclass(typ,UserASSDMultiple) : + return 1 + return 0 + + def waitUserAssdOrAssdMultipleEnCreation(self): + for typ in self.definition.type: + if typ == 'createObject' : + return 1 + return 0 + + + def waitAssdOrGeom(self): + """ + Retourne 1 si le mot-cle simple attend un objet de type + assd, ASSD, geom ou GEOM + Retourne 0 dans le cas contraire + """ + for typ in self.definition.type: + if type(typ) == type or isinstance(typ,type): + if typ.__name__ in ("GEOM","ASSD","geom","assd") or issubclass(typ,GEOM) : + return 1 + return 0 + + def waitGeom(self): + """ + Retourne 1 si le mot-cle simple attend un objet de type GEOM + Retourne 0 dans le cas contraire + """ + for typ in self.definition.type: + if type(typ) == type or isinstance(typ,type): + if issubclass(typ,GEOM) : return 1 + return 0 + + + def waitTxm(self): + """ + Retourne 1 si le mot-cle simple attend un objet de type TXM + Retourne 0 dans le cas contraire + """ + for typ in self.definition.type: + if typ == 'TXM' :return 1 + return 0 + + def waitTuple(self): + for ss_type in self.definition.type: + if repr(ss_type).find('Tuple') != -1 : + return 1 + return 0 + + + def getListeValeurs(self): + """ + """ + if self.valeur == None: + return [] + elif type(self.valeur) == tuple: + return list(self.valeur) + elif type(self.valeur) == list: + return self.valeur + else: + return [self.valeur] + + def isOblig(self): + return self.definition.statut=='o' + + def isImmuable(self): + return self.definition.homo=='constant' + + def isInformation(self): + return self.definition.homo=='information' + + + + def validVal(self,valeur): + """ + Verifie que la valeur passee en argument (valeur) est valide + sans modifier la valeur courante + """ + lval=listProto.adapt(valeur) + if lval is None: + valid=0 + mess=tr("None n'est pas une valeur autorisee") + else: + try: + for val in lval: + self.typeProto.adapt(val) + self.intoProto.adapt(val) + self.cardProto.adapt(lval) + if self.definition.validators: + self.definition.validators.convert(lval) + valid,mess=1,"" + except ValError as e: + mess=str(e) + valid=0 + return valid,mess + + def validValeur(self,new_valeur): + """ + Verifie que la valeur passee en argument (new_valeur) est valide + sans modifier la valeur courante (evite d'utiliser setValeur et est plus performant) + """ + validite,mess=self.validVal(new_valeur) + return validite + + def validValeurPartielle(self,new_valeur): + """ + Verifie que la valeur passee en argument (new_valeur) est une liste partiellement valide + sans modifier la valeur courante du mot cle + """ + validite=1 + try: + for val in new_valeur: self.typeProto.adapt(val) self.intoProto.adapt(val) - self.cardProto.adapt(lval) - if self.definition.validators: - self.definition.validators.convert(lval) - valid,mess=1,"" - except ValError as e: - mess=str(e) - valid=0 - return valid,mess - - def validValeur(self,new_valeur): - """ - Verifie que la valeur passee en argument (new_valeur) est valide - sans modifier la valeur courante (evite d'utiliser setValeur et est plus performant) - """ - validite,mess=self.validVal(new_valeur) - return validite - - def validValeurPartielle(self,new_valeur): - """ - Verifie que la valeur passee en argument (new_valeur) est une liste partiellement valide - sans modifier la valeur courante du mot cle - """ - validite=1 - try: - for val in new_valeur: - self.typeProto.adapt(val) - self.intoProto.adapt(val) - #on ne verifie pas la cardinalite - if self.definition.validators: - validite=self.definition.validators.valideListePartielle(new_valeur) - except ValError as e: - validite=0 - - return validite - - def updateConditionBloc(self): - """ Met a jour les blocs conditionnels dependant du mot cle simple self - """ - if self.definition.position == 'global' : - self.etape.deepUpdateConditionBloc() - elif self.definition.position == 'reCalculeEtape' : - self.etape.deepUpdateConditionBloc() - self.etape.demandeRedessine() - elif self.definition.position == 'global_jdc' : - self.jdc.deepUpdateConditionBloc(self) - self.etape.demandeRedessine() - elif self.definition.position == 'inGetAttribut' : - self.jdc.deepUpdateConditionBloc(self) - else: - self.parent.updateConditionBloc() - - def setValeur(self,new_valeur,evaluation='oui'): - self.initModif() - self.valeur = new_valeur - self.val = new_valeur - if self.valeur and self.waitUserAssd() and not(self.waitUserAssdOrAssdMultipleEnCreation()) : - if type(self.valeur) in (list,tuple): - for v in self.valeur : v.ajoutUtilisePar(self) - else : self.valeur.ajoutUtilisePar(self) - if self.isValid():self.setValeurObjPyxb(new_valeur) - self.updateConditionBloc() - if self.definition.metAJour != None : self.updateAutresMotsClefs() - self.etape.modified() - self.finModif() - return 1 - - def evalValeur(self,new_valeur): - """ - Essaie d'evaluer new_valeur comme une SD, une declaration Python - ou un EVAL: Retourne la valeur evaluee (ou None) et le test de reussite (1 ou 0) - """ - sd = self.jdc.getSdAvantEtape(new_valeur,self.etape) - #sd = self.jdc.getContexteAvant(self.etape).get(new_valeur,None) - if sd is not None: - return sd,1 - lsd = self.jdc.chercheListAvant(self.etape,new_valeur) - if lsd : - return lsd,1 - else: - d={} - # On veut EVAL avec tous ses comportements. On utilise Accas. Perfs ?? - d['EVAL']=Accas.EVAL - try : - objet = eval(new_valeur,d) - return objet,1 - except Exception: - itparam=self.chercheItemParametre(new_valeur) - if itparam: - return itparam,1 - try : - object=eval(new_valeur.valeur,d) - except : - pass - if CONTEXT.debug : traceback.print_exc() - return None,0 - - def evalVal(self,new_valeur): - """ - Tente d'evaluer new_valeur comme un objet du jdc (par appel a evalValItem) - ou comme une liste de ces memes objets - Si new_valeur contient au moins un separateur (,), tente l'evaluation sur - la chaine splittee - """ - if new_valeur in ('True','False') and 'TXM' in self.definition.type : - valeur=self.evalValItem(str(new_valeur)) - return new_valeur - if type(new_valeur) in (list,tuple): - valeurretour=[] - for item in new_valeur : - valeurretour.append(self.evalValItem(item)) - return valeurretour - else: - valeur=self.evalValItem(new_valeur) - return valeur - - def evalValItem(self,new_valeur): - """ - Tente d'evaluer new_valeur comme un concept, un parametre, un objet Python ou un UserASSD - Si c'est impossible retourne new_valeur inchange - argument new_valeur : string (nom de concept, de parametre, expression ou simple chaine) - """ - - if new_valeur in list(self.jdc.sdsDict.keys()) and self.waitUserAssd(): - valeur=self.jdc.sdsDict[new_valeur] - return valeur - elif self.etape and self.etape.parent: - valeur=self.etape.parent.evalInContext(new_valeur,self.etape) - return valeur - else: - try : - valeur = eval(val) - return valeur - except: - #traceback.print_exc() - return new_valeur - pass - - def chercheItemParametre (self,new_valeur): + #on ne verifie pas la cardinalite + if self.definition.validators: + validite=self.definition.validators.valideListePartielle(new_valeur) + except ValError as e: + validite=0 + + return validite + + def updateConditionBloc(self): + """ Met a jour les blocs conditionnels dependant du mot cle simple self + """ + if self.definition.position == 'global' : + self.etape.deepUpdateConditionBloc() + elif self.definition.position == 'reCalculeEtape' : + self.etape.deepUpdateConditionBloc() + self.etape.demandeRedessine() + elif self.definition.position == 'global_jdc' : + self.jdc.deepUpdateConditionBloc(self) + self.etape.demandeRedessine() + elif self.definition.position == 'inGetAttribut' : + self.jdc.deepUpdateConditionBloc(self) + else: + self.parent.updateConditionBloc() + + def setValeur(self,new_valeur,evaluation='oui'): + self.initModif() + self.valeur = new_valeur + self.val = new_valeur + if self.valeur and self.waitUserAssd() and not(self.waitUserAssdOrAssdMultipleEnCreation()) : + if type(self.valeur) in (list,tuple): + for v in self.valeur : v.ajoutUtilisePar(self) + else : self.valeur.ajoutUtilisePar(self) + if self.isValid() and hasattr(self, 'objPyxb') and self.objPyxb : self.setValeurObjPyxb(new_valeur) + self.updateConditionBloc() + if self.definition.metAJour != None : self.updateAutresMotsClefs() + self.etape.modified() + self.finModif() + return 1 + + def evalValeur(self,new_valeur): + """ + Essaie d'evaluer new_valeur comme une SD, une declaration Python + ou un EVAL: Retourne la valeur evaluee (ou None) et le test de reussite (1 ou 0) + """ + sd = self.jdc.getSdAvantEtape(new_valeur,self.etape) + #sd = self.jdc.getContexteAvant(self.etape).get(new_valeur,None) + if sd is not None: + return sd,1 + lsd = self.jdc.chercheListAvant(self.etape,new_valeur) + if lsd : + return lsd,1 + else: + d={} + # On veut EVAL avec tous ses comportements. On utilise Accas. Perfs ?? + d['EVAL']=Accas.EVAL + try : + objet = eval(new_valeur,d) + return objet,1 + except Exception: + itparam=self.chercheItemParametre(new_valeur) + if itparam: + return itparam,1 + try : + object=eval(new_valeur.valeur,d) + except : + pass + if CONTEXT.debug : traceback.print_exc() + return None,0 + + def evalVal(self,new_valeur): + """ + Tente d'evaluer new_valeur comme un objet du jdc (par appel a evalValItem) + ou comme une liste de ces memes objets + Si new_valeur contient au moins un separateur (,), tente l'evaluation sur + la chaine splittee + """ + if new_valeur in ('True','False') and 'TXM' in self.definition.type : + valeur=self.evalValItem(str(new_valeur)) + return new_valeur + if type(new_valeur) in (list,tuple): + valeurretour=[] + for item in new_valeur : + valeurretour.append(self.evalValItem(item)) + return valeurretour + else: + valeur=self.evalValItem(new_valeur) + return valeur + + def evalValItem(self,new_valeur): + """ + Tente d'evaluer new_valeur comme un concept, un parametre, un objet Python ou un UserASSD + Si c'est impossible retourne new_valeur inchange + argument new_valeur : string (nom de concept, de parametre, expression ou simple chaine) + """ + + if new_valeur in list(self.jdc.sdsDict.keys()) and self.waitUserAssd(): + valeur=self.jdc.sdsDict[new_valeur] + return valeur + elif self.etape and self.etape.parent: + valeur=self.etape.parent.evalInContext(new_valeur,self.etape) + return valeur + else: + try : + valeur = eval(val) + return valeur + except: + #traceback.print_exc() + return new_valeur + pass + + def chercheItemParametre (self,new_valeur): try: - nomparam=new_valeur[0:new_valeur.find("[")] - indice=new_valeur[new_valeur.find(u"[")+1:new_valeur.find(u"]")] - for p in self.jdc.params: - if p.nom == nomparam : - if int(indice) < len(p.getValeurs()): - itparam=parametre.ITEM_PARAMETRE(p,int(indice)) - return itparam - return None + nomparam=new_valeur[0:new_valeur.find("[")] + indice=new_valeur[new_valeur.find(u"[")+1:new_valeur.find(u"]")] + for p in self.jdc.params: + if p.nom == nomparam : + if int(indice) < len(p.getValeurs()): + itparam=parametre.ITEM_PARAMETRE(p,int(indice)) + return itparam + return None except: - return None - - def updateConcept(self,sd): - if not self.waitAssd() : return - if type(self.valeur) in (list,tuple) : - if sd in self.valeur: - #if self.objPyxb : - newVal=[] - for v in self.valeur : newVal.append(v.nom) - self.setValeurObjPyxb(newVal) - self.initModif() - self.finModif() - else: - if sd == self.valeur: - self.setValeurObjPyxb(sd.nom) - self.initModif() - self.finModif() - - def deleteConcept(self,sd): - """ - Inputs : - - sd=concept detruit - Fonction : - Met a jour la valeur du mot cle simple suite a la disparition - du concept sd - Attention aux matrices - """ + return None + + def updateConcept(self,sd): + if not self.waitAssd() : return + if type(self.valeur) in (list,tuple) : + if sd in self.valeur: + newVal=[] + for v in self.valeur : newVal.append(v.nom) + self.initModif() + if hasattr(self, 'objPyxb') and self.objPyxb : self.setValeurObjPyxb(newVal) + self.finModif() + else: + if sd == self.valeur: + self.initModif() + if hasattr(self, 'objPyxb') and self.objPyxb : self.setValeurObjPyxb(sd.nom) + self.finModif() + + def deleteConcept(self,sd): + """ + Inputs : + - sd=concept detruit + Fonction : + Met a jour la valeur du mot cle simple suite a la disparition + du concept sd + Attention aux matrices + """ ##PNPNPN a tester - if type(self.valeur) == tuple : - if sd in self.valeur: - self.initModif() - self.valeur=list(self.valeur) - while sd in self.valeur : self.valeur.remove(sd) - if self.objPyxb : - newVal=[] - for v in self.valeur : newVal.append(v.nom) - if newVal == [] : self.delObjPyxb() - else : self.setValeurObjPyxb(sd.nom) - self.finModif() - elif type(self.valeur) == list: - if sd in self.valeur: - self.initModif() - while sd in self.valeur : self.valeur.remove(sd) - self.finModif() - else: - if self.valeur == sd: - self.initModif() - self.valeur=None - self.val=None - if self.objPyxb : self.setValeurObjPyxb() - self.finModif() - # Glut Horrible pour les matrices OT ??? - #if sd.__class__.__name__== "variable": - # for type_permis in self.definition.type: - #if type(type_permis) == types.InstanceType: - # a voir en python 3 - # if type_permis.__class__.__name__ == 'Matrice' : - # self.state="changed" - # self.isValid() - - - def replaceConcept(self,old_sd,sd): - """ - Inputs : - - old_sd=concept remplace - - sd=nouveau concept - Fonction : - Met a jour la valeur du mot cle simple suite au remplacement - du concept old_sd - """ - #print ("replaceConcept",old_sd,sd) - if type(self.valeur) == tuple : - if old_sd in self.valeur: - self.initModif() - self.valeur=list(self.valeur) - i=self.valeur.index(old_sd) - self.valeur[i]=sd - self.finModif() - elif type(self.valeur) == list: - if old_sd in self.valeur: + if type(self.valeur) == tuple : + if sd in self.valeur: + self.initModif() + self.valeur=list(self.valeur) + while sd in self.valeur : self.valeur.remove(sd) + if hasattr(self, 'objPyxb') and self.objPyxb : + newVal=[] + for v in self.valeur : newVal.append(v.nom) + if newVal == [] : self.delObjPyxb() + else : self.setValeurObjPyxb(sd.nom) + self.finModif() + elif type(self.valeur) == list: + if sd in self.valeur: + self.initModif() + while sd in self.valeur : self.valeur.remove(sd) + self.finModif() + else: + if self.valeur == sd: + self.initModif() + self.valeur=None + self.val=None + if hasattr(self, 'objPyxb') and self.objPyxb : self.setValeurObjPyxb() + self.finModif() + # Glut Horrible pour les matrices OT ??? + #if sd.__class__.__name__== "variable": + # for type_permis in self.definition.type: + #if type(type_permis) == types.InstanceType: + # a voir en python 3 + # if type_permis.__class__.__name__ == 'Matrice' : + # self.state="changed" + # self.isValid() + + + def replaceConcept(self,old_sd,sd): + """ + Inputs : + - old_sd=concept remplace + - sd=nouveau concept + Fonction : + Met a jour la valeur du mot cle simple suite au remplacement + du concept old_sd + """ + #print ("replaceConcept",old_sd,sd) + if type(self.valeur) == tuple : + if old_sd in self.valeur: + self.initModif() + self.valeur=list(self.valeur) + i=self.valeur.index(old_sd) + self.valeur[i]=sd + self.finModif() + elif type(self.valeur) == list: + if old_sd in self.valeur: + self.initModif() + i=self.valeur.index(old_sd) + self.valeur[i]=sd + self.finModif() + else: + if self.valeur == old_sd: + self.initModif() + self.valeur=sd + self.val=sd + self.finModif() + + def setValeurCo(self,nomCO): + """ + Affecte a self l'objet de type CO et de nom nomCO + """ + step=self.etape.parent + if nomCO == None or nomCO == '': + new_objet=None + else: + # Avant de creer un concept il faut s'assurer du contexte : step + # courant + sd= step.getSdAutourEtape(nomCO,self.etape,avec='oui') + if sd: + # Si un concept du meme nom existe deja dans la portee de l'etape + # on ne cree pas le concept + return 0,tr("un concept de meme nom existe deja") + # Il n'existe pas de concept de meme nom. On peut donc le creer + # Il faut neanmoins que la methode NommerSdProd de step gere les + # contextes en mode editeur + # Normalement la methode du Noyau doit etre surchargee + # On declare l'etape du mot cle comme etape courante pour nommerSDProd + cs= CONTEXT.getCurrentStep() + CONTEXT.unsetCurrentStep() + CONTEXT.setCurrentStep(step) + step.setEtapeContext(self.etape) + new_objet = Accas.CO(nomCO) + CONTEXT.unsetCurrentStep() + CONTEXT.setCurrentStep(cs) self.initModif() - i=self.valeur.index(old_sd) - self.valeur[i]=sd - self.finModif() - else: - if self.valeur == old_sd: - self.initModif() - self.valeur=sd - self.val=sd + self.valeur = new_objet + self.val = new_objet + # On force l'enregistrement de new_objet en tant que concept produit + # de la macro en appelant getType_produit avec force=1 + self.etape.getType_produit(force=1) self.finModif() + step.resetContext() + #print "setValeurCo",new_objet + return 1,tr("Concept cree") + + def verifExistenceSd(self): + """ + Verifie que les structures de donnees utilisees dans self existent bien dans le contexte + avant etape, sinon enleve la referea ces concepts + """ + #print "verifExistenceSd" + # Attention : possible probleme avec include + # A priori il n'y a pas de raison de retirer les concepts non existants + # avant etape. En fait il s'agit uniquement eventuellement de ceux crees par une macro + l_sd_avant_etape = list(self.jdc.getContexteAvant(self.etape).values()) + if type(self.valeur) in (tuple,list) : + l=[] + for sd in self.valeur: + if isinstance(sd,ASSD) : + if sd in l_sd_avant_etape or self.etape.getSdprods(sd.nom) is sd: + l.append(sd) + else: + l.append(sd) + if len(l) < len(self.valeur): + self.initModif() + self.valeur=tuple(l) + self.finModif() + else: + if isinstance(self.valeur,ASSD) : + if self.valeur not in l_sd_avant_etape and self.etape.getSdprods(self.valeur.nom) is None: + self.initModif() + self.valeur = None + self.finModif() + + def renommeSdCree(self,nouveauNom): + if nouveauNom in self.jdc.sdsDict : return (0, 'concept deja existant') + if self.valeur == None : return (0, 'pb sur la valeur') + else : self.valeur.renomme(nouveauNom) + return (1, 'concept renomme') + + def renommeSdCreeDsListe(self,objASSD, nouveauNom): + #print ( 'dans renommeSdCree', self.jdc.sdsDict, self.valeur, nouveauNom) + if nouveauNom in self.jdc.sdsDict : return (0, 'concept deja existant') + objASSD.renomme(nouveauNom) + return (1, 'concept renomme') + + + + def getMinMax(self): + """ + Retourne les valeurs min et max admissibles pour la valeur de self + """ + return self.definition.min,self.definition.max + + + def getType(self): + """ + Retourne le type attendu par le mot-cle simple + """ + return self.definition.type + + def deleteMcGlobal(self): + """ Retire self des declarations globales + """ + # on est oblige de verifier si le nom est dans etape + # car parfois l ordre des creations/destruction n est pas clair + # quand on a des blocs freres qui contiennent le meme mc global + # cas de NumericalMethod dans VIMMP + if self.definition.position == 'global' : + etape = self.getEtape() + if etape and self.nom in etape.mc_globaux: + if etape.mc_globaux[self.nom] == self : + del etape.mc_globaux[self.nom] + elif self.definition.position == 'reCalculeEtape' : + etape = self.getEtape() + if etape : + if self.nom in etape.mc_globaux: + if etape.mc_globaux[self.nom] == self : + del etape.mc_globaux[self.nom] + self.etape.doitEtreRecalculee = True + #print ('deleteMcGlobal je mets doitEtreRecalculee = True avec', self.nom ,' pour ', etape.nom) + elif self.definition.position == 'global_jdc' : + if self.nom in self.jdc.mc_globaux: + try : del self.jdc.mc_globaux[self.nom] + except : print ('!!!!!!!! Souci delete mc_globaux') + + def updateMcGlobal(self): + """ + Met a jour les mots cles globaux enregistres dans l'etape parente + et dans le jdc parent. + Un mot cle simple peut etre global. + """ + if self.definition.position == 'global' : + etape = self.getEtape() + if etape : + etape.mc_globaux[self.nom]=self + elif self.definition.position == 'reCalculeEtape' : + etape = self.getEtape() + if etape : + etape.mc_globaux[self.nom]=self + etape.doitEtreRecalculee=True + print ('je mets doitEtreRecalculee = True avec', self.nom ,' pour ', etape.nom) + print ('j ajoute au mc_globaux') + elif self.definition.position == 'global_jdc' : + if self.jdc: + self.jdc.mc_globaux[self.nom]=self + + def nbrColonnes(self): + genea = self.getGenealogie() + if "VALE_C" in genea and "DEFI_FONCTION" in genea : return 3 + if "VALE" in genea and "DEFI_FONCTION" in genea : return 2 + return 0 + + def valideItem(self,item): + """Valide un item isole. Cet item est candidata l'ajout a la liste existante""" + valid=1 + try: + #on verifie le type + self.typeProto.adapt(item) + #on verifie les choix possibles + self.intoProto.adapt(item) + #on ne verifie pas la cardinalite + if self.definition.validators: + valid=self.definition.validators.verifItem(item) + except ValError as e: + #traceback.print_exc() + valid=0 + return valid - def setValeurCo(self,nomCO): - """ - Affecte a self l'objet de type CO et de nom nomCO - """ - step=self.etape.parent - if nomCO == None or nomCO == '': - new_objet=None - else: - # Avant de creer un concept il faut s'assurer du contexte : step - # courant - sd= step.getSdAutourEtape(nomCO,self.etape,avec='oui') - if sd: - # Si un concept du meme nom existe deja dans la portee de l'etape - # on ne cree pas le concept - return 0,tr("un concept de meme nom existe deja") - # Il n'existe pas de concept de meme nom. On peut donc le creer - # Il faut neanmoins que la methode NommerSdProd de step gere les - # contextes en mode editeur - # Normalement la methode du Noyau doit etre surchargee - # On declare l'etape du mot cle comme etape courante pour nommerSDProd - cs= CONTEXT.getCurrentStep() - CONTEXT.unsetCurrentStep() - CONTEXT.setCurrentStep(step) - step.setEtapeContext(self.etape) - new_objet = Accas.CO(nomCO) - CONTEXT.unsetCurrentStep() - CONTEXT.setCurrentStep(cs) - self.initModif() - self.valeur = new_objet - self.val = new_objet - # On force l'enregistrement de new_objet en tant que concept produit - # de la macro en appelant getType_produit avec force=1 - self.etape.getType_produit(force=1) - self.finModif() - step.resetContext() - #print "setValeurCo",new_objet - return 1,tr("Concept cree") - - def verifExistenceSd(self): - """ - Verifie que les structures de donnees utilisees dans self existent bien dans le contexte - avant etape, sinon enleve la referea ces concepts - """ - #print "verifExistenceSd" - # Attention : possible probleme avec include - # A priori il n'y a pas de raison de retirer les concepts non existants - # avant etape. En fait il s'agit uniquement eventuellement de ceux crees par une macro - l_sd_avant_etape = list(self.jdc.getContexteAvant(self.etape).values()) - if type(self.valeur) in (tuple,list) : - l=[] - for sd in self.valeur: - if isinstance(sd,ASSD) : - if sd in l_sd_avant_etape or self.etape.getSdprods(sd.nom) is sd: - l.append(sd) - else: - l.append(sd) - if len(l) < len(self.valeur): - self.initModif() - self.valeur=tuple(l) - self.finModif() - else: - if isinstance(self.valeur,ASSD) : - if self.valeur not in l_sd_avant_etape and self.etape.getSdprods(self.valeur.nom) is None: - self.initModif() - self.valeur = None - self.finModif() - - def renommeSdCree(self,nouveauNom): - if nouveauNom in self.jdc.sdsDict : return (0, 'concept deja existant') - if self.valeur == None : return (0, 'pb sur la valeur') - else : self.valeur.renomme(nouveauNom) - return (1, 'concept renomme') - - def renommeSdCreeDsListe(self,objASSD, nouveauNom): - #print ( 'dans renommeSdCree', self.jdc.sdsDict, self.valeur, nouveauNom) - if nouveauNom in self.jdc.sdsDict : return (0, 'concept deja existant') - objASSD.renomme(nouveauNom) - return (1, 'concept renomme') - - - - def getMinMax(self): - """ - Retourne les valeurs min et max admissibles pour la valeur de self - """ - return self.definition.min,self.definition.max - - - def getType(self): - """ - Retourne le type attendu par le mot-cle simple - """ - return self.definition.type - - def deleteMcGlobal(self): - """ Retire self des declarations globales - """ - # on est oblige de verifier si le nom est dans etape - # car parfois l ordre des creations/destruction n est pas clair - # quand on a des blocs freres qui contiennent le meme mc global - # cas de NumericalMethod dans VIMMP - if self.definition.position == 'global' : - etape = self.getEtape() - if etape and self.nom in etape.mc_globaux: - if etape.mc_globaux[self.nom] == self : - del etape.mc_globaux[self.nom] - elif self.definition.position == 'reCalculeEtape' : - etape = self.getEtape() - if etape : - if self.nom in etape.mc_globaux: - if etape.mc_globaux[self.nom] == self : - del etape.mc_globaux[self.nom] - self.etape.doitEtreRecalculee = True - #print ('deleteMcGlobal je mets doitEtreRecalculee = True avec', self.nom ,' pour ', etape.nom) - elif self.definition.position == 'global_jdc' : - if self.nom in self.jdc.mc_globaux: - try : del self.jdc.mc_globaux[self.nom] - except : print ('!!!!!!!! Souci delete mc_globaux') - - def updateMcGlobal(self): - """ - Met a jour les mots cles globaux enregistres dans l'etape parente - et dans le jdc parent. - Un mot cle simple peut etre global. - """ - if self.definition.position == 'global' : - etape = self.getEtape() - if etape : - etape.mc_globaux[self.nom]=self - elif self.definition.position == 'reCalculeEtape' : - etape = self.getEtape() - if etape : - etape.mc_globaux[self.nom]=self - etape.doitEtreRecalculee=True - print ('je mets doitEtreRecalculee = True avec', self.nom ,' pour ', etape.nom) - print ('j ajoute au mc_globaux') - elif self.definition.position == 'global_jdc' : - if self.jdc: - self.jdc.mc_globaux[self.nom]=self - - def nbrColonnes(self): - genea = self.getGenealogie() - if "VALE_C" in genea and "DEFI_FONCTION" in genea : return 3 - if "VALE" in genea and "DEFI_FONCTION" in genea : return 2 - return 0 - - def valideItem(self,item): - """Valide un item isole. Cet item est candidata l'ajout a la liste existante""" - valid=1 - try: - #on verifie le type - self.typeProto.adapt(item) - #on verifie les choix possibles - self.intoProto.adapt(item) - #on ne verifie pas la cardinalite - if self.definition.validators: - valid=self.definition.validators.verifItem(item) - except ValError as e: - #traceback.print_exc() - valid=0 - return valid - - def verifType(self,item): - """Verifie le type d'un item de liste""" - try: - #on verifie le type - self.typeProto.adapt(item) - #on verifie les choix possibles - self.intoProto.adapt(item) - #on ne verifie pas la cardinalite mais on verifie les validateurs - if self.definition.validators: - valid=self.definition.validators.verifItem(item) - comment="" - valid=1 - except ValError as e: - #traceback.print_exc() - comment=tr(e.__str__()) - valid=0 - return valid,comment - - def valideMatrice(self,cr): - ok=1 - if self.valeur == None : - self.setValid(0) - return 0 - if self.monType.methodeCalculTaille != None : - MCSIMP.__dict__[self.monType.methodeCalculTaille](*(self,)) - if len(self.valeur) == self.monType.nbLigs : - for i in range(len(self.valeur)): - if len(self.valeur[i]) != self.monType.nbCols: ok=0 - if not ok : - self.setValid(0) - if cr == 'oui' : - self.cr.fatal(tr("La matrice n'est pas une matrice %(n_lign)d sur %(n_col)d", \ - {'n_lign': self.monType.nbLigs, 'n_col': self.monType.nbCols})) - return 0 - for i in range(self.monType.nbLigs): - for j in range(self.monType.nbCols): - val=self.valeur[i][j] - if self.monType.typElt == 'R' : - try : val=float(str(val)) - except : ok=0 - if self.monType.typElt == 'TXM' : - if self.monType.typEltInto != None and val not in self.monType.typEltInto : ok=0 - if not ok : - self.setValid(0) - if cr == 'oui' : - self.cr.fatal(tr("Les elements de la matrice ne sont pas d un bon type")) - return 0 - self.setValid(1) - return 1 - - - - def valideMatriceOT(self,cr): - #Attention, la matrice contient comme dernier tuple l ordre des variables - if self.valideEnteteMatrice()==False : - self.setValid(0) - if cr == "oui" : self.cr.fatal(tr("La matrice n'a pas le bon entete")) - return 0 - if self.monType.methodeCalculTaille != None : - MCSIMP.__dict__[self.monType.methodeCalculTaille](*(self,)) - try : - #if 1 : - ok=0 - if len(self.valeur) == self.monType.nbLigs +1: - ok=1 - for i in range(len(self.valeur) -1): - if len(self.valeur[i])!= self.monType.nbCols: - ok=0 - if ok: - self.setValid(1) - return 1 - except : - #else : - pass - if cr == 'oui' : - self.cr.fatal(tr("La matrice n'est pas une matrice %(n_lign)d sur %(n_col)d", \ - {'n_lign': self.monType.nbLigs, 'n_col': self.monType.nbCols})) - self.setValid(0) - return 0 - - - def nbDeVariables(self): - listeVariables=self.jdc.getVariables(self.etape) - self.monType.nbLigs=len(listeVariables) - self.monType.nbCols=len(listeVariables) - - def valideEnteteMatrice(self): - if self.jdc.getDistributions(self.etape) == () or self.valeur == None : return 0 - if self.jdc.getDistributions(self.etape) != self.valeur[0] : return 0 - return 1 - - def changeEnteteMatrice(self): - a=[self.jdc.getDistributions(self.etape),] - for t in self.valeur[1:]: - a.append(t) - self.valeur=a - - - def nbDeDistributions(self): - listeVariables=self.jdc.getDistributions(self.etape) - self.monType.nbLigs=len(listeVariables) - self.monType.nbCols=len(listeVariables) - - def getNomDsXML(self): - nomDsXML=self.parent.getNomDsXML()+"."+self.nom - return nomDsXML - - - def verifTypeIhm(self,val,cr='non'): - try : - val.eval() - return 1 - except : - traceback.print_exc() - pass - return self.verifType(val,cr) - - def verifTypeliste(self,val,cr='non') : - verif=0 - for v in val : - verif=verif+self.verifTypeIhm(v,cr) - return verif - - def initModifUp(self): - Validation.V_MCSIMP.MCSIMP.initModifUp(self) - CONNECTOR.Emit(self,"valid") - - def deleteRef(self): - if self.valeur == None or self.valeur == [] : return - if not type(self.valeur) in (list, tuple): lesValeurs=(self.valeur,) - else : lesValeurs=self.valeur - for val in lesValeurs: - if self.definition.creeDesObjets : - val.deleteReference(self) - else : - if (hasattr (val, 'enleveUtilisePar')) : val.enleveUtilisePar(self) - - def updateAutresMotsClefs(self): - print ('updateAutresMotsClefs') - for (nomMC, Xpath) in self.definition.metAJour : - exp=Xpath+'.getChild("'+nomMC+'")' - try : - lesMotsClefs = eval(exp) + def verifType(self,item): + """Verifie le type d'un item de liste""" + try: + #on verifie le type + self.typeProto.adapt(item) + #on verifie les choix possibles + self.intoProto.adapt(item) + #on ne verifie pas la cardinalite mais on verifie les validateurs + if self.definition.validators: + valid=self.definition.validators.verifItem(item) + comment="" + valid=1 + except ValError as e: + #traceback.print_exc() + comment=tr(e.__str__()) + valid=0 + return valid,comment + + def valideMatrice(self,cr): + ok=1 + if self.valeur == None : + self.setValid(0) + return 0 + if self.monType.methodeCalculTaille != None : + MCSIMP.__dict__[self.monType.methodeCalculTaille](*(self,)) + if len(self.valeur) == self.monType.nbLigs : + for i in range(len(self.valeur)): + if len(self.valeur[i]) != self.monType.nbCols: ok=0 + if not ok : + self.setValid(0) + if cr == 'oui' : + self.cr.fatal(tr("La matrice n'est pas une matrice %(n_lign)d sur %(n_col)d", \ + {'n_lign': self.monType.nbLigs, 'n_col': self.monType.nbCols})) + return 0 + for i in range(self.monType.nbLigs): + for j in range(self.monType.nbCols): + val=self.valeur[i][j] + if self.monType.typElt == 'R' : + try : val=float(str(val)) + except : ok=0 + if self.monType.typElt == 'TXM' : + if self.monType.typEltInto != None and val not in self.monType.typEltInto : ok=0 + if not ok : + self.setValid(0) + if cr == 'oui' : + self.cr.fatal(tr("Les elements de la matrice ne sont pas d un bon type")) + return 0 + self.setValid(1) + return 1 + + + + def valideMatriceOT(self,cr): + #Attention, la matrice contient comme dernier tuple l ordre des variables + if self.valideEnteteMatrice()==False : + self.setValid(0) + if cr == "oui" : self.cr.fatal(tr("La matrice n'a pas le bon entete")) + return 0 + if self.monType.methodeCalculTaille != None : + MCSIMP.__dict__[self.monType.methodeCalculTaille](*(self,)) + try : + #if 1 : + ok=0 + if len(self.valeur) == self.monType.nbLigs +1: + ok=1 + for i in range(len(self.valeur) -1): + if len(self.valeur[i])!= self.monType.nbCols: + ok=0 + if ok: + self.setValid(1) + return 1 except : - lesMotsClefs = [] - if not type(lesMotsClefs) in (list, tuple): lesMotsClefs=(lesMotsClefs,) - if isinstance (lesMotsClefs, MCSIMP): lesMotsClefs=(lesMotsClefs,) - listeEtapesDejaRedessinees=[] - listeMotsClefsAppel=[] - for leMotCle in lesMotsClefs: - leMotCle.state='changed' - if not leMotCle.isValid() : leMotCle.val=None - if leMotCle.etape not in listeEtapesDejaRedessinees : - listeEtapesDejaRedessinees.append(leMotCle.etape) - listeMotsClefsAppel.append(leMotCle) - for leMotCle in listeMotsClefsAppel: - leMotCle.demandeRedessine() - - print ('fin updateAutresMotsClefs') + #else : + pass + if cr == 'oui' : + self.cr.fatal(tr("La matrice n'est pas une matrice %(n_lign)d sur %(n_col)d", \ + {'n_lign': self.monType.nbLigs, 'n_col': self.monType.nbCols})) + self.setValid(0) + return 0 + + def nbDeVariables(self): + listeVariables=self.jdc.getVariables(self.etape) + self.monType.nbLigs=len(listeVariables) + self.monType.nbCols=len(listeVariables) + + def valideEnteteMatrice(self): + if self.jdc.getDistributions(self.etape) == () or self.valeur == None : return 0 + if self.jdc.getDistributions(self.etape) != self.valeur[0] : return 0 + return 1 + + def changeEnteteMatrice(self): + a=[self.jdc.getDistributions(self.etape),] + for t in self.valeur[1:]: + a.append(t) + self.valeur=a + + + def nbDeDistributions(self): + listeVariables=self.jdc.getDistributions(self.etape) + self.monType.nbLigs=len(listeVariables) + self.monType.nbCols=len(listeVariables) + + def getNomDsXML(self): + nomDsXML=self.parent.getNomDsXML()+"."+self.nom + return nomDsXML + + + def verifTypeIhm(self,val,cr='non'): + try : + val.eval() + return 1 + except : + traceback.print_exc() + pass + return self.verifType(val,cr) + + def verifTypeliste(self,val,cr='non') : + verif=0 + for v in val : + verif=verif+self.verifTypeIhm(v,cr) + return verif + + def initModifUp(self): + Validation.V_MCSIMP.MCSIMP.initModifUp(self) + CONNECTOR.Emit(self,"valid") + + def deleteRef(self): + if self.valeur == None or self.valeur == [] : return + if not type(self.valeur) in (list, tuple): lesValeurs=(self.valeur,) + else : lesValeurs=self.valeur + for val in lesValeurs: + if self.definition.creeDesObjets : + val.deleteReference(self) + else : + if (hasattr (val, 'enleveUtilisePar')) : val.enleveUtilisePar(self) + + def updateAutresMotsClefs(self): + print ('updateAutresMotsClefs') + for (nomMC, Xpath) in self.definition.metAJour : + exp=Xpath+'.getChild("'+nomMC+'")' + try : + lesMotsClefs = eval(exp) + except : + lesMotsClefs = [] + if not type(lesMotsClefs) in (list, tuple): lesMotsClefs=(lesMotsClefs,) + if isinstance (lesMotsClefs, MCSIMP): lesMotsClefs=(lesMotsClefs,) + listeEtapesDejaRedessinees=[] + listeMotsClefsAppel=[] + for leMotCle in lesMotsClefs: + leMotCle.state='changed' + if not leMotCle.isValid() : leMotCle.val=None + if leMotCle.etape not in listeEtapesDejaRedessinees : + listeEtapesDejaRedessinees.append(leMotCle.etape) + listeMotsClefsAppel.append(leMotCle) + for leMotCle in listeMotsClefsAppel: + leMotCle.demandeRedessine() + + print ('fin updateAutresMotsClefs') diff --git a/Ihm/I_OBJECT.py b/Ihm/I_OBJECT.py index e53df63e..75b7d051 100644 --- a/Ihm/I_OBJECT.py +++ b/Ihm/I_OBJECT.py @@ -27,174 +27,173 @@ import re conceptRE=re.compile(r'[a-zA-Z_]\w*$') class OBJECT: - from Noyau.N_CO import CO - from Noyau.N_ASSD import assd - - def isMCList(self): - """ - Retourne 1 si self est une MCList (liste de mots-cles), 0 sinon (defaut) - """ - return 0 - - def getRegles(self): - """ - Retourne les regles de self - """ - if hasattr(self,'definition'): - return self.definition.regles - elif hasattr(self,'regles'): - return self.regles - else : - return [] - - def initModif(self): - """ - Met l'etat de l'objet a modified et propage au parent - qui vaut None s'il n'existe pas - """ - self.state = 'modified' - if self.parent: - self.parent.initModif() - - def finModif(self): - """ - Methode appelee apres qu'une modification a ete faite afin de declencher - d'eventuels traitements post-modification - """ - #print "finModif",self - # pour les objets autres que les commandes, aucun traitement specifique - # on remonte l'info de fin de modif au parent - CONNECTOR.Emit(self,"valid") - if self.parent: - self.parent.finModif() - - def isRepetable(self): - """ - Indique si l'objet est repetable - """ - return 0 - - def listeMcPresents(self): - """ - Retourne la liste des noms des mots cles presents - """ - return [] - - def getDocu(self): - return self.definition.getDocu() - - def getListeMcInconnus(self): - """ - Retourne la liste des mots-cles inconnus dans self - """ - return [] - - def verifConditionRegles(self,liste_presents): - """ - Retourne la liste des mots-cles a rajouter pour satisfaire les regles - en fonction de la liste des mots-cles presents - """ - liste=[] - for regle in self.definition.regles: - liste=regle.verifConditionRegle(liste,liste_presents) - return liste - - def verifConditionBloc(self): - """ - Evalue les conditions de tous les blocs fils possibles - (en fonction du catalogue donc de la definition) de self et - retourne deux listes : - - la premiere contient les noms des blocs a rajouter - - la seconde contient les noms des blocs a supprimer - """ - return [],[] - - def getGenealogiePrecise(self): - if self.parent: - l=self.parent.getGenealogiePrecise() - l.append(self.nom.strip()) - return l - else: - return [self.nom.strip()] - - - def getGenealogie(self): - """ - Retourne la liste des noms des ascendants (noms de MCSIMP,MCFACT,MCBLOC - ou ETAPE) de self jusqu'au premier objet etape rencontre - """ - if self.parent: - l=self.parent.getGenealogie() - l.append(self.nom.strip()) - return l - else: - return [self.nom.strip()] - - def getFr(self): - """ - Retourne la chaine d'aide contenue dans le catalogue - en tenant compte de la langue - """ - try: - #if 1 : - c=getattr(self.definition,self.jdc.lang) - return c - except: - #else: - try : - c=getattr(self.definition,"fr") + from Noyau.N_CO import CO + from Noyau.N_ASSD import assd + + def isMCList(self): + """ + Retourne 1 si self est une MCList (liste de mots-cles), 0 sinon (defaut) + """ + return 0 + + def getRegles(self): + """ + Retourne les regles de self + """ + if hasattr(self,'definition'): + return self.definition.regles + elif hasattr(self,'regles'): + return self.regles + else : + return [] + + def initModif(self): + """ + Met l'etat de l'objet a modified et propage au parent + qui vaut None s'il n'existe pas + """ + self.state = 'modified' + if self.parent: + self.parent.initModif() + + def finModif(self): + """ + Methode appelee apres qu'une modification a ete faite afin de declencher + d'eventuels traitements post-modification + """ + #print "finModif",self + # pour les objets autres que les commandes, aucun traitement specifique + # on remonte l'info de fin de modif au parent + CONNECTOR.Emit(self,"valid") + if self.parent: + self.parent.finModif() + + def isRepetable(self): + """ + Indique si l'objet est repetable + """ + return 0 + + def listeMcPresents(self): + """ + Retourne la liste des noms des mots cles presents + """ + return [] + + def getDocu(self): + return self.definition.getDocu() + + def getListeMcInconnus(self): + """ + Retourne la liste des mots-cles inconnus dans self + """ + return [] + + def verifConditionRegles(self,liste_presents): + """ + Retourne la liste des mots-cles a rajouter pour satisfaire les regles + en fonction de la liste des mots-cles presents + """ + liste=[] + for regle in self.definition.regles: + liste=regle.verifConditionRegle(liste,liste_presents) + return liste + + def verifConditionBloc(self): + """ + Evalue les conditions de tous les blocs fils possibles + (en fonction du catalogue donc de la definition) de self et + retourne deux listes : + - la premiere contient les noms des blocs a rajouter + - la seconde contient les noms des blocs a supprimer + """ + return [],[] + + def getGenealogiePrecise(self): + if self.parent: + l=self.parent.getGenealogiePrecise() + l.append(self.nom.strip()) + return l + else: + return [self.nom.strip()] + + + def getGenealogie(self): + """ + Retourne la liste des noms des ascendants (noms de MCSIMP,MCFACT,MCBLOC + ou ETAPE) de self jusqu'au premier objet etape rencontre + """ + if self.parent: + l=self.parent.getGenealogie() + l.append(self.nom.strip()) + return l + else: + return [self.nom.strip()] + + def getFr(self): + """ + Retourne la chaine d'aide contenue dans le catalogue + en tenant compte de la langue + """ + try: + #if 1 : + c=getattr(self.definition,self.jdc.lang) return c - except : - return '' + except: + #else: + try : + c=getattr(self.definition,"fr") + return c + except : + return '' - def updateConcept(self,sd): - pass + def updateConcept(self,sd): + pass - def normalize(self): - """ Retourne l'objet normalise. En general self sauf si - pour etre insere dans l'objet pere il doit etre - wrappe dans un autre objet (voir mot cle facteur). - """ - return self + def normalize(self): + """ Retourne l'objet normalise. En general self sauf si + pour etre insere dans l'objet pere il doit etre + wrappe dans un autre objet (voir mot cle facteur). + """ + return self - def deleteMcGlobal(self): - return + def deleteMcGlobal(self): + return - def updateMcGlobal(self): - return + def updateMcGlobal(self): + return - #def __del__(self): - # print "__del__",self + #def __del__(self): + # print "__del__",self - def nommeSd(self): - # surcharge dans I_ETAPE.py - if ( nom in dir(self.jdc.cata)) : return (0, nom + tr("mot reserve")) - if not conceptRE.match(nom): - return 0, tr("Un nom de concept doit etre un identificateur Python") - self.initModif() - #self.getSdProd() - #self.sd.nom = nom - #self.sdnom=nom - #self.parent.updateConceptAfterEtape(self,self.sd) - #self.finModif() - #return 1, tr("Nommage du concept effectue") + def nommeSd(self): + # surcharge dans I_ETAPE.py + if ( nom in dir(self.jdc.cata)) : return (0, nom + tr("mot reserve")) + if not conceptRE.match(nom): + return 0, tr("Un nom de concept doit etre un identificateur Python") + self.initModif() + #self.getSdProd() + #self.sd.nom = nom + #self.sdnom=nom + #self.parent.updateConceptAfterEtape(self,self.sd) + #self.finModif() + #return 1, tr("Nommage du concept effectue") - def deleteRef(self): - # est surcharge dans MC_SIMP et dans MC_List - #print ('je suis dans deleteRef pour', self.nom) - for obj in (self.mcListe): - obj.deleteRef() + def deleteRef(self): + # est surcharge dans MC_SIMP et dans MC_List + #print ('je suis dans deleteRef pour', self.nom) + for obj in (self.mcListe): + obj.deleteRef() - def supprimeUserAssd(self): - pass + def supprimeUserAssd(self): + pass - - def demandeRedessine(self): - #print ('demandeRedessine pour', self.nom, self, tout) - CONNECTOR.Emit(self,"redessine") + def demandeRedessine(self): + #print ('demandeRedessine pour', self.nom, self, tout) + CONNECTOR.Emit(self,"redessine") -class ErrorObj(OBJECT):pass +class ErrorObj(OBJECT):pass diff --git a/Ihm/I_PRESENT_ABSENT.py b/Ihm/I_PRESENT_ABSENT.py index b4a43e46..30fa01ae 100644 --- a/Ihm/I_PRESENT_ABSENT.py +++ b/Ihm/I_PRESENT_ABSENT.py @@ -24,14 +24,13 @@ from __future__ import absolute_import from . import I_REGLE class PRESENT_ABSENT(I_REGLE.REGLE): - def purgeListe(self,liste_a_purger,listeMcPresents): - regle_active=0 - if self.mcs[0] in listeMcPresents:regle_active=1 - if not regle_active : return liste_a_purger - - # Il ne faut pas purger le mot cle present - for mc in self.mcs[1:]: - if mc in liste_a_purger : - liste_a_purger.remove(mc) - return liste_a_purger + def purgeListe(self,liste_a_purger,listeMcPresents): + regle_active=0 + if self.mcs[0] in listeMcPresents:regle_active=1 + if not regle_active : return liste_a_purger + # Il ne faut pas purger le mot cle present + for mc in self.mcs[1:]: + if mc in liste_a_purger : + liste_a_purger.remove(mc) + return liste_a_purger diff --git a/Ihm/I_PRESENT_PRESENT.py b/Ihm/I_PRESENT_PRESENT.py index a6f1ba06..b4a3a80d 100644 --- a/Ihm/I_PRESENT_PRESENT.py +++ b/Ihm/I_PRESENT_PRESENT.py @@ -24,14 +24,12 @@ from __future__ import absolute_import from . import I_REGLE class PRESENT_PRESENT(I_REGLE.REGLE): - def verifConditionRegle(self,liste,l_mc_presents): - mc0=self.mcs[0] - for mc_present in l_mc_presents: - if mc_present == mc0 : - for mc in self.mcs[1:]: - nb = l_mc_presents.count(mc) - if nb == 0 : liste.append(mc) + def verifConditionRegle(self,liste,l_mc_presents): + mc0=self.mcs[0] + for mc_present in l_mc_presents: + if mc_present == mc0 : + for mc in self.mcs[1:]: + nb = l_mc_presents.count(mc) + if nb == 0 : liste.append(mc) + return liste return liste - return liste - - diff --git a/Ihm/I_PROC_ETAPE.py b/Ihm/I_PROC_ETAPE.py index 4b46b592..b95918a4 100644 --- a/Ihm/I_PROC_ETAPE.py +++ b/Ihm/I_PROC_ETAPE.py @@ -30,66 +30,65 @@ from Noyau.N_Exception import AsException from Extensions.eficas_exception import EficasException class PROC_ETAPE(I_ETAPE.ETAPE): - def getSdname(self): - return "" + def getSdname(self): + return "" - def getSdprods(self,nom_sd): - """ - Fonction : retourne le concept produit par l etape de nom nom_sd - s il existe sinon None - Une PROC ne produit aucun concept - """ - return None + def getSdprods(self,nom_sd): + """ + Fonction : retourne le concept produit par l etape de nom nom_sd + s il existe sinon None + Une PROC ne produit aucun concept + """ + return None - def supprimeSdProds(self): - """ - Fonction: Lors d'une destruction d'etape, detruit tous les concepts produits - Une procedure n'en a aucun - """ - return + def supprimeSdProds(self): + """ + Fonction: Lors d'une destruction d'etape, detruit tous les concepts produits + Une procedure n'en a aucun + """ + return - def deleteConcept(self,sd): - """ - Fonction : Mettre a jour les mots cles de l etape - suite a la disparition du concept sd - Seuls les mots cles simples MCSIMP font un traitement autre - que de transmettre aux fils + def deleteConcept(self,sd): + """ + Fonction : Mettre a jour les mots cles de l etape + suite a la disparition du concept sd + Seuls les mots cles simples MCSIMP font un traitement autre + que de transmettre aux fils - Inputs : - - sd=concept detruit - """ - for child in self.mcListe : - child.deleteConcept(sd) + Inputs : + - sd=concept detruit + """ + for child in self.mcListe : + child.deleteConcept(sd) - def replaceConcept(self,old_sd,sd): - """ - Fonction : Mettre a jour les mots cles de l etape - suite au remplacement du concept old_sd + def replaceConcept(self,old_sd,sd): + """ + Fonction : Mettre a jour les mots cles de l etape + suite au remplacement du concept old_sd - Inputs : - - old_sd=concept remplace - - sd=nouveau concept - """ - for child in self.mcListe : - child.replaceConcept(old_sd,sd) + Inputs : + - old_sd=concept remplace + - sd=nouveau concept + """ + for child in self.mcListe : + child.replaceConcept(old_sd,sd) #ATTENTION SURCHARGE: a garder en synchro ou a reintegrer dans le Noyau - def buildSd(self): - """ - Methode de Noyau surchargee pour poursuivre malgre tout - si une erreur se produit pendant la creation du concept produit - """ - try: - sd=Noyau.N_PROC_ETAPE.PROC_ETAPE.buildSd(self) - except AsException : - # 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 possibilites : - # 1. on annule la sd associee a self - # 2. on la conserve mais il faut la retourner - # En plus il faut rendre coherents sdnom et sd.nom - self.sd=None - self.sdnom=None - self.state="unchanged" - self.valid=0 - + def buildSd(self): + """ + Methode de Noyau surchargee pour poursuivre malgre tout + si une erreur se produit pendant la creation du concept produit + """ + try: + sd=Noyau.N_PROC_ETAPE.PROC_ETAPE.buildSd(self) + except AsException : + # 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 possibilites : + # 1. on annule la sd associee a self + # 2. on la conserve mais il faut la retourner + # En plus il faut rendre coherents sdnom et sd.nom + self.sd=None + self.sdnom=None + self.state="unchanged" + self.valid=0 diff --git a/Ihm/I_REGLE.py b/Ihm/I_REGLE.py index b0f19adc..224f7627 100644 --- a/Ihm/I_REGLE.py +++ b/Ihm/I_REGLE.py @@ -23,28 +23,28 @@ from __future__ import absolute_import class REGLE: - def getText(self): - text = self.__class__.__name__+ ' :\n' - for mc in self.mcs : - text = text + '\t' + mc.strip() + '\n' - return text - - def purgeListe(self,liste_a_purger,listeMcPresents): - """ - Cette methode doit retirer de la liste liste_a_purger - les elements qui ne doivent plus apparaitre en fonction du contexte - """ - # Dans le cas general on ne touche pas a la liste - return liste_a_purger - - def hasOperande(self,nom): - # On peut faire aussi try:self.mcs.index(nom);return 1;except:return 0 - for mc in self.mcs: - if mc==nom : return 1 - return 0 - - def verifConditionRegle(self,liste,l_mc_presents): - return [] + def getText(self): + text = self.__class__.__name__+ ' :\n' + for mc in self.mcs : + text = text + '\t' + mc.strip() + '\n' + return text + + def purgeListe(self,liste_a_purger,listeMcPresents): + """ + Cette methode doit retirer de la liste liste_a_purger + les elements qui ne doivent plus apparaitre en fonction du contexte + """ + # Dans le cas general on ne touche pas a la liste + return liste_a_purger + + def hasOperande(self,nom): + # On peut faire aussi try:self.mcs.index(nom);return 1;except:return 0 + for mc in self.mcs: + if mc==nom : return 1 + return 0 + + def verifConditionRegle(self,liste,l_mc_presents): + return [] # def enregistreXML(self,root,catalogueXml): @@ -52,7 +52,6 @@ class REGLE: # regleXml=ET.SubElement(root,'regles') # txt="" # for mot in self.getText().split('\n'): -# mot.replace(' ','') +# mot.replace(' ','') # txt=txt + mot + " " # regleXml.text= txt - diff --git a/Ihm/I_UN_PARMI.py b/Ihm/I_UN_PARMI.py index 65812619..dc3abe57 100644 --- a/Ihm/I_UN_PARMI.py +++ b/Ihm/I_UN_PARMI.py @@ -25,18 +25,17 @@ from . import I_REGLE class UN_PARMI(I_REGLE.REGLE): - def purgeListe(self,liste_a_purger,listeMcPresents): - regle_active=0 - for mc_present in listeMcPresents: - if mc_present in self.mcs: - regle_active=1 - break - if not regle_active : return liste_a_purger - - # Si un des mots cles est present, on les enleve tous - # sauf celui ci - for mc in self.mcs: - if mc in liste_a_purger and mc not in listeMcPresents: - liste_a_purger.remove(mc) - return liste_a_purger + def purgeListe(self,liste_a_purger,listeMcPresents): + regle_active=0 + for mc_present in listeMcPresents: + if mc_present in self.mcs: + regle_active=1 + break + if not regle_active : return liste_a_purger + # Si un des mots cles est present, on les enleve tous + # sauf celui ci + for mc in self.mcs: + if mc in liste_a_purger and mc not in listeMcPresents: + liste_a_purger.remove(mc) + return liste_a_purger diff --git a/Ihm/I_VALIDATOR.py b/Ihm/I_VALIDATOR.py index 604feffc..2dc42fc1 100644 --- a/Ihm/I_VALIDATOR.py +++ b/Ihm/I_VALIDATOR.py @@ -22,20 +22,19 @@ from __future__ import absolute_import from Noyau.N_VALIDATOR import * class Compulsory(Compulsory): - def hasInto(self): - return 0 - def valideListePartielle(self,liste_courante=None): - return 1 + def hasInto(self): + return 0 + def valideListePartielle(self,liste_courante=None): + return 1 class OrdList(OrdList): - def valideListePartielle(self,liste_courante=None): - """ - Methode de validation de liste partielle pour le validateur OrdList - """ - try: - self.convert(liste_courante) - valid=1 - except : - valid=0 - return valid - + def valideListePartielle(self,liste_courante=None): + """ + Methode de validation de liste partielle pour le validateur OrdList + """ + try: + self.convert(liste_courante) + valid=1 + except : + valid=0 + return valid -- 2.39.2