# -*- coding: utf-8 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
-# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2024 EDF R&D WWW.CODE-ASTER.ORG
# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-#i -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
+# i -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
listener(cargs+args)
"""
-from __future__ import absolute_import
-from __future__ import print_function
import traceback
from copy import copy
import weakref
class ConnectorError(Exception):
pass
-class CONNECTOR:
+class CONNECTOR:
def __init__(self):
- self.connections={}
+ self.connections = {}
def Connect(self, object, channel, function, args):
- #print ("Connect",object, channel, function, args)
+ # print ("Connect",object, channel, function, args)
idx = id(object)
- #if self.connections.has_key(idx):
- if idx in self.connections :
+ # 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 :
+ # if channels.has_key(channel):
+ if channel in channels:
receivers = channels[channel]
else:
receivers = channels[channel] = []
- for funct,fargs in receivers[:]:
+ 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))
+ 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))
+ raise ConnectorError(
+ "no receivers for channel %s of %s" % (channel, object)
+ )
- for funct,fargs in receivers[:]:
+ for funct, fargs in receivers[:]:
if funct() is None:
- receivers.remove((funct,fargs))
+ receivers.remove((funct, fargs))
- for funct,fargs in receivers:
- if (function,args) == (funct(),fargs):
- 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)]
return
raise ConnectorError(
- 'receiver %s%s is not connected to channel %s of %s' \
- % (function, args, channel, object))
-
-
+ "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
+ # print "Emit",object, channel, args
try:
receivers = self.connections[id(object)][channel]
except KeyError:
return
- #print "Emit",object, channel, receivers
+ # 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()
+ func = rfunc()
if func:
- #print (func,args,fargs)
- #rint args + fargs
- #apply(func, args + fargs)
- if args + fargs == () : func()
- else : func ( args + fargs)
+ # 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))
+ if (rfunc, fargs) in receivers:
+ receivers.remove((rfunc, fargs))
except:
traceback.print_exc()
-def ref(target,callback=None):
- #if hasattr(target,"im_self"):
+
+def ref(target, callback=None):
+ # if hasattr(target,"im_self"):
# return BoundMethodWeakref(target)
- if hasattr(target,"__self__"):
+ if hasattr(target, "__self__"):
return BoundMethodWeakref(target)
else:
- return weakref.ref(target,callback)
+ 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 __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()
+ target = self.Self()
+ if not target:
+ return None
+ func = self.Func()
if func:
return func.__get__(self.Self())
-_the_connector =CONNECTOR()
+
+_the_connector = CONNECTOR()
Connect = _the_connector.Connect
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 add(self, a):
+ print(("--------------------------------add ", self, a))
def __del__(self):
print(("__del__", self))
def f(a):
print((f, a))
- a=A()
- b=B()
- c=B()
+ a = A()
+ b = B()
+ c = B()
- Connect(a,"add",b.add,())
- Connect(a,"add",b.add,())
- Connect(a,"add",c.add,())
- Connect(a,"add",f,())
+ Connect(a, "add", b.add, ())
+ Connect(a, "add", b.add, ())
+ Connect(a, "add", c.add, ())
+ Connect(a, "add", f, ())
- Emit(a,"add",1)
+ Emit(a, "add", 1)
- print ("del b")
+ print("del b")
del b
- Emit(a,"add",1)
- print ("del f")
+ Emit(a, "add", 1)
+ print("del f")
del f
- Emit(a,"add",1)
- Disconnect(a,"add",c.add,())
- Emit(a,"add",1)
+ Emit(a, "add", 1)
+ Disconnect(a, "add", c.add, ())
+ Emit(a, "add", 1)
# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
+# Copyright (C) 2007-2024 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-
-#from I_VALIDATOR import ValidException
-
-from __future__ import absolute_import
from Extensions.i18n import tr
from Extensions.eficas_exception import EficasException
from Noyau.N_VALIDATOR import ValError
+
class ASSD:
def __repr__(self):
return "concept " + self.getName() + " type " + self.__class__.__name__
class assd(ASSD):
- def __convert__(cls,valeur):
+ def __convert__(cls, valeur):
return valeur
- __convert__=classmethod(__convert__)
+
+ __convert__ = classmethod(__convert__)
+
class GEOM(ASSD):
- def __convert__(cls,valeur):
+ def __convert__(cls, valeur):
return valeur
- __convert__= classmethod(__convert__)
+
+ __convert__ = classmethod(__convert__)
+
class geom(GEOM):
pass
+
class CO(ASSD):
- def __convert__(cls,valeur):
- if hasattr(valeur,'_etape') :
+ 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__)
+ raise ValError("Pas un concept CO")
+
+ __convert__ = classmethod(__convert__)
# -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2021 EDF R&D
+# Copyright (C) 2007-2024 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-from __future__ import absolute_import
-from __future__ import print_function
-import types
-
class I_AVANT:
"""
- La regle I_AVANT verifie que l'on trouve l ordre des mots-cles
- de la regle parmi les arguments d'un JDC.
+ La regle I_AVANT verifie que l'on trouve l ordre des mots-cles
+ de la regle parmi les arguments d'un JDC.
- Ces arguments sont transmis a la regle pour validation sous la forme
- d'une liste de noms de mots-cles ou d'un dictionnaire dont
- les cles sont des noms de mots-cles.
+ Ces arguments sont transmis a la regle pour validation sous la forme
+ d'une liste de noms de mots-cles ou d'un dictionnaire dont
+ les cles sont des noms de mots-cles.
"""
- def __init__(self,*args):
- if len(args) > 2 :
- print(("Erreur a la creation de la regle A_CLASSER(",args,")"))
+ 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],)
+ self.listeAvant = args[0]
+ else:
+ self.listeAvant = (args[0],)
if type(args[1]) == tuple:
- self.listeApres=args[1]
- else :
- self.listeApres=(args[1],)
+ self.listeApres = args[1]
+ else:
+ self.listeApres = (args[1],)
- def verif(self,args):
+ 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.
+ 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
+ text = ""
+ boolListeAvant = 0
+ boolListeApres = 0
+ boolOK = 1
for nom in args:
- if nom in self.listeAvant :
- boolListeAvant=1
- if boolListeApres == 1 :
+ 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
-
+ 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 + ','
+ 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
# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
+# Copyright (C) 2007-2024 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
#
"""
"""
-
-from __future__ import absolute_import
-
from . import I_REGLE
+
class A_CLASSER(I_REGLE.REGLE):
def getText(self):
- text = 'Regle ' + self.__class__.__name__+ ' :\n'
- t=" D'abord :\n"+' '*8
+ 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
+ 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'
+ t = t + arg.strip() + " ou "
+ text = text + t[0:-4] + "\n"
return text
# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
+# Copyright (C) 2007-2024 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-from __future__ import absolute_import
-_no=0
+_no = 0
-import Accas
+
+# 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
+ 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
+ _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
+ if hasattr(self, "docu"):
+ if self.docu != "":
+ return self.docu
else:
- if hasattr(self,'pere'):
+ if hasattr(self, "pere"):
return self.pere.getDocu()
else:
return None
return None
def getSug(self):
- if hasattr(self,'sug') :
- if self.sug != "" : return self.sug
+ if hasattr(self, "sug"):
+ if self.sug != "":
+ return self.sug
return None
def checkDefinition(self, parent):
args = self.entites.copy()
mcs = set()
for nom, val in args.items():
- if val.label == 'SIMP':
+ if val.label == "SIMP":
mcs.add(nom)
- #if val.max != 1 and val.type == 'TXM':
- #print "#CMD", parent, nom
- elif val.label == 'FACT':
+ # if val.max != 1 and val.type == 'TXM':
+ # print "#CMD", parent, nom
+ elif val.label == "FACT":
val.checkDefinition(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':
+ if val.label == "BLOC":
mcbloc = val.checkDefinition(parent)
- #print "#BLOC", parent, re.sub('\s+', ' ', val.condition)
- #assert mcs.isdisjoint(mcbloc), "Commande %s : Mot(s)-clef(s) vu(s) plusieurs fois : %s" \
+ # 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 UQPossible(self):
return True
# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
+# Copyright (C) 2007-2024 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
"""
"""
# Modules Python
-from __future__ import absolute_import
-from __future__ import print_function
-import sys,re
+import sys, re
import types
from copy import copy
from Extensions.eficas_exception import EficasException
# Objet re pour controler les identificateurs Python
-conceptRE=re.compile(r'[a-zA-Z_]\w*$')
+conceptRE = re.compile(r"[a-zA-Z_]\w*$")
-# import rajoute suite a l'ajout de buildSd --> a resorber
import traceback
-import Noyau
+from Noyau import N_ETAPE
from Noyau import N_Exception
from Noyau.N_Exception import AsException
import Validation
+
# fin import a resorber
# Modules EFICAS
from . import CONNECTOR
from Extensions import commande_comm
-class ETAPE(I_MCCOMPO.MCCOMPO):
+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=''
+ # 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()
+ sdname = self.reuse.getName()
else:
- if self.sd:sdname=self.sd.getName()
- if sdname.find('sansnom') != -1 or sdname.find('SD_') != -1:
+ 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 ""
return sdname
def isReentrant(self):
"""
- Indique si la commande est reentrante
+ Indique si la commande est reentrante
"""
- return self.definition.reentrant == 'o'
+ return self.definition.reentrant == "o"
def initModif(self):
"""
- Met l'etat de l'etape a : modifie
- Propage la modification au parent
+ 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'
+ # 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)
+ 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")
+ CONNECTOR.Emit(self, "valid")
if self.parent:
self.parent.finModif()
- def nommeSd(self,nom) :
+ 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
+ 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':
+ 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"
+ 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
+ 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:
#
# 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()) :
+ 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 :
+ 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
+ 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):
+ 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")
+ 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
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.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') :
+ 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.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.sd.nom = nom
+ self.sdnom = nom
+ self.parent.updateConceptAfterEtape(self, self.sd)
self.finModif()
return 1, tr("Nommage du concept effectue")
- if self.isValid() :
+ 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")
+ 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.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'
+ return 0, "Normalement on ne devrait pas passer ici"
- def getSdprods(self,nom_sd):
+ def getSdprods(self, nom_sd):
"""
- Fonction : retourne le concept produit par l etape de nom nom_sd
- s il existe sinon None
+ 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
+ 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
+ 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
+ if self.actif:
+ return
self.actif = 1
self.initModif()
- if self.sd :
+ if self.sd:
try:
self.jdc.appendSdProd(self.sd)
except:
pass
- CONNECTOR.Emit(self,"add",None)
- CONNECTOR.Emit(self,"valid")
+ 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
+ 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 :
+ if self.sd:
self.jdc.delSdprod(self.sd)
- self.jdc.deleteConceptAfterEtape(self,self.sd)
- CONNECTOR.Emit(self,"supp",None)
- CONNECTOR.Emit(self,"valid")
+ self.jdc.deleteConceptAfterEtape(self, self.sd)
+ CONNECTOR.Emit(self, "supp", None)
+ CONNECTOR.Emit(self, "valid")
- def controlSdprods(self,d):
+ 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
+ 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)
+ # print ("controlSdprods etape",d.keys(),self.sd and self.sd.nom,self.nom)
if self.sd:
- if self.sd.nom in d :
+ 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
+ # 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)
+ 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):
+ def supprimeSdprod(self, sd):
"""
- Supprime le concept produit sd s'il est produit par l'etape
+ Supprime le concept produit sd s'il est produit par l'etape
"""
- if sd is not self.sd:return
- if self.sd != None :
+ if sd is not self.sd:
+ return
+ if self.sd != None:
self.initModif()
self.parent.delSdprod(sd)
- self.sd=None
+ 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
+ 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
+ # 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 :
+ 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 :
+ def updateConcept(self, sd):
+ for child in self.mcListe:
child.updateConcept(sd)
- def deleteConcept(self,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
+ 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.sd = self.reuse = None
self.initModif()
- for child in self.mcListe :
+ for child in self.mcListe:
child.deleteConcept(sd)
- def replaceConcept(self,old_sd,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
+ 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.sd = self.reuse = sd
self.initModif()
- for child in self.mcListe :
- child.replaceConcept(old_sd,sd)
+ 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
+ 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)
+ 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)
+ 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 getMCPath(self):
+ return [self.nom, "@sdname " + self.sd.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
+ 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
+ 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
+ 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 :
+ # 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.
+ 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={}
+ self.mc_globaux = {}
I_MCCOMPO.MCCOMPO.updateMcGlobal(self)
def updateConditionBloc(self):
"""
- Realise l'update des blocs conditionnels fils de self
+ Realise l'update des blocs conditionnels fils de self
"""
self._updateConditionBloc()
- def getObjetCommentarise(self,format):
+ def getObjetCommentarise(self, format):
"""
- Cette methode retourne un objet commande commentarisee
- representant la commande self
+ Cette methode retourne un objet commande commentarisee
+ representant la commande self
"""
import generator
- g=generator.plugins[format]()
- texte_commande = g.gener(self,format='beautifie')
+
+ 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)
+ 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)
+ 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)
+ 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":
+ if self.nom == "DETRUIRE":
self.parent.controlContextApres(self)
-
-
-#ATTENTION SURCHARGE: a garder en synchro ou a reintegrer dans le Noyau
- def buildSd(self,nom):
+ # 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
+ 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 :
+ # sd = Noyau.N_ETAPE.ETAPE.buildSd(self, nom)
+ sd = 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
+ 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
+ # 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
+ 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 :
+ if self.parent:
self.jdc = self.parent.getJdcRoot()
- self.id= self.parent.register(self)
- self.UserError=self.jdc.UserError
- if self.definition.niveau :
+ 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.register(self)
else:
# La definition est au niveau global
- self.nom_niveau_definition = 'JDC'
- self.niveau=self.parent
+ self.nom_niveau_definition = "JDC"
+ self.niveau = self.parent
else:
- self.jdc = self.parent =None
- self.id=None
- self.niveau=None
- self.UserError="UserError"
+ 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)
+ 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")))
+ 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
-# Copyright (C) 2007-2021 EDF R&D
+# Copyright (C) 2007-2024 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
"""
"""
-class EVAL :
- """
- """
- def __init__(self,str):
+
+class EVAL:
+ """ """
+
+ def __init__(self, str):
"""
- L'objet EVAL est initialise avec une chaine de caracteres (str)
+ L'objet EVAL est initialise avec une chaine de caracteres (str)
"""
self.valeur = str
- self.val=None
+ self.val = None
def __repr__(self):
- return 'EVAL("""'+self.valeur+'""")'
+ return 'EVAL("""' + self.valeur + '""")'
- def accept(self,visitor):
+ def accept(self, visitor):
"""
- Cette methode permet de parcourir l'arborescence des objets
- en utilisant le pattern VISITEUR
+ Cette methode permet de parcourir l'arborescence des objets
+ en utilisant le pattern VISITEUR
"""
visitor.visitEVAL(self)
# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
+# Copyright (C) 2007-2024 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
#
"""
"""
-
-from __future__ import absolute_import
from . import I_REGLE
+
class EXCLUS(I_REGLE.REGLE):
- def purgeListe(self,liste_a_purger,listeMcPresents):
- regle_active=0
+ def purgeListe(self, liste_a_purger, listeMcPresents):
+ regle_active = 0
for mc_present in listeMcPresents:
if mc_present in self.mcs:
- regle_active=1
+ regle_active = 1
break
- if not regle_active : return liste_a_purger
+ 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
# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
+# Copyright (C) 2007-2024 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-from __future__ import absolute_import
import types
-class Fichier:
- def __init__(self,filtre='All Files (*)',existence='NonExistant',repertoire=None):
- self.filtre=filtre
- self.existence=existence
- self.repertoire=repertoire
+class Fichier:
+ def __init__(
+ self, filtre="All Files (*)", existence="NonExistant", repertoire=None
+ ):
+ self.filtre = filtre
+ self.existence = existence
+ self.repertoire = repertoire
- def __convert__(self,valeur):
+ def __convert__(self, valeur):
# Attention ne verifie pas grand chose
- if type(valeur) != bytes and type(valeur) != str:
+ 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)
+ return "Fichier de Type %s et %s" % (self.filtre, self.existence)
- __repr__=info
- __str__=info
+ __repr__ = info
+ __str__ = info
# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
+# Copyright (C) 2007-2024 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-from __future__ import absolute_import
-from __future__ import print_function
from .I_ASSD import ASSD
from Extensions.i18n import tr
from Extensions.eficas_exception import EficasException
+
class FONCTION(ASSD):
- def __init__(self,etape=None,sd=None,reg='oui'):
- if reg=='oui':
+ 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'):
+ 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''')
+ 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
# On conserve l'ancienne classe fonction (ceinture et bretelles)
-class fonction(FONCTION) : pass
+class fonction(FONCTION):
+ pass
+
from Extensions import param2
-class formule(FONCTION) :
- def __call__(self,*val):
+
+
+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)
+ 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 * '!')
+ 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
# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
+# Copyright (C) 2007-2024 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
"""
+classe pour declarer une formule
+tombée en désuétude
+Attention, n est pas projete en XSD
+verifier l analyse catalogue
"""
-from __future__ import absolute_import
-import string,traceback,re
+import string, traceback, re
+
identifier = re.compile(r"^[^\d\W]\w*\Z", re.UNICODE)
from Extensions import interpreteur_formule
from Editeur import analyse_catalogue
-analyse_catalogue.l_noms_commandes.append('FORM') # declare le nom FORM a l'analyseur de catalogue
+analyse_catalogue.l_noms_commandes.append(
+ "FORM"
+) # declare le nom FORM a l'analyseur de catalogue
class FORM_ETAPE(MACRO_ETAPE):
-
interpreteur = interpreteur_formule.Interpreteur_Formule
def MCBuild(self):
- self.mcListe=self.buildMc()
+ self.mcListe = self.buildMc()
# on cree la liste des types autorises (liste des noms de mots-cles
# simples dans le catalogue de FORMULE)
self.l_types_autorises = list(self.definition.entites.keys())
# en plus de la construction traditionnelle des fils de self
# il faut pour les FORMULE decortiquer l'expression ...
- self.type_retourne,self.arguments,self.corps = self.analyseFormule()
-
+ self.type_retourne, self.arguments, self.corps = self.analyseFormule()
def analyseFormule(self):
"""
"""
if len(self.mcListe) == 0:
# pas de fils pour self --> la FORMULE est incomplete
- return None,None,None
- type_retourne="REEL"
+ return None, None, None
+ type_retourne = "REEL"
if len(self.mcListe) > 0:
- child = self.mcListe[0] # child est un MCSIMP
+ child = self.mcListe[0] # child est un MCSIMP
corps = child.getVal()
else:
corps = None
if len(self.mcListe) > 1:
child = self.mcListe[1]
- l_args= child.getVal()
- else :
- l_args=None
- return type_retourne,l_args,corps
+ l_args = child.getVal()
+ else:
+ l_args = None
+ return type_retourne, l_args, corps
def getNom(self):
"""
Retourne le nom de la FORMULE, cad le nom de la SD si elle existe,
la string vide sinon
"""
- if self.sd :
+ if self.sd:
return self.sd.getName()
else:
- return ''
+ return ""
def getFormule(self):
"""
Retourne un tuple decrivant la formule :
(nom,type_retourne,arguments,corps)
"""
- t,a,c = self.analyseFormule()
+ t, a, c = self.analyseFormule()
n = self.getNom()
- return (n,t,a,c)
+ return (n, t, a, c)
- def verifArguments(self,arguments = None):
+ def verifArguments(self, arguments=None):
"""
Verifie si les arguments passes en argument (si aucun prend les arguments courants)
sont des arguments valide pour une FORMULE.
- un booleen, qui vaut 1 si arguments licites, 0 sinon
- un message d'erreurs ('' si illicites)
"""
- if not arguments :
+ if not arguments:
arguments = self.arguments
- if not arguments :
- return 0,"Une formule doit avoir au minimum un argument"
+ if not arguments:
+ return 0, "Une formule doit avoir au minimum un argument"
# il faut au prealable enlever les parentheses ouvrantes et fermantes
# encadrant les arguments
arguments = string.strip(arguments)
- if arguments[0] != '(':
- return 0,tr("La liste des arguments d'une formule doit etre entre parentheses : parenthese ouvrante manquante")
- if arguments[-1] != ')':
- return 0,tr("La liste des arguments d'une formule doit etre entre parentheses : parenthese fermante manquante")
+ if arguments[0] != "(":
+ return 0, tr(
+ "La liste des arguments d'une formule doit etre entre parentheses : parenthese ouvrante manquante"
+ )
+ if arguments[-1] != ")":
+ return 0, tr(
+ "La liste des arguments d'une formule doit etre entre parentheses : parenthese fermante manquante"
+ )
# on peut tester la syntaxe de chaque argument maintenant
- erreur=''
+ erreur = ""
test = 1
- arguments = arguments[1:-1] # on enleve les parentheses ouvrante et fermante
- l_arguments = string.split(arguments,',')
- for a in l_arguments :
- if not re.match(identifier,str(a)) : return 0, str(a)+" n est pas un identifiant"
- return test,erreur
+ arguments = arguments[1:-1] # on enleve les parentheses ouvrante et fermante
+ l_arguments = string.split(arguments, ",")
+ for a in l_arguments:
+ if not re.match(identifier, str(a)):
+ return 0, str(a) + " n est pas un identifiant"
+ return test, erreur
- def verifCorps(self,corps=None,arguments=None):
+ def verifCorps(self, corps=None, arguments=None):
"""
Cette methode a pour but de verifier si le corps de la FORMULE
est syntaxiquement correct.
- un booleen, qui vaut 1 si corps de FORMULE licite, 0 sinon
- un message d'erreurs ('' si illicite)
"""
- if not corps :
+ if not corps:
corps = self.corps
- if not arguments :
+ if not arguments:
arguments = self.arguments
- formule=(self.getNom(),self.type_retourne,arguments,corps)
+ formule = (self.getNom(), self.type_retourne, arguments, corps)
# on recupere la liste des constantes et des autres fonctions predefinies
# et qui peuvent etre utilisees dans le corps de la formule courante
- l_ctes,l_form = self.jdc.getParametresFonctionsAvantEtape(self)
+ l_ctes, l_form = self.jdc.getParametresFonctionsAvantEtape(self)
# on cree un objet verificateur
try:
- verificateur = self.interpreteur(formule=formule,
- constantes = l_ctes,
- fonctions = l_form)
- except :
+ verificateur = self.interpreteur(
+ formule=formule, constantes=l_ctes, fonctions=l_form
+ )
+ except:
traceback.print_exc()
- return 0,tr("Impossible de realiser la verification de la formule")
- return verificateur.isValid(),verificateur.report()
+ return 0, tr("Impossible de realiser la verification de la formule")
+ return verificateur.isValid(), verificateur.report()
- def verifNom(self,nom=None):
+ def verifNom(self, nom=None):
"""
Verifie si le nom passe en argument (si aucun prend le nom courant)
est un nom valide pour une FORMULE.
- un booleen, qui vaut 1 si nom licite, 0 sinon
- un message d'erreurs ('' si illicite)
"""
- if not nom :
+ if not nom:
nom = self.getNom()
- if nom == "" :
- return 0,tr("Pas de nom donne a la FORMULE")
- if len(nom) > 8 :
- return 0,tr("Un nom de FORMULE ne peut depasser 8 caracteres")
- if nom[0] > "0" and nom[0] < "9" :
- return 0,tr("Un nom de FORMULE ne peut pas commencer par un chiffre")
- sd = self.parent.getSdAutourEtape(nom,self)
- if sd :
- return 0,tr("Un concept de nom %s existe deja !" %nom)
- return 1,''
+ if nom == "":
+ return 0, tr("Pas de nom donne a la FORMULE")
+ if len(nom) > 8:
+ return 0, tr("Un nom de FORMULE ne peut depasser 8 caracteres")
+ if nom[0] > "0" and nom[0] < "9":
+ return 0, tr("Un nom de FORMULE ne peut pas commencer par un chiffre")
+ sd = self.parent.getSdAutourEtape(nom, self)
+ if sd:
+ return 0, tr("Un concept de nom %s existe deja !" % nom)
+ return 1, ""
- def verifType(self,type=None):
+ def verifType(self, type=None):
"""
Verifie si le type passe en argument (si aucun prend le type courant)
est un type valide pour une FORMULE.
"""
if not type:
type = self.type_retourne
- if not type :
- return 0,tr("Le type de la valeur retournee n'est pas specifie")
+ if not type:
+ return 0, tr("Le type de la valeur retournee n'est pas specifie")
if type not in self.l_types_autorises:
- return 0,tr("Une formule ne peut retourner une valeur de type : %s" %type)
- return 1,''
+ return 0, tr("Une formule ne peut retourner une valeur de type : %s" % type)
+ return 1, ""
- def verifFormule(self,formule=None):
+ def verifFormule(self, formule=None):
"""
Verifie la validite de la formule passee en argument.
Cette nouvelle formule est passee sous la forme d'un tuple : (nom,type_retourne,arguments,corps)
- un booleen, qui vaut 1 si formule licite, 0 sinon
- un message d'erreurs ('' si illicite)
"""
- if not formule :
- formule = (None,None,None,None)
- test_nom,erreur_nom = self.verifNom(formule[0])
- test_type,erreur_type = self.verifType(formule[1])
+ if not formule:
+ formule = (None, None, None, None)
+ test_nom, erreur_nom = self.verifNom(formule[0])
+ test_type, erreur_type = self.verifType(formule[1])
if formule[2]:
- args = '('+formule[2]+')'
+ args = "(" + formule[2] + ")"
else:
args = None
- test_arguments,erreur_arguments = self.verifArguments(args)
- test_corps,erreur_corps = self.verifCorps(corps = formule[3], arguments = args)
+ test_arguments, erreur_arguments = self.verifArguments(args)
+ test_corps, erreur_corps = self.verifCorps(corps=formule[3], arguments=args)
# test global = produit des tests partiels
- test = test_nom*test_type*test_arguments*test_corps
+ test = test_nom * test_type * test_arguments * test_corps
# message d'erreurs global = concatenation des messages partiels
- erreur = ''
- if not test :
- for mess in (erreur_nom,erreur_type,erreur_arguments,erreur_corps):
- erreur = erreur+(len(mess) > 0)*'\n'+mess
- return test,erreur
+ erreur = ""
+ if not test:
+ for mess in (erreur_nom, erreur_type, erreur_arguments, erreur_corps):
+ erreur = erreur + (len(mess) > 0) * "\n" + mess
+ return test, erreur
- def verifFormule_python(self,formule=None):
+ def verifFormule_python(self, formule=None):
"""
Pour l instant ne fait qu un compile python
il serait possible d ajouter des tests sur les arguments
ou le type retourne mais ...
"""
- if not formule :
- formule = (None,None,None,None)
- test_nom,erreur_nom = self.verifNom(formule[0])
+ if not formule:
+ formule = (None, None, None, None)
+ test_nom, erreur_nom = self.verifNom(formule[0])
if formule[2]:
- args = '('+formule[2]+')'
+ args = "(" + formule[2] + ")"
else:
args = None
- test_arguments,erreur_arguments = self.verifArguments(args)
- corps=formule[3]
- erreur_formule= ''
- test_formule=1
- try :
- compile(corps,'<string>','eval')
- except :
- erreur_formule= "le corps de la formule n'est pas une formule python valide"
- test_formule=0
- erreur = ''
- test = test_nom*test_arguments*test_formule
- if not test :
- for mess in (erreur_nom,erreur_arguments,erreur_formule):
- erreur = erreur+(len(mess) > 0)*'\n'+mess
- return test,erreur
-
+ test_arguments, erreur_arguments = self.verifArguments(args)
+ corps = formule[3]
+ erreur_formule = ""
+ test_formule = 1
+ try:
+ compile(corps, "<string>", "eval")
+ except:
+ erreur_formule = (
+ "le corps de la formule n'est pas une formule python valide"
+ )
+ test_formule = 0
+ erreur = ""
+ test = test_nom * test_arguments * test_formule
+ if not test:
+ for mess in (erreur_nom, erreur_arguments, erreur_formule):
+ erreur = erreur + (len(mess) > 0) * "\n" + mess
+ return test, erreur
- def update(self,formule):
+ def update(self, formule):
"""
Methode externe.
Met a jour les champs nom, type_retourne,arguments et corps de la FORMULE
On stocke les valeurs SANS verifications.
"""
self.type_retourne = formule[1]
- self.arguments = '('+formule[2]+')'
+ self.arguments = "(" + formule[2] + ")"
self.corps = formule[3]
# il faut ajouter le mot-cle simple correspondant dans mcListe
# pour cela on utilise la methode generale buildMc
# du coup on est oblige de modifier le dictionnaire valeur de self ...
self.valeur = {}
- self.valeur[self.type_retourne] = self.arguments+' = ' + self.corps
+ self.valeur[self.type_retourne] = self.arguments + " = " + self.corps
self.MCBuild()
sd = self.getSdProd()
if sd:
# parametres
# corps de la fonction
# il faut aussi que les arguments soient sous forme de tuple
- def updateFormulePython(self,formule):
+ def updateFormulePython(self, formule):
self.buildMc()
- self.mcListe=[]
- if len(formule) < 4 :
+ self.mcListe = []
+ if len(formule) < 4:
return 0
- arguments=formule[3]
- if arguments[0] == '(' :
- arguments=arguments[1:]
- if arguments[-1] == ')' :
- arguments=arguments[:-1]
- self.arguments=tuple(arguments.split(','))
+ arguments = formule[3]
+ if arguments[0] == "(":
+ arguments = arguments[1:]
+ if arguments[-1] == ")":
+ arguments = arguments[:-1]
+ self.arguments = tuple(arguments.split(","))
- mocles={"NOM_PARA":self.arguments}
+ 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=self.definition.entites[k](None,nom=k,parent=self)
- child.valeur=mocles[k]
- child.state = 'modified'
+ for k, v in self.definition.entites.items():
+ if not k in mocles:
+ continue
+ child = self.definition.entites[k](None, nom=k, parent=self)
+ child.valeur = mocles[k]
+ child.state = "modified"
self.mcListe.append(child)
self.corps = formule[2]
self.actif = 1
self.initModif()
nom = self.getNom()
- if nom == '' : return
+ if nom == "":
+ return
try:
self.jdc.appendFonction(self.sd)
except:
"""
self.actif = 0
self.initModif()
- if not self.sd : return
+ if not self.sd:
+ return
self.jdc.delFonction(self.sd)
- def updateConcept(self,sd):
+ def updateConcept(self, sd):
return
- def deleteConcept(self,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,
- sauf les objets FORM_ETAPE qui doivent verifier que le concept detruit n'est pas
- utilise dans le corps de la fonction
+ 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
+ utilise dans le corps de la fonction
"""
self.initModif()
- def replaceConcept(self,old_sd,sd):
+ def replaceConcept(self, old_sd, sd):
"""
- Inputs :
- - old_sd=concept remplace
- - sd = nouveau concept
- Fonction :
- Les objets FORM_ETAPE devraient verifier que le concept remplace n'est pas
- utilise dans le corps de la fonction
+ Inputs :
+ - old_sd=concept remplace
+ - sd = nouveau concept
+ Fonction :
+ Les objets FORM_ETAPE devraient verifier que le concept remplace n'est pas
+ utilise dans le corps de la fonction
"""
self.initModif()
# -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2021 EDF R&D
+# Copyright (C) 2007-2024 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
"""
"""
# Modules Python
-from __future__ import absolute_import
-from __future__ import print_function
-import types,traceback,sys,os
+import types, traceback, sys, os
import linecache
from Extensions.i18n import tr
from Extensions.eficas_exception import EficasException
+import Noyau
+
# Modules Eficas
from . import I_OBJECT
-import Noyau
from Noyau.N_ASSD import ASSD
-#from Noyau.N_LASSD import LASSD
+
+# from Noyau.N_LASSD import LASSD
from Noyau.N_ETAPE import ETAPE
from Noyau.N_Exception import AsException
-from Extensions import commentaire ,parametre ,parametre_eval
+from Extensions import commentaire, parametre, parametre_eval
from . import CONNECTOR
import Validation
except NameError:
basestring = str
+
class LASSD:
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 __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):
+ def getIndex(self, objet):
"""
- Retourne la position d'objet dans la liste self
+ Retourne la position d'objet dans la liste self
"""
return self.etapes.index(objet)
- def getSdAvantDuBonType(self,etape,types_permis):
+ def getSdAvantDuBonType(self, etape, types_permis):
"""
- Retourne la liste des concepts avant etape d'un type acceptable
+ Retourne la liste des concepts avant etape d'un type acceptable
"""
- #print ('getSdAvantDuBonType ', types_permis)
- d=self.getContexteAvant(etape)
+ # 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
+ 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)
+ 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=[]
+ def getSdCreeParObjet(self, classeAChercher):
+ l = []
for v in list(self.sdsDict.keys()):
- if (isinstance(self.sdsDict[v], classeAChercher)) :
+ 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:
+ 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 :
+ 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)
+ 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):
+ # def set_Copules_recalcule_etat(self):
# for etapeTraitee in self.etapes :
# if etapeTraitee.nom == 'CORRELATION' :
- #Matrix=etapeTraitee.getChild('Matrix')
- #if Matrix !=None :
+ # Matrix=etapeTraitee.getChild('Matrix')
+ # if Matrix !=None :
# Correlation=etapeTraitee.getChild('CorrelationMatrix')
# if Correlation !=None : Correlation.state='arecalculer'
- # Matrix.state='arecalculer'
+ # Matrix.state='arecalculer'
- #def recalculeEtatCorrelation(self):
+ # def recalculeEtatCorrelation(self):
# for etapeTraitee in self.etapes :
# if etapeTraitee.nom == 'CORRELATION' :
- #Matrix=etapeTraitee.getChild('Matrix')
- #if Matrix !=None :
+ # Matrix=etapeTraitee.getChild('Matrix')
+ # if Matrix !=None :
# Matrix.state='arecalculer'
# Correlation=Matrix.getChild('CorrelationMatrix')
# if Correlation !=None : Correlation.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'
+ 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]
- except :
- liste=()
- for etapeTraitee in self.etapes :
- if etapeTraitee.nom not in liste: continue
- #self.forceRecalculBloc(etapeTraitee)
- etapeTraitee.state='arecalculer'
+ # print ("je passe dans recalculeValiditeApresChangementGlobalJdc")
+ try:
+ liste = self.getJdcRoot().cata.dict_condition[motClef.nom]
+ except:
+ liste = ()
+ for etapeTraitee in self.etapes:
+ if etapeTraitee.nom not in liste:
+ continue
+ # self.forceRecalculBloc(etapeTraitee)
+ etapeTraitee.state = "arecalculer"
etapeTraitee.deepUpdateConditionBloc()
etapeTraitee.isValid()
- #print (etapeTraitee.nom ,etapeTraitee.isValid())
+ # print (etapeTraitee.nom ,etapeTraitee.isValid())
def activeBlocsGlobaux(self):
- for nomMotClef in self.mc_globaux :
- motClef=self.mc_globaux[nomMotClef]
+ 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'
+ 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
+ # 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():
# if hasattr(objet,'_updateConditionBloc'):objet._updateConditionBloc()
# self.forceRecalculBloc(child)
-
- def getSdAvantDuBonTypePourTypeDeBase(self,etape,type):
+ 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
+ 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 :
+ 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):
+ 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 :
+ 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] :
+ # 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):
+ 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 :
+ if type_ok in ("R", "I", "C", "TXM") and v in self.params:
return 1
- elif type_ok == 'R' and v.__class__.__name__ == 'reel' :
+ elif type_ok == "R" and v.__class__.__name__ == "reel":
return 1
- elif type_ok == 'I' and v.__class__.__name__ == 'entier' :
+ elif type_ok == "I" and v.__class__.__name__ == "entier":
return 1
- elif type_ok == 'C' and v.__class__.__name__ == 'complexe' :
+ elif type_ok == "C" and v.__class__.__name__ == "complexe":
return 1
- elif type_ok == 'TXM' and v.__class__.__name__ == 'chaine' :
+ elif type_ok == "TXM" and v.__class__.__name__ == "chaine":
return 1
- elif type(type_ok) != type and not isinstance(type_ok,type):
+ elif type(type_ok) != type and not isinstance(type_ok, type):
continue
- elif v.__class__ == type_ok or issubclass(v.__class__,type_ok):
+ elif v.__class__ == type_ok or issubclass(v.__class__, type_ok):
return 1
return 0
- def addEntite(self,name,pos):
+ 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
+ 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" :
+ 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)
+ 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.editmode = 0
self.activeEtapes()
- CONNECTOR.Emit(self,"add",objet)
+ 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)
+ 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 pos == None:
+ pos = 0
+ self.etapes.insert(pos, objet)
self.resetContext()
- self.editmode=0
+ self.editmode = 0
self.activeEtapes()
- CONNECTOR.Emit(self,"add",objet)
+ 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)
+ 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)
+ if pos == None:
+ pos = 0
+ self.etapes.insert(pos, objet)
self.resetContext()
- self.editmode=0
+ self.editmode = 0
self.activeEtapes()
- CONNECTOR.Emit(self,"add",objet)
+ CONNECTOR.Emit(self, "add", objet)
self.finModif()
return objet
- elif not( isinstance(name, basestring)):
- #elif type(name)==types.InstanceType:
- #elif isinstance(name,object):
+ 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)):
+
+ if not (isinstance(objet, commentaire.COMMENTAIRE)):
objet.reparent(self)
self.setCurrentStep()
- if isinstance(objet,ETAPE):
- if objet.nom_niveau_definition == 'JDC':
+ 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)
+ 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.editmode = 0
self.activeEtapes()
- CONNECTOR.Emit(self,"add",objet)
+ CONNECTOR.Emit(self, "add", objet)
self.finModif()
return objet
- else :
+ else:
# On veut ajouter une nouvelle commande
try:
self.setCurrentStep()
- cmd=self.getCmd(name)
+ 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)
+ e = cmd.make_objet()
+ if pos == None:
+ pos = 0
+ self.etapes.insert(pos, e)
self.resetCurrentStep()
self.resetContext()
- self.editmode=0
+ self.editmode = 0
self.activeEtapes()
- self.enregistreEtapePyxb(e,pos)
+ self.enregistreEtapePyxb(e, pos)
# PN fait ds self.activeEtapes
- CONNECTOR.Emit(self,"add",e)
+ 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')
+ self.editmode = 0
+ raise AsException(tr("Impossible d'ajouter la commande") + name + "\n")
except:
- #else :
+ # else :
traceback.print_exc()
self.resetCurrentStep()
- self.editmode=0
- raise AsException(tr("Impossible d ajouter la commande")+name)
+ self.editmode = 0
+ raise AsException(tr("Impossible d ajouter la commande") + name)
def close(self):
- #print "JDC.close",self
+ # print "JDC.close",self
for etape in self.etapes:
- if hasattr(etape,"close"):etape.close()
- CONNECTOR.Emit(self,"close")
+ if hasattr(etape, "close"):
+ etape.close()
+ CONNECTOR.Emit(self, "close")
def setCurrentStep(self):
CONTEXT.unsetCurrentStep()
def listeMcPresents(self):
return []
- def getSdAvantEtape(self,nom_sd,etape):
- return self.getContexteAvant(etape).get(nom_sd,None)
+ def getSdAvantEtape(self, nom_sd, etape):
+ return self.getContexteAvant(etape).get(nom_sd, None)
- def getSdApresEtapeAvecDetruire(self,nom_sd,sd,etape,avec='non'):
+ 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
+ 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}
+ # 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)
+ 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).
+ # 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 :
+ 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:
+ 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
# concept initial
return sd
- def getSdApresEtape(self,nom_sd,etape,avec='non'):
+ 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
+ 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
+ ietap = self.etapes.index(etape)
+ if avec == "non":
+ ietap = ietap + 1
for e in self.etapes[ietap:]:
- sd=e.getSdprods(nom_sd)
+ sd = e.getSdprods(nom_sd)
if sd:
- if hasattr(e,'reuse'):
+ if hasattr(e, "reuse"):
if e.reuse != sd:
return sd
return None
- def getSdAutourEtape(self,nom_sd,etape,avec='non'):
+ 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
+ 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
+ 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]
+ if nom_sd in self.sdsDict.keys():
+ sd = self.sdsDict[nom_sd]
return sd
- def getContexte_apres(self,etape):
+ 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
+ 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)
+ 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
+ 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):
+ def deplaceEntite(self, indexNoeudACopier, indexNoeudOuColler, pos):
"""
- Pour le cut
+ 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:]
+ 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.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'
+ for e in self.etapes:
+ e.state = "modified"
self.controlContextApres(None)
return 1
-
- def suppEntite(self,etape) :
+ 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
+ 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
- #print ('suppEntite', etape.nom)
- if etape not in self.etapes: return 0
+ # PN correction de bugs
+ # print ('suppEntite', etape.nom)
+ if etape not in self.etapes:
+ return 0
+ # print ('suppEntite', etape.nom)
+ if etape.nom == "ExpressionIncertitude":
+ etape.delieIncertitude()
self.initModif()
- index_etape=self.etapes.index(etape)
+ index_etape = self.etapes.index(etape)
- #etape.delObjPyxb()
+ # etape.delObjPyxb()
self.etapes.remove(etape)
if etape.niveau is not self:
# 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]
+ index_etape = index_etape - 1
+ etape = self.etapes[index_etape]
else:
- etape=None
+ etape = None
self.controlContextApres(etape)
self.resetContext()
- CONNECTOR.Emit(self,"supp",etape)
+ CONNECTOR.Emit(self, "supp", etape)
self.finModif()
return 1
- def controlContextApres(self,etape):
+ 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.
+ 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
+ # print ("controlContextApres",self,etape)
+ # Regularise les etapes du jdc apres l'etape etape
self.controlJdcContextApres(etape)
- def controlJdcContextApres(self,etape):
+ def controlJdcContextApres(self, etape):
"""
- Methode semblable a controlContextApres mais ne travaille
- que sur les etapes et sous etapes du jdc
+ Methode semblable a controlContextApres mais ne travaille
+ que sur les etapes et sous etapes du jdc
"""
- #print ("controlJdcContextApres",self,etape)
+ # print ("controlJdcContextApres",self,etape)
if etape is None:
# on demarre de la premiere etape
- index_etape=0
+ index_etape = 0
else:
- index_etape=self.etapes.index(etape)+1
+ index_etape = self.etapes.index(etape) + 1
try:
- etape=self.etapes[index_etape]
+ etape = self.etapes[index_etape]
except:
- #derniere etape du jdc : rien a faire
+ # derniere etape du jdc : rien a faire
return
- context=self.getContexteAvant(etape)
+ 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
+ if not self.cr.estvide():
+ return
self.activeEtapes()
- if self.mc_globaux != {} : self.activeBlocsGlobaux()
+ if self.mc_globaux != {}:
+ self.activeBlocsGlobaux()
def analyseXML(self):
- #print ('analyseXML')
- #print (self.procedure)
+ # print ('analyseXML')
+ # print (self.procedure)
self.setCurrentContext()
- self.analyseFromXML()
+ try:
+ self.analyseFromXML()
+ except Exception as e:
+ print("Erreur dans analyseXML a la generation du JDC a partir du xml")
+ # import traceback
+ # traceback.print_stack()
+ # Erreur lors de la conversion
+ l = traceback.format_exception(
+ sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]
+ )
+ self.cr.exception(
+ tr("Impossible de convertir le fichier XML\n %s", "".join(l))
+ )
+ print(e)
+ return
- def registerParametre(self,param):
+ def registerParametre(self, param):
"""
- Cette methode sert a ajouter un parametre dans la liste des parametres
+ Cette methode sert a ajouter un parametre dans la liste des parametres
"""
self.params.append(param)
- def registerFonction(self,fonction):
+ def registerFonction(self, fonction):
"""
- Cette methode sert a ajouter une fonction dans la liste des fonctions
+ Cette methode sert a ajouter une fonction dans la liste des fonctions
"""
self.fonctions.append(fonction)
- def deleteParam(self,param):
+ def deleteParam(self, param):
"""
- Supprime le parametre param de la liste des parametres
- et du contexte gobal
+ 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]
+ 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):
+ 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
+ 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)
+ 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)
+ 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())
+ 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',):
+ 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
+ return l_constantes, l_fonctions
- def getNbEtapesAvant(self,niveau):
+ def getNbEtapesAvant(self, niveau):
"""
- Retourne le nombre d etapes avant le debut de niveau
+ Retourne le nombre d etapes avant le debut de niveau
"""
- nb=0
+ nb = 0
for niv in self.etapes_niveaux:
- if niv == niveau:break
- nb=nb+len(niv.etapes)
+ 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'
+ # print "initModif",self
+ self.state = "modified"
def finModif(self):
- #print "finModif",self
- CONNECTOR.Emit(self,"valid")
+ # print "finModif",self
+ CONNECTOR.Emit(self, "valid")
self.isValid()
pass
- def deepUpdateConditionBloc(self,motClef=None):
+ def deepUpdateConditionBloc(self, motClef=None):
# pour le moment, on ne fait rien
self.getJdcRoot().recalculeValiditeApresChangementGlobalJdc(motClef)
- #raise EficasException(tr("Pas implemente"))
+ # raise EficasException(tr("Pas implemente"))
def updateConditionBloc(self):
# pour le moment, on ne fait rien
"""
# 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() :
+ for etape in self.etapes:
+ if etape.isActif():
+ if not etape.isValid():
l = etape.getListeMcInconnus()
- if l : l_mc.extend(l)
+ if l:
+ l_mc.extend(l)
return l_mc
+ def getMCPath(self):
+ return []
+
def getGenealogiePrecise(self):
return []
+ def getObjetByMCPath(self, MCPath):
+ # Attention; le MCPath n est valide qu a la lecture du fichier
+ etape = None
+ nomEtape = MCPath[0]
+ nomSuivant = MCPath[1]
+ if nomSuivant.startswith("@sdname "):
+ nomEtape = nomSuivant.split(" ")[1]
+ etape = self.getEtapeByConceptName(nomEtape)
+ elif nomSuivant.startswith("@index "):
+ indexEtape = nomSuivant.split(" ")[1]
+ etape = self.getEtapesByName(nomEtape)[indexEtape]
+ if not etape:
+ return None
+ return etape.getObjetByMCPath(MCPath[2:])
+
def getGenealogie(self):
"""
- Retourne la liste des noms des ascendants de l'objet self
- jusqu'a la premiere ETAPE parent.
+ 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
+ Retourne la liste des commandes du catalogue
"""
return self.niveau.definition.getListeCmd()
def getGroups(self):
"""
- Retourne la liste des groupes
+ Retourne la liste des groupes
"""
- return self.niveau.definition.liste_groupes,self.niveau.definition.dict_groupes
+ return self.niveau.definition.liste_groupes, self.niveau.definition.dict_groupes
- def setEtapeContext(self,etape):
+ def setEtapeContext(self, etape):
"""
- Positionne l'etape qui sera utilisee dans NommerSdProd pour
- decider si le concept passe pourra etre nomme
+ Positionne l'etape qui sera utilisee dans NommerSdProd pour
+ decider si le concept passe pourra etre nomme
"""
- self._etape_context=etape
+ 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.
+ 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
+ # 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):
+ def delSdprod(self, sd):
"""
- Supprime la SD sd de la liste des sd et des dictionnaires de contexte
+ 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]
+ # 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):
+ def delParam(self, param):
"""
- Supprime le parametre param de la liste des paramatres
- et du contexte gobal
+ 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]
+ 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):
+ def delFonction(self, fonction):
"""
- Supprime la fonction fonction de la liste des fonctions
- et du contexte gobal
+ 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]
+ 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):
+ 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
+ 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
+ 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)
+ # if sd not in self.sds : self.sds.append(sd)
- def appendParam(self,param):
+ def appendParam(self, param):
"""
- Ajoute le parametre param a la liste des params
- et au contexte global
+ 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
+ if param not in self.params:
+ self.params.append(param)
+ self.g_context[param.nom] = param
- def appendFonction(self,fonction):
+ def appendFonction(self, fonction):
"""
- Ajoute la fonction fonction a la liste des fonctions
- et au contexte global
+ 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
+ if fonction not in self.fonctions:
+ self.fonctions.append(fonction)
+ self.g_context[fonction.nom] = fonction
- def deleteConcept(self,sd):
+ 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
+ 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 :
+ for etape in self.etapes:
etape.deleteConcept(sd)
- #PN PN PN pour les matrices ????
- #self.getVariables_avant(etape)
+ # PN PN PN pour les matrices ????
+ # self.getVariables_avant(etape)
- def replaceConceptAfterEtape(self,etape,old_sd,sd):
+ 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
+ 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 !
+ 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)
+ child.replaceConcept(old_sd, sd)
- def updateConceptAfterEtape(self,etape,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
+ 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
+ # 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 !
+ 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))
+ # 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 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):
+ def recordUnit(self, unit, etape):
"""Enregistre les unites logiques incluses et les infos relatives a l'etape"""
- #print "recordUnit",unit,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)
+ 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.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
+ 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
+ # 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)
+ try:
+ objet = eval(valeur, context)
return objet
except:
- #traceback.print_exc()
+ # traceback.print_exc()
pass
return valeur
-#ATTENTION SURCHARGE : cette methode doit etre gardee en synchronisation avec celle de Noyau
+ # 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=[]
-
-#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()
+ 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
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'):
+ # 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
+ 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
# 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 CONTEXT.debug:
+ print(("JDC.nommerSDProd ", sd, sdnom))
if self._etape_context:
- o=self.getContexteAvant(self._etape_context).get(sdnom,None)
+ o = self.getContexteAvant(self._etape_context).get(sdnom, None)
else:
- o=self.sdsDict.get(sdnom,None)
+ o = self.sdsDict.get(sdnom, None)
- if isinstance(o,ASSD):
- raise AsException(tr(" Nom de concept deja defini : "+ sdnom))
+ 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
+ # 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
+ if restrict == "non":
+ self.g_context[sdnom] = sd
- def deleteConceptEntreEtapes(self,index1,index2,sd):
- if index2 <= index1 :return
+ 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):
+ def deleteConceptAfterEtape(self, etape, sd):
"""
- Met a jour les etapes du JDC qui sont apres etape en fonction
- de la disparition du concept 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 !
+ 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 updateMCPath(self):
+ # Cette methode sert a recaluler les MCPaths qui peuvent avoir changer
+ # si il y a eu des suprressions dans des MCList freres ou oncles des motclefs incertains
+ etapeIncertitude = self.getEtapesByName("ExpressionIncertitude")
+ if etapeIncertitude == []:
+ return
+ mcVP = self.getChild("Input").getChild("VariableProbabiliste")
+ if mcVP == None:
+ return
+ for mc in mcVP:
+ itemMCPath = mc.getChild("MCPath")
+ itemMCPath.setValeur(mc.variableDeterministe.getMCPath())
+
+ # ATTENTION SURCHARGE : les methodes ci-dessus surchargent des methodes de Noyau et Validation : a reintegrer
- def getFile(self,unite=None,fic_origine=''):
+ 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
+ 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)
+ 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 os.path.exists("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()
+ 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 == None : return None,None
+ text = text.replace("\r\n", "\n")
if file:
- linecache.cache[file]=0,0,text.split('\n'),file
- return file,text
+ 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)
+ 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")
+ CONNECTOR.Emit(self, "valid")
return valid
def getLNomsEtapes(self):
"""
- Retourne la liste des noms des etapes de self
+ Retourne la liste des noms des etapes de self
"""
- l=[]
+ l = []
for etape in self.etapes:
l.append(etape.nom)
return l
# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
+# Copyright (C) 2007-2024 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-from __future__ import absolute_import
from Noyau import N_JDC_CATA
+
class JDC_CATA:
def __init__(self):
- self.l_noms_entites=[]
+ self.l_noms_entites = []
def getListeCmd(self):
self.l_noms_entites.sort()
def getDocu(self):
return
-
-#ATTENTION SURCHARGE: cette methode doit etre synchronisee avec celle du Noyau
- def enregistre(self,commande):
+ # 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
+ Cette methode surcharge la methode de la classe du Noyau
+ Marche avec Noyau
"""
- N_JDC_CATA.JDC_CATA.enregistre(self,commande)
+ N_JDC_CATA.JDC_CATA.enregistre(self, commande)
self.l_noms_entites.append(commande.nom)
# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
+# Copyright (C) 2007-2024 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+
class LASSD:
def __repr__(self):
return self.getName()
# -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2021 EDF R&D
+# Copyright (C) 2007-2024 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
"""
"""
# Modules Python
-from __future__ import absolute_import
-from __future__ import print_function
import sys
import os.path as osp
-import traceback,types
+import traceback, types
# Modules Eficas
from Extensions.i18n import tr
from Extensions.eficas_exception import EficasException
-from Ihm import I_ETAPE
+from Ihm import I_ETAPE
from Ihm import I_ENTITE
from Ihm import I_OBJECT
-import Noyau
from Noyau.N_ASSD import ASSD
from Noyau import N__F
-from Extensions import param2
-
-# import rajoutes suite a l'ajout de buildSd --> a resorber
-import Noyau, Validation.V_MACRO_ETAPE
+from Noyau import N_MACRO_ETAPE
from Noyau import N_Exception
from Noyau.N_Exception import AsException
-import Accas # attention aux imports circulaires
+from Extensions import param2
+
# fin import a resorber
-class MACRO_ETAPE(I_ETAPE.ETAPE):
+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):
+ 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
+ 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
+ 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 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)
+ d = {}
+ self.definition.op_init(*(self, d))
+ return d.get(nom_sd, None)
return None
- def getContexteJdc(self,fichier,text,doitEtreValide=1):
+ def getContexteJdc(self, fichier, text, doitEtreValide=1):
"""
- Interprete text comme un texte de jdc et retourne le contexte final.
+ Interprete text comme un texte de jdc et retourne le contexte final.
- Le contexte final est le dictionnaire des sd disponibles 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
+ 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)
+ # print ("getContexteJdc",self,self.nom, text)
# On recupere l'etape courante
- step=CONTEXT.getCurrentStep()
- self.text_included_converted=0
+ step = CONTEXT.getCurrentStep()
+ self.text_included_converted = 0
try:
- #if 1 :
+ # 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.
# Indispensable avant de creer un nouveau JDC
CONTEXT.unsetCurrentStep()
- args=self.jdc.args
- prefix_include=None
- if hasattr(self,'prefix'):
- prefix_include=self.prefix
+ 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()
+ 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:
+ if hasattr(self, "jdc_aux") and self.jdc_aux:
self.jdc_aux.supprime_aux()
- if fichier is None:fichier="SansNom"
+ 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=""
+ 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"
+ format = self.jdc.appliEficas.format_fichier
+ # on force a python pour Carmel
+ if format == "CARMEL3D":
+ format = "python"
import convert
- if format in convert.plugins :
+
+ 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
+ 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)
+ 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)
+ 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)
+ 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
+ self.etapes = j.etapes
+ self.jdc_aux = j
+ self.jdc.jdcDict = self.jdc_aux
except:
- #else :
+ # 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())
+ # 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))
-
+ 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)
+ 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()
+ j_context = j.getVerifContexte()
+ # print j_context.keys()
+ # print j.g_context.keys()
except:
# On retablit l'etape courante step
CONTEXT.unsetCurrentStep()
# sans verification car on est sur (verification integree) que
# le nommage est possible
self.g_context.clear()
- for k,v in j_context.items():
+ 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
+ self.g_context[k] = v
+ self.parent.sdsDict[k] = v
- #Ce traitement n'est realise que dans les cas suivants:
+ # Ce traitement n'est realise que dans les cas suivants:
# - si convert n'a pas pu convertir le jeu de commandes
# - et ce n'est pas un INCLUDE_MATERIAU
- #On collecte les variables Python qui ne sont pas dans le contexte initial
- #et dans le contexte valide et on en fait un pseudo-parametre (Variable)
+ # 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)
+ 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)
# On recupere le contexte courant
- self.currentContext=j.currentContext
- self.index_etape_courante=j.index_etape_courante
- self.jdc_aux=j
+ self.currentContext = j.currentContext
+ self.index_etape_courante = j.index_etape_courante
+ self.jdc_aux = j
# On retablit l'etape courante step
CONTEXT.unsetCurrentStep()
def reevalueSdJdc(self):
"""
- Avec la liste des SD qui ont ete supprimees, propage la
- disparition de ces SD dans toutes les etapes et descendants
+ 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()
+ # 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)
+ 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
+ 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 [],[]
+ 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):
+ 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):
+ 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):
+ 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)
+ 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)
+ # 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
+ # 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
+ # 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)
+ 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=[]
+ 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
+ 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)
+ # supprime les references a co dans les etapes suivantes
+ self.parent.deleteConceptAfterEtape(self, co)
else:
self.sdprods.append(co)
self.finModif()
e.controlSdprods(d)
e.updateContext(d)
- def supprimeSdprod(self,sd):
+ def supprimeSdprod(self, sd):
"""
- Supprime le concept produit sd s'il est produit par l'etape
+ Supprime le concept produit sd s'il est produit par l'etape
"""
- #print ('supprimeSdprod de MACRO_ETAPE')
+ # print ('supprimeSdprod de MACRO_ETAPE')
if sd in self.sdprods:
self.initModif()
self.parent.delSdprod(sd)
self.parent.deleteConcept(sd)
return
- if sd is not self.sd :return
- if self.sd is not None :
+ if sd is not self.sd:
+ return
+ if self.sd is not None:
self.initModif()
self.parent.delSdprod(sd)
- self.sd=None
+ 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
+ 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 :
+ # 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 :
+ if self.sd != None:
self.parent.delSdprod(self.sd)
self.parent.deleteConcept(self.sd)
# On detruit les concepts a droite du signe =
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
+ 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={}
+ self.g_context = {}
def close(self):
- #print "close",self
- if hasattr(self,"jdc_aux") and self.jdc_aux:
+ # 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:
+ 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)
+ def updateConcept(self, sd):
+ I_ETAPE.ETAPE.updateConcept(self, sd)
for etape in self.etapes:
etape.updateConcept(sd)
- def deleteConcept(self,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
+ 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)
+ # print "deleteConcept",sd
+ I_ETAPE.ETAPE.deleteConcept(self, sd)
for etape in self.etapes:
etape.deleteConcept(sd)
- def replaceConcept(self,old_sd,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
+ 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)
+ # print "replaceConcept",old_sd,sd
+ I_ETAPE.ETAPE.replaceConcept(self, old_sd, sd)
for etape in self.etapes:
- etape.replaceConcept(old_sd,sd)
+ etape.replaceConcept(old_sd, sd)
- def changeFichierInit(self,new_fic,text):
+ def changeFichierInit(self, new_fic, text):
"""
- Tente de changer le fichier include. Le precedent include est conserve
- dans old_xxx
+ 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"
+ 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.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.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
+ self.fichier_text = text
try:
- self.makeContexteInclude(new_fic,text)
+ self.makeContexteInclude(new_fic, text)
except:
- l=traceback.format_exception_only(tr("Fichier invalide %s", sys.exc_info()[1]))
- self.fichier_err=''.join(l)
+ 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.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.old_contexte_fichier_init = self.old_context
self.reevalueSdJdc()
self.finModif()
def restoreFichierInit(self):
"""
- Restaure le fichier init enregistre dans old_xxx
+ 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
+ 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
+ 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()
+ 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)
+ 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():
+ 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
+ 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.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.state = "undetermined"
self.recordUnite()
# Le contexte du parent doit etre reinitialise car les concepts produits ont change
self.parent.resetContext()
# 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.old_contexte_fichier_init = self.old_context
self.reevalueSdJdc()
self.finModif()
if self.old_jdc_aux:
self.jdc_aux.forceContexte(self.g_context)
- def buildInclude(self,fichier,text):
+ def buildInclude(self, fichier, text):
import Extensions.jdc_include
- self.JdC_aux=Extensions.jdc_include.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)
+ self.recorded_units = self.parent.recorded_units
+ self.buildJdcaux(fichier, text)
- def buildPoursuite(self,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)
+ 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):
+ 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)
+ 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):
+ def buildIncludeEtape(self, text, doitEtreValide=0):
import Extensions.jdc_include
- self.JdC_aux=Extensions.jdc_include.JdC_include
+
+ self.JdC_aux = Extensions.jdc_include.JdC_include
# un include partage la table des unites avec son parent (jdc)
- #self.buildJdcauxInclude(text)
+ # self.buildJdcauxInclude(text)
# Attention fonctionne pour import_Zone de MT
# a adapter eventuellement
- try :
- #if 1 :
- contexte = self.getContexteJdc(None,text,doitEtreValide)
+ 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'
+ 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:]
+ 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.g_context = {}
+ self.etapes = []
self.jdc.resetContext()
- self.jdc_aux=None
+ self.jdc_aux = None
CONTEXT.unsetCurrentStep()
return 1
-
- def buildJdcauxInclude(self,text):
-
- try :
- contexte = self.getContexteJdc(None,text)
+ def buildJdcauxInclude(self, text):
+ try:
+ contexte = self.getContexteJdc(None, text)
except EficasException:
pass
- index=self.jdc.etapes.index(self)
+ 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
+ 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):
+ 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
+ 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_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"))
+ 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.finModif()
except:
# Impossible de construire le jdc auxiliaire (sortie par exception)
- l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
+ 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.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):
+ def makeContexteInclude(self, fichier, text):
"""
- Cette methode sert a craer un contexte en interpratant un texte source Python.
+ Cette methode sert a craer un contexte en interpratant un texte source Python.
"""
- #print ("makeContexteInclude",fichier)
+ # 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")
+ 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
# 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)
+ # 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
+ # print "reevalue_fichier_init"
+ old_context = self.contexte_fichier_init
try:
- self.makeContexteInclude(self.fichier_ini ,self.fichier_text)
+ 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={}
+ 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.old_contexte_fichier_init = old_context
self.reevalueSdJdc()
- def updateFichierInit(self,unite):
+ 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.
+ 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",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
+ # 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
+ # print "updateFichierInit","pas de changement dans include"
+ self.fichier_unite = unite
return
- elif unite == self.fichier_unite :
+ elif unite == self.fichier_unite:
# L'unite n'a pas change
- #print "updateFichierInit","pas de changement dans include 3"
+ # print "updateFichierInit","pas de changement dans include 3"
return
- elif unite != self.fichier_unite :
+ 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)
+ 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
+ # 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
+ self.fichier_text = text
+ self.fichier_unite = unite
+ # print "updateFichierInit",self.recorded_units
- #print "updateFichierInit",self.fichier_ini,self.fichier_text,self.fichier_unite
+ # 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)
+ # print "updateFichierInit.fichier inchange",self.jdc_aux.context_ini
+ self.parent.recordUnit(unite, self)
return
try:
- self.fichier_err=None
- self.makeContexteInclude(self.fichier_ini,self.fichier_text)
+ 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])
+ 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={}
+ 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)
+ 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()
+ # print "updateFichierInit",self.jdc_aux.context_ini.keys()
def recordUnite(self):
- #print "recordUnite",self.nom
+ # print "recordUnite",self.nom
if self.nom == "POURSUITE":
- self.parent.recordUnit(None,self)
+ self.parent.recordUnit(None, self)
else:
- if hasattr(self,'fichier_unite') :
- self.parent.recordUnit(self.fichier_unite,self)
+ if hasattr(self, "fichier_unite"):
+ self.parent.recordUnit(self.fichier_unite, self)
- def getFileMemo(self, unite=None, fname=None, fic_origine=''):
+ 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
+ Initialise en plus recorded_units
"""
- #print "getFileMemo",unite,fic_origine,self,self.parent
- #print self.parent.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={}
+ units = {}
else:
# On est dans le cas d'un include. On reutilise toutes les unites de parent
- units=self.parent.recorded_units
+ units = self.parent.recorded_units
if unite in self.parent.recorded_units:
- f,text,units=self.parent.recorded_units[unite]
- elif self.jdc :
+ 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()
+ text = open(fname, "r").read()
else:
- f,text=self.jdc.getFile(unite=unite, fic_origine=fic_origine)
+ f, text = self.jdc.getFile(unite=unite, fic_origine=fic_origine)
else:
- f,text=None,None
+ f, text = None, None
- self.recorded_units=units
+ 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):
+ 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
+ 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
+ # 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.
- #get_context_avant appelle updateContext qui NE DOIT PAS appeler getContexteAvant
- #On n'a besoin que d'un update local connaissant
+ # 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
for e in self.etapes:
e.updateContext(d)
return
if type(self.definition.op_init) == types.FunctionType:
- self.definition.op_init(*(self,d))
- if self.sd != None :d[self.sd.nom]=self.sd
+ 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()
+ d[co.nom] = co
+ # print "updateContext.fin",d.keys()
-#ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
+ # 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
+ 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:
+ # print "supprime",self
+ if hasattr(self, "jdc_aux") and self.jdc_aux:
self.jdc_aux.supprime_aux()
- self.jdc_aux=None
+ 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)
+ # 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
+ f, text = None, None
+ return f, text
-
- def makeInclude3(self,fichier=None):
+ 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
+ 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)
+
+ 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
+ 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')
+ 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 :
+ except:
pass
raise EficasException(self.fichier_err)
- self.fichier_ini = fichier
- f=open(self.fichier_ini,'r')
- self.fichier_text=f.read()
+ 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
+ self.contexte_fichier_init = {}
+ self.fichier_unite = 999
+ self.fichier_err = None
try:
- #if 1 :
+ # if 1 :
import Extensions.jdc_include
- self.JdC_aux=Extensions.jdc_include.JdC_include
+
+ self.JdC_aux = Extensions.jdc_include.JdC_include
except:
- #else:
+ # 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 :
+ # 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:
+ # 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)
+ # CONTEXT.setCurrentStep(self)
- def makeInclude2(self,fichier=None):
- # Pour OT
+ def makeInclude2(self, fichier=None):
+ # Pour OT
# gestion de l unicite SVP
- unite=999
+ unite = 999
- if hasattr(self,'fichier_ini') : return
- reevalue=0
- if hasattr(self,'old_context_fichier_init' ):
- reevalue=1
+ 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')
+ 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 :
+ except:
pass
raise EficasException(self.fichier_err)
- self.fichier_ini = fichier
+ self.fichier_ini = fichier
self.fichier_text = ""
- self.contexte_fichier_init={}
- self.fichier_unite=999
- self.fichier_err=None
- nbVariableOut=0
- try :
+ 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)
+
+ 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 :
- self.makeIncl2Except(mess=tr("le fichier doit contenir une unique variable de sortie"))
+ if nbVariableOut != 1:
+ 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
+
+ self.JdC_aux = Extensions.jdc_include.JdC_include
except:
traceback.print_exc()
self.makeIncl2Except()
raise EficasException(" ")
try:
- 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')
+ 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 :
+ except:
pass
except:
self.makeIncl2Except()
# recalcul validite pour la matrice eventuelle
- if reevalue :
+ if reevalue:
for e in self.jdc.etapes:
- if e.nom == "VARIABLE" :
- e.state="modified"
- try :
- mc=e.getChild('ModelVariable')
- mc.state="modified"
- except :
+ 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 :
+ 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])
+ 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')
+ 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):
+ # 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 ???)
+ 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 ???)
"""
# 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:
+ # 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 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)
+ 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_ini = f
self.fichier_text = text
- self.contexte_fichier_init={}
- self.fichier_unite=unite
- self.fichier_err=None
+ 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
+ self.JdC_aux = Extensions.jdc_include.JdC_include
- #print "makeInclude",self.fichier_ini,self.fichier_text
+ # 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)
+ self.fichier_err = tr("Le fichier INCLUDE n est pas defini")
+ self.parent.recordUnit(unite, self)
raise EficasException(self.fichier_err)
try:
- self.makeContexteInclude(self.fichier_ini ,self.fichier_text)
- self.parent.recordUnit(unite,self)
+ self.makeContexteInclude(self.fichier_ini, self.fichier_text)
+ self.parent.recordUnit(unite, self)
except:
- l=traceback.format_exception_only(tr("Fichier invalide %s",sys.exc_info()[1]))
+ 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={}
+ 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)
-
+ 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):
+ # 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
+ 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
+ # 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:
+ 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={}
+ 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
+
+ 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
+ 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
+ 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={}
+ 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)
+ 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'):
+ # 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)
+ 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):
+ # 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
+ 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:
+ sd = 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 :
# 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
+ 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
+ # 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') :
+ """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)
+ 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
+ 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
+ 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)
+ 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)
+ 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])
+ 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={}
+ 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)
+ if self.fichier_err is not None:
+ raise EficasException(self.fichier_err)
# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
+# Copyright (C) 2007-2024 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-from __future__ import absolute_import
from . import I_MCCOMPO
-class MCBLOC(I_MCCOMPO.MCCOMPO):
+
+class MCBLOC(I_MCCOMPO.MCCOMPO):
def getNomDsXML(self):
return self.parent.getNomDsXML()
+
+ def getMCPath(self):
+ return self.parent.getMCPath()
# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
+# Copyright (C) 2007-2024 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
#
"""
"""
-from __future__ import absolute_import
-from __future__ import print_function
-import string,types,sys
+import string, types, sys
from copy import copy
import traceback
from Noyau.N_MCBLOC import MCBLOC
from Noyau.N_MCLIST import MCList
from . import I_OBJECT
-
from . import CONNECTOR
+
class MCCOMPO(I_OBJECT.OBJECT):
def getLabelText(self):
"""
- Retourne le label de self
- utilise pour l'affichage dans l'arbre
+ Retourne le label de self
+ utilise pour l'affichage dans l'arbre
"""
return tr(self.nom)
- def getListeMcOrdonnee(self,liste,dico):
+ 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 ...)
+ 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))
+ return self.filtreListeMc(self.getListeMcOrdonneeBrute(liste, dico))
- def getListeMcOrdonneeBrute(self,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 + ...
+ 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 :
+ 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
+ else:
+ specifique = 1
+ if specifique == 1:
+ return l
+ return objet_cata.ordreMC
+
+ def filtreListeMc(self, liste_brute, avecCache=True):
+ """
+ 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
+ si avecCache=False on n inclut pas les MC dont le statut = cache
"""
liste = copy(liste_brute)
listeMcPresents = self.listeMcPresents()
# 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)
+ 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):
+ 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):
+ elif isinstance(objet, MCBLOC):
# un bloc conditionnel ne doit pas apparaitre dans la liste de choix
liste.remove(k)
- elif isinstance(objet,MCFACT):
+ 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 :
+ if not avecCache and objet.definition.statut in ("c", "d", "cache"):
+ liste.remove(k)
+ elif isinstance(objet, MCList):
+ try:
nb_occur_maxi = objet[0].definition.max
if len(objet) >= nb_occur_maxi:
liste.remove(k)
+ if not avecCache and objet[0].definition.statut == "cache":
+ 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 :
+ 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' :
+ if (
+ self.definition.entites[k].statut == "c"
+ or self.definition.entites[k].statut == "cache"
+ ):
liste.remove(k)
- if self.definition.entites[k].label=='BLOC':
+ 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 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):
+ if not avecCache and objet.definition.statut == "cache":
+ liste.remove(k)
+ elif isinstance(objet, MCList):
nb_occur_maxi = objet[0].definition.max
if len(objet) < nb_occur_maxi:
liste.append(k)
+ if not avecCache and objet[0].definition.statut == "cache":
+ liste.remove(k)
return liste
def listeMcPresents(self):
"""
- Retourne la liste des noms des mots-cles fils de self presents construite
- a partir de self.mcListe
+ Retourne la liste des noms des mots-cles fils de self presents construite
+ a partir de self.mcListe
"""
- l=[]
+ l = []
for v in self.mcListe:
- k=v.nom
+ k = v.nom
l.append(k)
return l
- def getIndexChild(self,nom_fils):
+ 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
+ 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_ordonnee = self.getListeMcOrdonneeBrute(
+ self.getGenealogie(), cata_ordonne
+ )
liste_noms_mc_presents = self.listeMcPresents()
- index=0
+ 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
+ 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 :
+ 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)
+ 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
+ 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):
+ def ordonneListeMc(self, listeMc_a_ordonner, liste_noms_mc_ordonnee):
"""
- Retourne listeMc_a_ordonner ordonnee suivant l'ordre
- donne par 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
+ 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:
# on la retourne
return liste
- def suppEntite(self,objet) :
+ 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
+ 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)
+ # print ('suppEntite de MCCOMPO', self.nom,objet)
if not objet in self.mcListe:
# Impossible de supprimer objet. Il n'est pas dans mcListe
return 0
+ if objet.nom == "VariableProbabiliste":
+ if (
+ hasattr(objet[0], "variableDeterministe")
+ and objet[0].variableDeterministe
+ ):
+ objet[0].variableDeterministe.variableProbabiliste = None
+ objet[0].variableDeterministe.associeVariableUQ = False
self.initModif()
objet.delObjPyxb()
objet.deleteRef()
self.mcListe.remove(objet)
- CONNECTOR.Emit(self,"supp",objet)
+ CONNECTOR.Emit(self, "supp", objet)
objet.deleteMcGlobal()
objet.updateConditionBloc()
objet.supprime()
- while self.etape.doitEtreRecalculee == True :
- #print (' je suis dans le while')
+ while self.etape.doitEtreRecalculee == True:
+ # print (' je suis dans le while')
self.etape.doitEtreRecalculee = False
self.etape.deepUpdateConditionBlocApresSuppression()
self.etape.modified()
def isOblig(self):
return 0
- def addEntite(self,name,pos=None):
+ def addEntite(self, name, pos=None):
"""
- Ajoute le mot-cle name a la liste des mots-cles de
- l'objet MCCOMPOSE
+ Ajoute le mot-cle name a la liste des mots-cles de
+ l'objet MCCOMPOSE
"""
- #print ('addEntite', name, pos)
+ # 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 :
+ 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
# 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.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
# On cherche s'il existe deja un mot cle de meme nom
- old_obj = self.getChild(objet.nom,restreint = 'oui')
- if not old_obj :
+ old_obj = self.getChild(objet.nom, restreint="oui")
+ if not old_obj:
# on normalize l'objet
- objet=objet.normalize()
+ objet = objet.normalize()
# Le mot cle n'existe pas encore. On l'ajoute a la position
# demandee (pos)
- if pos == None :
+ if pos == None:
self.mcListe.append(objet)
- else :
- self.mcListe.insert(pos,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)
+ 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()
# 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.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))
+ 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):
+ 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
+ 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 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 :
+ else:
return 0
- #elif type(fils) == types.InstanceType:
- elif isinstance(fils,object):
+ # 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 :
if not fils.nom in self.definition.entites:
return 0
else:
- if fils.parent.nom != self.nom : return 0
+ if fils.parent.nom != self.nom:
+ return 0
return 1
- def updateConcept(self,sd):
- for child in self.mcListe :
+ def updateConcept(self, sd):
+ for child in self.mcListe:
child.updateConcept(sd)
- def deleteConcept(self,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
+ 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 :
+ for child in self.mcListe:
child.deleteConcept(sd)
- def replaceConcept(self,old_sd,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
+ 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)
+ for child in self.mcListe:
+ child.replaceConcept(old_sd, sd)
def getListeMcInconnus(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
+ 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]
def deepUpdateConditionBlocApresSuppression(self):
self._updateConditionBloc()
for mcobj in self.mcListe:
- if mcobj.nature=="MCList" :
- for obj in mcobj :
+ if mcobj.nature == "MCList":
+ for obj in mcobj:
obj.deepUpdateConditionBlocApresSuppression()
- obj.state='modified'
- elif hasattr(mcobj,"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()
+ # 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 :
+ if mcobj.nature == "MCList":
+ for obj in mcobj:
obj.deepUpdateConditionBlocApresCreation()
- obj.state='modified'
- elif hasattr(mcobj,"deepUpdateConditionBlocApresCreation"):
+ obj.state = "modified"
+ elif hasattr(mcobj, "deepUpdateConditionBlocApresCreation"):
mcobj.deepUpdateConditionBlocApresCreation()
- mcobj.state='modified'
- self.state='modified'
+ 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
+ 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"):
+ if hasattr(mcobj, "deepUpdateConditionBloc"):
mcobj.deepUpdateConditionBloc()
- mcobj.state='modified'
- if self.nature == 'PROCEDURE' :
- if self.doitEtreRecalculee :
+ 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
+ Realise l'update des blocs conditionnels fils de self
+ et propage au parent
"""
self._updateConditionBloc()
- if self.parent:self.parent.updateConditionBloc()
+ if self.parent:
+ self.parent.updateConditionBloc()
def _updateConditionBloc(self):
"""
- Realise l'update des blocs conditionnels fils de 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)
+ 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)
+ 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)
+ # print ("SUPPRESSION BLOC",k,bloc)
self.suppEntite(bloc)
- doitEtreReecrit=True
+ doitEtreReecrit = True
def verifConditionBloc(self):
"""
"""
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
+ 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 :
+ else:
# le bloc doit etre absent
- if self.getChild(k,restreint = 'oui'):
+ if self.getChild(k, restreint="oui"):
# le bloc est present : il faut l'enlever
liste_retraits.append(k)
- return liste_ajouts,liste_retraits
+ 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
+ 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 :
+ 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.
+ 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 :
+ for motcle in self.mcListe:
motcle.updateMcGlobal()
def deleteMcGlobal(self):
- for motcle in self.mcListe :
+ 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 :
+ # try :
# print (motcle)
# motcle.updateMcGlobal()
- #except :
+ # except :
# pass
def supprimeUserAssd(self):
def initModifUp(self):
Validation.V_MCCOMPO.MCCOMPO.initModifUp(self)
- CONNECTOR.Emit(self,"valid")
+ CONNECTOR.Emit(self, "valid")
# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
+# Copyright (C) 2007-2024 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-from __future__ import absolute_import
from Extensions.i18n import tr
from . import CONNECTOR
from . import I_MCCOMPO
-import Noyau
+from Noyau import N_MCFACT
+
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
+ 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 :
+ else:
return 0
def isOblig(self):
- if self.definition.statut != 'o' : return 0
+ if self.definition.statut != "o":
+ return 0
objet = self.parent.getChild(self.nom)
- if len(objet) > 1 : return 0
- else : return 1
+ 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
+ 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 :
+ 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
+ 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
+ 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 = 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)+':'
+ 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]
+ nom = self.getLabelText()
+ if nom[-1] == ":":
+ nom = nom[0:-1]
if self.parent:
- l=self.parent.getGenealogiePrecise()
+ l = self.parent.getGenealogiePrecise()
l.append(nom.strip())
return l
else:
return [nom.strip()]
+ def getMCPath(self):
+ objet = self.parent.getChild(self.nom, restreint="oui")
+ if objet is None or objet is self:
+ return "mauvais MCPath"
+ if len(objet) > 1:
+ index = objet.getIndex(self)
+ else:
+ index = 0
+ nom = self.nom
+ if self.parent:
+ l = self.parent.getMCPath()
+ else:
+ l = []
+ l.append(nom.strip())
+ l.append("@index " + str(index) + " @")
+ return l
def initModif(self):
"""
- Met l'etat de l'objet a modified et propage au parent
- qui vaut None s'il n'existe pas
+ 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
+ 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
+ Methode appelee apres qu'une modification a ete faite afin de declencher
+ d'eventuels traitements post-modification
"""
- #print "finModif",self
+ # 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
+ 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
+ """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.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)
+ self.alt_parent = None
+ N_MCFACT.MCFACT.supprime(self)
# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
+# Copyright (C) 2007-2024 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-from __future__ import absolute_import
-import types,traceback
+import types, traceback
from Extensions.i18n import tr
from Extensions.eficas_exception import EficasException
from copy import copy
from . import CONNECTOR
+
class MCList:
def isMCList(self):
"""
- Retourne 1 si self est une MCList (liste de mots-cles), 0 sinon (defaut)
+ Retourne 1 si self est une MCList (liste de mots-cles), 0 sinon (defaut)
"""
return 1
- def getIndex(self,objet):
+ def getIndex(self, objet):
"""
- Retourne la position d'objet dans la liste self
+ 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
+ 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'):
+ if max == "**" or max == float("inf"):
return 1
else:
- if len(self) < max :
+ 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
+ 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 :
+ 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'
+ return self.data[0].definition.statut == "o"
- def suppEntite(self,obj):
+ def suppEntite(self, obj):
"""
- Supprime le mot cle facteur obj de la MCLIST
+ 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)
+ CONNECTOR.Emit(self, "supp", obj)
self.updateConditionBloc()
obj.delObjPyxb()
obj.supprime()
self.etape.modified()
self.finModif()
+ if obj.nom == "VariableProbabiliste":
+ if obj.variableDeterministe:
+ obj.variableDeterministe.variableProbabiliste = None
+ obj.variableDeterministe.associeVariableUQ = False
return 1
- def addEntite(self,obj,pos=None):
+ 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
+ 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 :
+ 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))
+ 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]
+ obj = obj.data[0]
# traitement du copier coller seulement
# Les autres cas d'ajout sont traites dans MCFACT
if pos is None:
self.append(obj)
else:
- self.insert(pos,obj)
- CONNECTOR.Emit(self,"add",obj)
+ 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 :
+ def updateConcept(self, sd):
+ for child in self.data:
child.updateConcept(sd)
def deleteRef(self):
- for child in self.data :
+ for child in self.data:
child.deleteRef()
- def deleteConcept(self,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
+ 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 :
+ for child in self.data:
child.deleteConcept(sd)
- def replaceConcept(self,old_sd,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
+ 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)
+ for child in self.data:
+ child.replaceConcept(old_sd, sd)
def getDocu(self):
return self.data[0].definition.getDocu()
Retourne la liste des mots-cles inconnus dans self
"""
l_mc = []
- for mcfact in self.data :
- if mcfact.isValid() : continue
+ for mcfact in self.data:
+ if mcfact.isValid():
+ continue
l_child = mcfact.getListeMcInconnus()
for mc in l_child:
l = [self]
l_mc.append(l)
return l_mc
- def verifConditionRegles(self,liste_presents):
+ 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
+ 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
+ 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 :
+ # 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
+ 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()
+ 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
+ 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 [],[]
+ return [], []
def initModif(self):
"""
- Met l'etat de l'objet a modified et propage au parent
- qui vaut None s'il n'existe pas
+ Met l'etat de l'objet a modified et propage au parent
+ qui vaut None s'il n'existe pas
"""
- self.state = 'modified'
+ 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
+ Methode appelee apres qu'une modification a ete faite afin de declencher
+ d'eventuels traitements post-modification
"""
- #print "finModif",self
- CONNECTOR.Emit(self,"valid")
+ # print "finModif",self
+ CONNECTOR.Emit(self, "valid")
if self.parent:
self.parent.finModif()
else:
return []
+ def getMCPath(self):
+ if self.parent:
+ return self.parent.getMCPath()
+ 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 ????
+ 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):
+ 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 + ...
+ 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
+ dico = objet_cata.entites
+ return objet_cata.ordreMC
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
+ 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 :
+ 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
+ Retourne la chaine d'aide contenue dans le catalogue
+ en tenant compte de la langue
"""
- try :
+ try:
return self.data[0].getFr()
except:
- return ''
+ return ""
def normalize(self):
"""
- Retourne l'objet normalise. Une liste est deja normalisee
+ 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.
+ 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 :
+ for motcle in self.data:
motcle.updateMcGlobal()
def deleteMcGlobal(self):
- for motcle in self.data :
+ for motcle in self.data:
motcle.deleteMcGlobal()
-
- #def __del__(self):
+ # def __del__(self):
# print "__del__",self
# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
+# Copyright (C) 2007-2024 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-from __future__ import absolute_import
import types
import traceback
from copy import copy
# on ne peut pas les importer au debut.
# On fait donc un import local quand c'est necessaire (peut occasionner
# des pbs de prformance).
-from Noyau.N_ASSD import ASSD,assd
-from Noyau.N_GEOM import GEOM,geom
+from Noyau.N_ASSD import ASSD, assd
+from Noyau.N_GEOM import GEOM, geom
from Noyau.N_CO import CO
from Accas.A_ASSD import UserASSD
from Accas.A_ASSD import UserASSDMultiple
import Accas
+
# fin attention
from Extensions import parametre
from Extensions import param2
from . import I_OBJECT
from . import CONNECTOR
-from .I_VALIDATOR import ValError,listProto
-
-class MCSIMP(I_OBJECT.OBJECT):
+from .I_VALIDATOR import ValError, listProto
- def isValid(self,cr='non'):
- if self.state == 'unchanged':
+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':
- if hasattr(type_permis, "typElt") :
- self.monType=type_permis
+ # if hasattr(type_permis, "__class__") and type_permis.__class__.__name__ == 'Matrice':
+ if hasattr(type_permis, "typElt"):
+ self.monType = type_permis
return self.valideMatrice(cr=cr)
- validite=Validation.V_MCSIMP.MCSIMP.isValid(self,cr=cr)
+ validite = Validation.V_MCSIMP.MCSIMP.isValid(self, cr=cr)
if self.definition.siValide != None and validite:
self.definition.siValide(self)
return validite
-
def getNomConcept(self):
- p=self
- while p.parent :
- try :
- nomconcept=p.getSdname()
+ p = self
+ while p.parent:
+ try:
+ nomconcept = p.getSdname()
return nomconcept
except:
- try :
- nomconcept= p.object.getSdname()
+ try:
+ nomconcept = p.object.getSdname()
return nomconcept
- except :
+ except:
pass
- p=p.parent
+ p = p.parent
return ""
def getText(self):
"""
- Retourne le texte a afficher dans l'arbre representant la valeur de l'objet
- pointe par self
+ Retourne le texte a afficher dans l'arbre representant la valeur de l'objet
+ pointe par self
"""
- if self.valeur == None :
+ if self.valeur == None:
return None
- elif type(self.valeur) == float :
+ 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 :
+ 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)
+ 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=''
+ txt = "("
+ sep = ""
for val in self.valeur:
- if type(val) == float :
- clefobj=self.getNomConcept()
+ 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)
+ 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) or isinstance(i,str) : texteVal = texteVal +"'"+str(i)+"',"
- else : texteVal = texteVal + str(i)+','
- texteVal=texteVal[:-1]+')'
- else :
- if isinstance(val,bytes) or isinstance(val,str): texteVal="'"+str(val)+"'"
- else :texteVal=str(val)
- txt = txt + sep+ texteVal
-
-## if len(txt) > 200:
-## #ligne trop longue, on tronque
-## txt=txt+" ..."
-## break
- sep=','
+ if isinstance(val, tuple):
+ texteVal = "("
+ for i in val:
+ if isinstance(i, bytes) or isinstance(i, str):
+ texteVal = texteVal + "'" + str(i) + "',"
+ else:
+ texteVal = texteVal + str(i) + ","
+ texteVal = texteVal[:-1] + ")"
+ else:
+ if isinstance(val, bytes) or isinstance(val, str):
+ 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+')'
+ if isinstance(val, tuple) and len(self.valeur) == 1:
+ txt = txt + ","
+ txt = txt + ")"
else:
# traitement des autres cas
txt = str(self.valeur)
def getVal(self):
"""
- Retourne une chaine de caractere representant la valeur de 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] :
+ 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 :
+ 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()+','
+ else:
+ if val == () or val == []:
+ return val
+ s = "( "
+ for item in val:
+ try:
+ s = s + item.getName() + ","
except:
- s=s+repr(item)+','
- s=s+' )'
+ s = s + repr(item) + ","
+ s = s + " )"
return s
def waitBool(self):
for typ in self.definition.type:
- try :
- if typ == bool: return True
- except :
+ 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
+ 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) :
+ 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
+ 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) :
+ 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
+ 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) :
+ 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) :
+ 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' :
+ 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
+ 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) :
+ 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
+ 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
+ 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
+ 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
+ if typ == "TXM":
+ return 1
return 0
def waitTuple(self):
for ss_type in self.definition.type:
- if repr(ss_type).find('Tuple') != -1 :
+ if repr(ss_type).find("Tuple") != -1:
return 1
return 0
def waitChaineAvecBlancs(self):
- if self.definition.avecBlancs : return 1
+ if self.definition.avecBlancs:
+ return 1
return 0
def combienEltDsTuple(self):
for ss_type in self.definition.type:
- if hasattr(ss_type,'ntuple'):
- return ss_type.ntuple
- return O
+ if hasattr(ss_type, "ntuple"):
+ return ss_type.ntuple
+ return O
def waitMatrice(self):
- if hasattr(self, 'isAMatrice') : return self.isAMatrice
+ if hasattr(self, "isAMatrice"):
+ return self.isAMatrice
for typ in self.definition.type:
- try :
- if hasattr(typ, 'typElt') : self.isAMatrice=1; return 1
- except : pass
- self.isAMatrice=0
+ try:
+ if hasattr(typ, "typElt"):
+ self.isAMatrice = 1
+ return 1
+ except:
+ pass
+ self.isAMatrice = 0
return 0
def getListeValeurs(self):
- """
- """
+ """ """
if self.valeur == None:
return []
elif type(self.valeur) == tuple:
return [self.valeur]
def isOblig(self):
- return self.definition.statut=='o'
+ return self.definition.statut == "o"
def isImmuable(self):
- return self.definition.homo=='constant'
+ return self.definition.homo == "constant"
def isInformation(self):
- return self.definition.homo=='information'
+ return self.definition.homo == "information"
-
- def validVal(self,valeur):
+ def validVal(self, valeur):
"""
- Verifie que la valeur passee en argument (valeur) est valide
- sans modifier la valeur courante
+ Verifie que la valeur passee en argument (valeur) est valide
+ sans modifier la valeur courante
"""
- lval=listProto.adapt(valeur)
+ lval = listProto.adapt(valeur)
if lval is None:
- valid=0
- mess=tr("None n'est pas une valeur autorisee")
+ valid = 0
+ mess = tr("None n'est pas une valeur autorisee")
else:
try:
for val in lval:
self.cardProto.adapt(lval)
if self.definition.validators:
self.definition.validators.convert(lval)
- valid,mess=1,""
+ valid, mess = 1, ""
except ValError as e:
- mess=str(e)
- valid=0
- return valid,mess
+ mess = str(e)
+ valid = 0
+ return valid, mess
- def validValeur(self,new_valeur):
+ 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)
+ 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)
+ validite, mess = self.validVal(new_valeur)
return validite
- def validValeurPartielle(self,new_valeur):
+ 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
+ Verifie que la valeur passee en argument (new_valeur) est une liste partiellement valide
+ sans modifier la valeur courante du mot cle
"""
- validite=1
+ validite = 1
try:
for val in new_valeur:
self.typeProto.adapt(val)
self.intoProto.adapt(val)
- #on ne verifie pas la cardinalite
+ # on ne verifie pas la cardinalite
if self.definition.validators:
- validite=self.definition.validators.valideListePartielle(new_valeur)
+ validite = self.definition.validators.valideListePartielle(
+ new_valeur
+ )
except ValError as e:
- validite=0
+ validite = 0
return validite
def updateConditionBloc(self):
- """ Met a jour les blocs conditionnels dependant du mot cle simple self
- """
- if self.definition.position == 'global' :
+ """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' :
- print ('je passe par la pour ', self.nom)
+ elif self.definition.position == "reCalculeEtape":
+ # print ('je passe par updateConditionBloc pour ', self.nom)
self.etape.deepUpdateConditionBloc()
self.etape.demandeRedessine()
- elif self.definition.position == 'global_jdc' :
+ elif self.definition.position == "global_jdc":
self.jdc.deepUpdateConditionBloc(self)
self.etape.demandeRedessine()
- elif self.definition.position == 'inGetAttribut' :
+ elif self.definition.position == "inGetAttribut":
self.jdc.deepUpdateConditionBloc(self)
else:
self.parent.updateConditionBloc()
- def setValeur(self,new_valeur,evaluation='oui'):
+ 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)
+ 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()
+ if self.definition.metAJour != None:
+ self.updateAutresMotsClefs()
self.etape.modified()
self.finModif()
return 1
- def evalValeur(self,new_valeur):
+ 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)
+ 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)
+ 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
+ return sd, 1
+ lsd = self.jdc.chercheListAvant(self.etape, new_valeur)
+ if lsd:
+ return lsd, 1
else:
- d={}
+ 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
+ d["EVAL"] = Accas.EVAL
+ try:
+ objet = eval(new_valeur, d)
+ return objet, 1
except Exception:
- itparam=self.chercheItemParametre(new_valeur)
+ itparam = self.chercheItemParametre(new_valeur)
if itparam:
- return itparam,1
- try :
- object=eval(new_valeur.valeur,d)
- except :
+ return itparam, 1
+ try:
+ object = eval(new_valeur.valeur, d)
+ except:
pass
- if CONTEXT.debug : traceback.print_exc()
- return None,0
+ if CONTEXT.debug:
+ traceback.print_exc()
+ return None, 0
- def evalVal(self,new_valeur):
+ 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
+ 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))
+ 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 :
+ 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)
+ valeur = self.evalValItem(new_valeur)
return valeur
- def evalValItem(self,new_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)
+ 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]
+ valeur = self.jdc.sdsDict[new_valeur]
return valeur
elif self.etape and self.etape.parent:
- valeur=self.etape.parent.evalInContext(new_valeur,self.etape)
+ valeur = self.etape.parent.evalInContext(new_valeur, self.etape)
return valeur
else:
- try :
+ try:
valeur = eval(val)
return valeur
except:
- #traceback.print_exc()
+ # traceback.print_exc()
return new_valeur
pass
- def chercheItemParametre (self,new_valeur):
+ 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"]")]
+ nomparam = new_valeur[0 : new_valeur.find("[")]
+ indice = new_valeur[new_valeur.find("[") + 1 : new_valeur.find("]")]
for p in self.jdc.params:
- if p.nom == nomparam :
+ if p.nom == nomparam:
if int(indice) < len(p.getValeurs()):
- itparam=parametre.ITEM_PARAMETRE(p,int(indice))
+ 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) :
+ 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)
+ newVal = []
+ for v in self.valeur:
+ newVal.append(v.nom)
self.initModif()
- if hasattr(self, 'objPyxb') and self.objPyxb : self.setValeurObjPyxb(newVal)
+ 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)
+ if hasattr(self, "objPyxb") and self.objPyxb:
+ self.setValeurObjPyxb(sd.nom)
self.finModif()
- def deleteConcept(self,sd):
+ 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
+ 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 :
+ ##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 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.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)
+ 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.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":
+ # 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(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):
+ 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
+ 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 :
+ # 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.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
+ 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 = sd
+ self.val = sd
self.finModif()
- def setValeurCo(self,nomCO):
+ def setValeurCo(self, nomCO):
"""
- Affecte a self l'objet de type CO et de nom 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
+ 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')
+ 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")
+ 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()
+ cs = CONTEXT.getCurrentStep()
CONTEXT.unsetCurrentStep()
CONTEXT.setCurrentStep(step)
step.setEtapeContext(self.etape)
self.etape.getType_produit(force=1)
self.finModif()
step.resetContext()
- #print "setValeurCo",new_objet
- return 1,tr("Concept cree")
+ # 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
+ Verifie que les structures de donnees utilisees dans self existent bien dans le contexte
+ avant etape, sinon enleve la referea ces concepts
"""
- #print "verifExistenceSd"
+ # 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=[]
+ if type(self.valeur) in (tuple, list):
+ l = []
for sd in self.valeur:
- if isinstance(sd,ASSD) :
+ 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.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:
+ 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):
- #print ( 'dans renommeSdCree', self.jdc.sdsDict, self.valeur)
- 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 renommeSdCree(self, nouveauNom):
+ # print ( 'dans renommeSdCree', self.jdc.sdsDict, self.valeur)
+ 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')
+ 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')
-
-
+ 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
-
+ return self.definition.min, self.definition.max
def getType(self):
"""
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' :
+ """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 :
+ if etape.mc_globaux[self.nom] == self:
del etape.mc_globaux[self.nom]
- elif self.definition.position == 'reCalculeEtape' :
+ elif self.definition.position == "reCalculeEtape":
etape = self.getEtape()
- if etape :
+ if etape:
if self.nom in etape.mc_globaux:
- if etape.mc_globaux[self.nom] == self :
+ 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' :
+ # 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')
+ 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.
+ 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' :
+ if self.definition.position == "global":
etape = self.getEtape()
- if etape :
- etape.mc_globaux[self.nom]=self
- elif self.definition.position == 'reCalculeEtape' :
+ 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 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
+ 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
+ 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):
+ def valideItem(self, item):
"""Valide un item isole. Cet item est candidata l'ajout a la liste existante"""
- valid=1
+ valid = 1
try:
- #on verifie le type
+ # on verifie le type
self.typeProto.adapt(item)
- #on verifie les choix possibles
+ # on verifie les choix possibles
self.intoProto.adapt(item)
- #on ne verifie pas la cardinalite
+ # on ne verifie pas la cardinalite
if self.definition.validators:
- valid=self.definition.validators.verifItem(item)
+ valid = self.definition.validators.verifItem(item)
except ValError as e:
- #traceback.print_exc()
- valid=0
+ # traceback.print_exc()
+ valid = 0
return valid
- def verifType(self,item):
+ def verifType(self, item):
"""Verifie le type d'un item de liste"""
try:
- #on verifie le type
+ # on verifie le type
self.typeProto.adapt(item)
- #on verifie les choix possibles
+ # on verifie les choix possibles
self.intoProto.adapt(item)
- #on ne verifie pas la cardinalite mais on verifie les validateurs
+ # on ne verifie pas la cardinalite mais on verifie les validateurs
if self.definition.validators:
- valid=self.definition.validators.verifItem(item)
- comment=""
- valid=1
+ if hasattr(self.definition.validators, "set_MCSimp"):
+ self.definition.validators.set_MCSimp(self)
+ 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
- commentaire =''
- if self.valeur == None :
+ # traceback.print_exc()
+ comment = tr(e.__str__())
+ valid = 0
+ except Exception as e:
+ comment = tr(e.__str__())
+ valid = 0
+ return valid, comment
+
+ def valideMatrice(self, cr):
+ ok = 1
+ commentaire = ""
+ if self.valeur == None:
self.setValid(0)
return 0
- if self.monType.methodeCalculTaille != None :
+ if self.monType.methodeCalculTaille != None:
MCSIMP.__dict__[self.monType.methodeCalculTaille](*(self,))
- if len(self.valeur) == self.monType.nbLigs :
+ if len(self.valeur) == self.monType.nbLigs:
for i in range(len(self.valeur)):
- if len(self.valeur[i]) != self.monType.nbCols: ok=0
- else : ok=0
+ if len(self.valeur[i]) != self.monType.nbCols:
+ ok = 0
+ else:
+ ok = 0
- if not ok :
+ 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}))
+ 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]
- ok, commentaire = self.monType.verifItem(str(val),self.parent)
- if self.monType.typElt not in ('TXM','I','R') and type(val) != self.monType.typElt :
- ok=0; commentaire = 'mauvais type'; self.valeur=None
- if not ok :
+ val = self.valeur[i][j]
+ ok, commentaire = self.monType.verifItem(str(val), self.parent)
+ if (
+ self.monType.typElt not in ("TXM", "I", "R")
+ and type(val) != self.monType.typElt
+ ):
+ ok = 0
+ commentaire = "mauvais type"
+ self.valeur = None
+ if not ok:
self.setValid(0)
- if cr == 'oui' :
- self.cr.fatal(tr(commentaire))
+ if cr == "oui":
+ self.cr.fatal(tr(commentaire))
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 :
+ 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"))
+ if cr == "oui":
+ self.cr.fatal(tr("La matrice n'a pas le bon entete"))
return 0
- if self.monType.methodeCalculTaille != None :
+ 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
+ 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 :
+ 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}))
+ 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)
+ 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
+ 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),]
+ a = [
+ self.jdc.getDistributions(self.etape),
+ ]
for t in self.valeur[1:]:
a.append(t)
- self.valeur=a
-
+ self.valeur = a
def nbDeDistributions(self):
- listeVariables=self.jdc.getDistributions(self.etape)
- self.monType.nbLigs=len(listeVariables)
- self.monType.nbCols=len(listeVariables)
+ 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
+ nomDsXML = self.parent.getNomDsXML() + "." + self.nom
return nomDsXML
-
- def verifTypeIhm(self,val,cr='non'):
- try :
+ def verifTypeIhm(self, val, cr="non"):
+ try:
val.eval()
return 1
- except :
+ except:
traceback.print_exc()
pass
- return self.verifType(val,cr)
+ return self.verifType(val, cr)
- def verifTypeliste(self,val,cr='non') :
- verif=0
- for v in val :
- verif=verif+self.verifTypeIhm(v,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")
+ 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
+ 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 :
+ if self.definition.creeDesObjets:
val.deleteReference(self)
- else :
- if (hasattr (val, 'enleveUtilisePar')) : val.enleveUtilisePar(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 :
+ # print ('updateAutresMotsClefs')
+ for nomMC, Xpath in self.definition.metAJour:
+ exp = Xpath + '.getChild("' + nomMC + '")'
+ try:
lesMotsClefs = eval(exp)
- except :
+ except:
lesMotsClefs = []
- if not type(lesMotsClefs) in (list, tuple): lesMotsClefs=(lesMotsClefs,)
- if isinstance (lesMotsClefs, MCSIMP): lesMotsClefs=(lesMotsClefs,)
- listeEtapesDejaRedessinees=[]
- listeMotsClefsAppel=[]
+ 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 :
+ 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')
+ # print ('fin updateAutresMotsClefs')
+
+ def UQPossible(self):
+ # Plus facile de mettre cette methode dans le SIMP, car on connait son nom
+ # reflechir au TUI
+ if not hasattr(self.cata, "dictUQ"):
+ return False
+ if not (self.nom in self.cata.dictUQ.keys()):
+ return False
+ if not hasattr(self.cata, "dictUQConditions"):
+ return True
+ if not (self.nom in self.cata.dictUQConditions.keys()):
+ return True
+ maFonction = self.cata.dictUQConditions[self.nom][0]
+ argsLoi = self.cata.dictUQConditions[self.nom][1]
+ argsLoi["obj"] = self
+ return maFonction(**argsLoi)
+
+ def isUQActivate(self):
+ # valide uniquement pour les MCSIMP
+ # a reflechir a la relecture du .comm
+ return self.associeVariableUQ
+
+ def lieVariableUQ(self):
+ # print ('je passe dans lieVariableUQ')
+ self.associeVariableUQ = True
+ etapeIncertitude = self.jdc.getEtapesByName("ExpressionIncertitude")
+ if etapeIncertitude == []:
+ self.jdc.editor.tree.racine.appendChild("ExpressionIncertitude", "last")
+ etapeIncertitude = self.jdc.getEtapesByName("ExpressionIncertitude")
+ # Ou la la, que c est generique
+ # ajouter un op_construction
+ etapeIncertitude[0].buildSd()
+ etapeIncertitude = etapeIncertitude[0]
+ incertitudeInput = etapeIncertitude.getChildOrChildInBloc("Input")
+ nodeVariableProbabiliste = incertitudeInput.node.appendChild(
+ "VariableProbabiliste", "first"
+ )
+ # le buildChildren a une mcliste --> on est oblige de mettre first mais en fait c est last
+ # PN a cooriger
+ if nodeVariableProbabiliste.item.object.nature == "MCFACT":
+ newVariable = nodeVariableProbabiliste.item.object
+ else:
+ newVariable = nodeVariableProbabiliste.item.object[-1]
+ newVariable.variableDeterministe = self
+ self.variableProbabiliste = newVariable
+
+ if self.etape.nature == "OPERATEUR":
+ itemObjet = newVariable.addEntite("ObjectName", 0)
+ itemObjet.definition.addInto(self.etape.sd.nom)
+ itemObjet.setValeur(self.etape.sd.nom)
+ itemModelVariable = newVariable.getChild("ModelVariable")
+ itemModelVariable.setValeur(self.nom)
+
+ itemConsigne = newVariable.getChild("Consigne")
+ itemConsigne.setValeur(
+ "la valeur entrée pour {} est {}".format(self.nom, self.valeur)
+ )
+
+ itemXPath = newVariable.getChild("MCPath")
+ itemXPath.setValeur(self.getMCPath())
+ # print (itemXPath)
+
+ self.definition.siValide = self.changeValeursRefUQ
+
+ def changeValeursRefUQ(self, motClef):
+ debug = 0
+ if debug:
+ print("changeValeursRefUQ", motClef)
+ if debug:
+ print(self.nom)
+ # la premiere fois, si on a des MCFACT, la variable probabiliste n est pas encore a jour
+ if not hasattr(motClef, "variableProbabiliste"):
+ if debug:
+ print("pb ds changeValeursRefUQ")
+ return
+ itemConsigne = motClef.variableProbabiliste.getChild("Consigne")
+ itemConsigne.setValeur(
+ "la valeur entrée pour {} est {}".format(motClef.nom, motClef.valeur)
+ )
+
+ def delieVariableUQ(self):
+ debug = 0
+ if debug:
+ print("delieVariableUQ pour", self)
+ self.associeVariableUQ = False
+ # Attention, on n a pas le MCLIST mais le MCLIST(0) dans la variableProbabiliste
+ # si self est le seul alors on enleve la MCLIST du MCCOMPO
+ mcVP = self.variableProbabiliste.parent.getChild("VariableProbabiliste")
+ if len(mcVP) == 1:
+ ret = self.variableProbabiliste.parent.suppEntite(mcVP)
+ else:
+ ret = mcVP.suppEntite(self.variableProbabiliste)
+ return ret
# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
+# Copyright (C) 2007-2024 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
#
"""
"""
-from __future__ import absolute_import
-import Noyau
from . import CONNECTOR
import re
-conceptRE=re.compile(r'[a-zA-Z_]\w*$')
+
+conceptRE = re.compile(r"[a-zA-Z_]\w*$")
+
class OBJECT:
from Noyau.N_CO import CO
def isMCList(self):
"""
- Retourne 1 si self est une MCList (liste de mots-cles), 0 sinon (defaut)
+ Retourne 1 si self est une MCList (liste de mots-cles), 0 sinon (defaut)
"""
return 0
def getRegles(self):
"""
- Retourne les regles de self
+ Retourne les regles de self
"""
- if hasattr(self,'definition'):
+ if hasattr(self, "definition"):
return self.definition.regles
- elif hasattr(self,'regles'):
+ elif hasattr(self, "regles"):
return self.regles
- else :
+ 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
+ Met l'etat de l'objet a modified et propage au parent
+ qui vaut None s'il n'existe pas
"""
- self.state = 'modified'
+ self.state = "modified"
if self.parent:
self.parent.initModif()
Methode appelee apres qu'une modification a ete faite afin de declencher
d'eventuels traitements post-modification
"""
- #print "finModif",self
+ # 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")
+ CONNECTOR.Emit(self, "valid")
if self.parent:
self.parent.finModif()
def isRepetable(self):
"""
- Indique si l'objet est repetable
+ Indique si l'objet est repetable
"""
return 0
def listeMcPresents(self):
"""
- Retourne la liste des noms des mots cles presents
+ Retourne la liste des noms des mots cles presents
"""
return []
"""
return []
- def verifConditionRegles(self,liste_presents):
+ 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
+ Retourne la liste des mots-cles a rajouter pour satisfaire les regles
+ en fonction de la liste des mots-cles presents
"""
- liste=[]
+ liste = []
for regle in self.definition.regles:
- liste=regle.verifConditionRegle(liste,liste_presents)
+ 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
+ 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 [],[]
+ return [], []
def getGenealogiePrecise(self):
if self.parent:
- l=self.parent.getGenealogiePrecise()
+ l = self.parent.getGenealogiePrecise()
+ l.append(self.nom.strip())
+ return l
+ else:
+ return [self.nom.strip()]
+
+ def getMCPath(self):
+ if self.parent:
+ l = self.parent.getMCPath()
l.append(self.nom.strip())
return l
else:
+ # a priori on ne devrait pas passer la
+ print("Erreur dans getMCPath de I_OBJECT")
return [self.nom.strip()]
+ def getObjetByMCPath(self, MCPath):
+ debug = 0
+ if debug:
+ print("getObjetByMCPath pour", self, self.nom, MCPath)
+ nomFils = MCPath[0]
+ if debug:
+ print("self", self.nom)
+ if debug:
+ print("MCPath restant", MCPath[1:])
+ if MCPath[1:] == [] or MCPath[1:] == ():
+ if debug:
+ print("objFils", self.getChildOrChildInBloc(nomFils))
+ return self.getChildOrChildInBloc(nomFils)
+ else:
+ objetFils = self.getChildOrChildInBloc(nomFils)
+ if debug:
+ print("dans else", self, self.nom, objetFils, nomFils)
+ if MCPath[1].startswith("@index "):
+ indexObj = MCPath[1].split(" ")[1]
+ indexObj = int(indexObj.split(" ")[0])
+ if debug:
+ print("index de l objet", indexObj)
+ objetFils = objetFils.data[indexObj]
+ if debug:
+ print("objetFils cas Mclist", objetFils)
+ if MCPath[2:] == [] or MCPath[2:] == ():
+ return objetFils
+ else:
+ return objetFils.getObjetByMCPath(MCPath[2:])
+ return objetFils.getObjetByMCPath(MCPath[1:])
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
+ 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 = self.parent.getGenealogie()
l.append(self.nom.strip())
return l
else:
def getFr(self):
"""
- Retourne la chaine d'aide contenue dans le catalogue
- en tenant compte de la langue
+ 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)
+ # if 1 :
+ c = getattr(self.definition, self.jdc.lang)
return c
except:
- #else:
- try :
- c=getattr(self.definition,"fr")
+ # else:
+ try:
+ c = getattr(self.definition, "fr")
return c
- except :
- return ''
+ except:
+ return ""
- def updateConcept(self,sd):
+ 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).
+ """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 updateMcGlobal(self):
return
- #def __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"))
+ # 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")
+ # 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):
+ # 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 demandeRedessine(self):
- #print ('demandeRedessine pour', self.nom, self, tout)
- CONNECTOR.Emit(self,"redessine")
+ # print ('demandeRedessine pour', self.nom, self, tout)
+ CONNECTOR.Emit(self, "redessine")
def isUQActivate(self):
# valide uniquement pour les MCSIMP
return True
-class ErrorObj(OBJECT):pass
+class ErrorObj(OBJECT):
+ pass
# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
+# Copyright (C) 2007-2024 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
"""
"""
-from __future__ import absolute_import
from . import I_REGLE
+
class PRESENT_ABSENT(I_REGLE.REGLE):
- def purgeListe(self,liste_a_purger,listeMcPresents):
- regle_active=0
- if self.mcs[0] in listeMcPresents:regle_active=1
- if not regle_active : return liste_a_purger
+ 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 :
+ if mc in liste_a_purger:
liste_a_purger.remove(mc)
return liste_a_purger
# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
+# Copyright (C) 2007-2024 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
"""
"""
-from __future__ import absolute_import
from . import I_REGLE
+
class PRESENT_PRESENT(I_REGLE.REGLE):
- def verifConditionRegle(self,liste,l_mc_presents):
- mc0=self.mcs[0]
+ def verifConditionRegle(self, liste, l_mc_presents):
+ mc0 = self.mcs[0]
for mc_present in l_mc_presents:
- if mc_present == mc0 :
+ if mc_present == mc0:
for mc in self.mcs[1:]:
nb = l_mc_presents.count(mc)
- if nb == 0 : liste.append(mc)
+ if nb == 0:
+ liste.append(mc)
return liste
return liste
# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
+# Copyright (C) 2007-2024 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-from __future__ import absolute_import
from . import I_ETAPE
# import rajoutes suite a l'ajout de buildSd --> a resorber
import sys
-import traceback,types
-import Noyau
+import traceback, types
+from Noyau import N_PROC_ETAPE
from Noyau import N_Exception
from Noyau.N_Exception import AsException
from Extensions.eficas_exception import EficasException
+
class PROC_ETAPE(I_ETAPE.ETAPE):
def getSdname(self):
return ""
- def getSdprods(self,nom_sd):
+ 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
+ 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
+ Fonction: Lors d'une destruction d'etape, detruit tous les concepts produits
+ Une procedure n'en a aucun
"""
return
- def deleteConcept(self,sd):
+ 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
+ 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
+ Inputs :
+ - sd=concept detruit
"""
- for child in self.mcListe :
+ for child in self.mcListe:
child.deleteConcept(sd)
- def replaceConcept(self,old_sd,sd):
+ def replaceConcept(self, old_sd, sd):
"""
- Fonction : Mettre a jour les mots cles de l etape
- suite au remplacement du concept old_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
+ Inputs :
+ - old_sd=concept remplace
+ - sd=nouveau concept
"""
- for child in self.mcListe :
- child.replaceConcept(old_sd,sd)
+ for child in self.mcListe:
+ child.replaceConcept(old_sd, sd)
+
+ def getMCPath(self):
+ index = self.jdc.getIndex(self)
+ return [self.nom, "@index " + str(index) + " @"]
+
+ def delieIncertitude(self):
+ mcVP = self.getChild("Input").getChild("VariableProbabiliste")
+ for vp in mcVP:
+ vp.variableDeterministe.variableProbabilite = None
+ vp.variableDeterministe.associeVariableUQ = False
+ vp.variableDeterministe.definition.siValide = None
-#ATTENTION SURCHARGE: a garder en synchro ou a reintegrer dans le Noyau
+ # 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
+ 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 :
+ sd = 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
+ self.sd = None
+ self.sdnom = None
+ self.state = "unchanged"
+ self.valid = 0
# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
+# Copyright (C) 2007-2024 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
#
"""
"""
-from __future__ import absolute_import
-class REGLE:
+class REGLE:
def getText(self):
- text = self.__class__.__name__+ ' :\n'
- for mc in self.mcs :
- text = text + '\t' + mc.strip() + '\n'
+ 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):
+ 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
+ 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):
+ 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
+ if mc == nom:
+ return 1
return 0
- def verifConditionRegle(self,liste,l_mc_presents):
+ def verifConditionRegle(self, liste, l_mc_presents):
return []
# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
+# Copyright (C) 2007-2024 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+
class I_Matrice:
def activeCouleur(self):
- self.dictCouleurs={}
- self.indiceCouleur=1
- self.listeCouleurs=((10, 186, 181),(204, 204, 255),(121, 248, 248),(254, 231, 240),(250, 234, 115), (254, 191, 210),(248, 142, 85),(133, 193, 126),(210, 202, 236),(225, 206, 154), (187, 174, 152),(240, 195, 0),(242, 255, 255),(239, 239, 239),(149, 165, 149), (150, 131, 236),(201, 160, 220),(103, 159, 90),(176, 242, 182),(233, 201, 177))
-
+ self.dictCouleurs = {}
+ self.indiceCouleur = 1
+ self.listeCouleurs = (
+ (10, 186, 181),
+ (204, 204, 255),
+ (121, 248, 248),
+ (254, 231, 240),
+ (250, 234, 115),
+ (254, 191, 210),
+ (248, 142, 85),
+ (133, 193, 126),
+ (210, 202, 236),
+ (225, 206, 154),
+ (187, 174, 152),
+ (240, 195, 0),
+ (242, 255, 255),
+ (239, 239, 239),
+ (149, 165, 149),
+ (150, 131, 236),
+ (201, 160, 220),
+ (103, 159, 90),
+ (176, 242, 182),
+ (233, 201, 177),
+ )
# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
+# Copyright (C) 2007-2024 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
"""
"""
-from __future__ import absolute_import
from . import I_REGLE
-class UN_PARMI(I_REGLE.REGLE):
- def purgeListe(self,liste_a_purger,listeMcPresents):
- regle_active=0
+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
+ regle_active = 1
break
- if not regle_active : return liste_a_purger
+ if not regle_active:
+ return liste_a_purger
# Si un des mots cles est present, on les enleve tous
# sauf celui ci
# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
+# Copyright (C) 2007-2024 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-from __future__ import absolute_import
from Noyau.N_VALIDATOR import *
+
class Compulsory(Compulsory):
def hasInto(self):
return 0
- def valideListePartielle(self,liste_courante=None):
+
+ def valideListePartielle(self, liste_courante=None):
return 1
+
class OrdList(OrdList):
- def valideListePartielle(self,liste_courante=None):
+ def valideListePartielle(self, liste_courante=None):
"""
- Methode de validation de liste partielle pour le validateur OrdList
+ Methode de validation de liste partielle pour le validateur OrdList
"""
try:
self.convert(liste_courante)
- valid=1
- except :
- valid=0
+ valid = 1
+ except:
+ valid = 0
return valid
-class compareAutreMC(Valid) :
-#----------------------------
- def __init__(self,frere=None):
+
+
+class compareAutreMC(Valid):
+ # ----------------------------
+ def __init__(self, frere=None):
Valid.__init__(self, frere=frere)
- self.nomFrere=frere
+ self.nomFrere = frere
- def set_MCSimp (self, MCSimp):
+ def set_MCSimp(self, MCSimp):
debug = 1
- if debug : print ('je passe la pour ', self, MCSimp.nom)
- self.MCSimp=MCSimp
+ if debug:
+ print("je passe la pour ", self, MCSimp.nom)
+ self.MCSimp = MCSimp
+
class infFrereMC(compareAutreMC):
-#-------------------------------
+ # -------------------------------
def convert(self, valeur):
# on sort de cardProto on a une liste
- valeur=valeur[0]
- try: MCFrere=self.MCSimp.parent.getChildOrChildInBloc(self.nomFrere)
- except : return valeur
- if not MCFrere : return valeur
- if MCFrere== None : return valeur
- if MCFrere.valeur == None : return valeur
- if MCFrere.valeur < valeur :
- raise CataError('la valeur de '+self.nomFrere + ' est inferieure a la valeur entree ')
+ valeur = valeur[0]
+ try:
+ MCFrere = self.MCSimp.parent.getChildOrChildInBloc(self.nomFrere)
+ except:
+ return valeur
+ if not MCFrere:
+ return valeur
+ if MCFrere == None:
+ return valeur
+ if MCFrere.valeur == None:
+ return valeur
+ if MCFrere.valeur < valeur:
+ raise CataError(
+ "la valeur de " + self.nomFrere + " est inferieure a la valeur entree "
+ )
return valeur
def verifItem(self, valeur):
- try: MCFrere=self.MCSimp.parent.getChildOrChildInBloc(self.nomFrere)
- except : return valeur
- if not MCFrere : return valeur
- if MCFrere== None : return valeur
- if MCFrere.valeur == None : return valeur
- if MCFrere.valeur < valeur :
- raise CataError('la valeur de '+self.nomFrere + ' est inferieure a la valeur entree et doit etre superieure')
- return 0
+ try:
+ MCFrere = self.MCSimp.parent.getChildOrChildInBloc(self.nomFrere)
+ except:
+ return valeur
+ if not MCFrere:
+ return valeur
+ if MCFrere == None:
+ return valeur
+ if MCFrere.valeur == None:
+ return valeur
+ if MCFrere.valeur < valeur:
+ raise CataError(
+ "la valeur de "
+ + self.nomFrere
+ + " est inferieure a la valeur entree et doit etre superieure"
+ )
+ return 0
return 1
def infoErreurItem(self, valeur):
- return 'la valeur de '+self.nomFrere + ' est inferieure a la valeur entree et doit etre superieure'
+ return (
+ "la valeur de "
+ + self.nomFrere
+ + " est inferieure a la valeur entree et doit etre superieure"
+ )
def info(self):
- return 'la valeur de '+self.nomFrere + ' est inferieure a la valeur entree et doit etre superieure'
+ return (
+ "la valeur de "
+ + self.nomFrere
+ + " est inferieure a la valeur entree et doit etre superieure"
+ )
+
class supFrereMC(compareAutreMC):
-#--------------------------------
+ # --------------------------------
def convert(self, valeur):
# on sort de cardProto on a une liste
- valeur=valeur[0]
- MCFrere=self.MCSimp.parent.getChildOrChildInBloc(self.nomFrere)
- if not MCFrere : return valeur
- if MCFrere== None : return valeur
- if MCFrere.valeur > valeur :
- raise CataError('la valeur de '+self.nomFrere + ' est superieure a la valeur entree et doit etre inferieure')
+ valeur = valeur[0]
+ MCFrere = self.MCSimp.parent.getChildOrChildInBloc(self.nomFrere)
+ if not MCFrere:
+ return valeur
+ if MCFrere == None:
+ return valeur
+ if MCFrere.valeur > valeur:
+ raise CataError(
+ "la valeur de "
+ + self.nomFrere
+ + " est superieure a la valeur entree et doit etre inferieure"
+ )
return valeur
def verifItem(self, valeur):
- MCFrere=self.MCSimp.parent.getChildOrChildInBloc(self.nomFrere)
- if not MCFrere : return 1
- if MCFrere== None : return 1
- if MCFrere.valeur > valeur :
- raise CataError('la valeur de '+self.nomFrere + ' est superieure a la valeur entree et doit etre inferieure')
- return 0
+ MCFrere = self.MCSimp.parent.getChildOrChildInBloc(self.nomFrere)
+ if not MCFrere:
+ return 1
+ if MCFrere == None:
+ return 1
+ if MCFrere.valeur > valeur:
+ raise CataError(
+ "la valeur de "
+ + self.nomFrere
+ + " est superieure a la valeur entree et doit etre inferieure"
+ )
+ return 0
return 1
def infoErreurItem(self, valeur):
- return 'la valeur de '+self.nomFrere + ' est superieure a la valeur entree et doit etre inferieure'
+ return (
+ "la valeur de "
+ + self.nomFrere
+ + " est superieure a la valeur entree et doit etre inferieure"
+ )
def info(self):
- return 'la valeur de '+self.nomFrere + ' est superieure a la valeur entree '
-
+ return "la valeur de " + self.nomFrere + " est superieure a la valeur entree "
# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
+# Copyright (C) 2007-2024 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
