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 :
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)
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 "<None>"
+ def __str__(self):
+ return self.getName() or "<None>"
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__)
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
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
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
# 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")
# 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
#
#
# 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'
#
# 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)
-#
+#
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
"""
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)
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
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
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
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
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):
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
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
child.valeur=mocles[k]
child.state = 'modified'
self.mcListe.append(child)
-
+
self.corps = formule[2]
self.type_retourne = formule[1]
sd = self.getSdProd()
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 :
utilise dans le corps de la fonction
"""
self.initModif()
-
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
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)
#
class LASSD:
- def __repr__(self):
- return self.getName()
+ def __repr__(self):
+ return self.getName()
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
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)
from . import I_MCCOMPO
class MCBLOC(I_MCCOMPO.MCCOMPO):
- def getNomDsXML(self):
- return self.parent.getNomDsXML()
-
-
+ def getNomDsXML(self):
+ return self.parent.getNomDsXML()
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")
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)
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
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')
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
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
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
-
-
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
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):
# regleXml=ET.SubElement(root,'regles')
# txt=""
# for mot in self.getText().split('\n'):
-# mot.replace(' ','')
+# mot.replace(' ','')
# txt=txt + mot + " "
# regleXml.text= txt
-
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
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
