From dab9ed84a3da026742e8c7ba2398c8bccc0a8d72 Mon Sep 17 00:00:00 2001 From: PASCALE NOYRET Date: Fri, 8 Dec 2023 11:46:58 +0100 Subject: [PATCH] maj Ihm --- Ihm/CMakeLists.txt | 2 +- Ihm/CONNECTOR.py | 137 ++-- Ihm/I_ASSD.py | 29 +- Ihm/I_AVANT.py | 76 +-- Ihm/I_A_CLASSER.py | 20 +- Ihm/I_ENTITE.py | 45 +- Ihm/I_ETAPE.py | 446 +++++++------ Ihm/I_EVAL.py | 23 +- Ihm/I_EXCLUS.py | 14 +- Ihm/I_FICHIER.py | 26 +- Ihm/I_FONCTION.py | 60 +- Ihm/I_FORM_ETAPE.py | 283 ++++---- Ihm/I_JDC.py | 1115 +++++++++++++++++-------------- Ihm/I_JDC_CATA.py | 17 +- Ihm/I_LASSD.py | 3 +- Ihm/I_MACRO_ETAPE.py | 1369 ++++++++++++++++++++------------------ Ihm/I_MCBLOC.py | 9 +- Ihm/I_MCCOMPO.py | 482 ++++++++------ Ihm/I_MCFACT.py | 107 +-- Ihm/I_MCLIST.py | 204 +++--- Ihm/I_MCSIMP.py | 992 +++++++++++++++------------ Ihm/I_OBJECT.py | 160 +++-- Ihm/I_PRESENT_ABSENT.py | 16 +- Ihm/I_PRESENT_PRESENT.py | 13 +- Ihm/I_PROC_ETAPE.py | 81 ++- Ihm/I_REGLE.py | 24 +- Ihm/I_TUPLE.py | 31 +- Ihm/I_UN_PARMI.py | 14 +- Ihm/I_VALIDATOR.py | 146 ++-- Ihm/__init__.py | 2 +- 30 files changed, 3292 insertions(+), 2654 deletions(-) diff --git a/Ihm/CMakeLists.txt b/Ihm/CMakeLists.txt index e3ce0580..c8c84624 100644 --- a/Ihm/CMakeLists.txt +++ b/Ihm/CMakeLists.txt @@ -1,7 +1,7 @@ # -*- 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 diff --git a/Ihm/CONNECTOR.py b/Ihm/CONNECTOR.py index 31efdd4c..2aa337fc 100644 --- a/Ihm/CONNECTOR.py +++ b/Ihm/CONNECTOR.py @@ -1,5 +1,5 @@ -#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 @@ -34,8 +34,6 @@ listener(cargs+args) """ -from __future__ import absolute_import -from __future__ import print_function import traceback from copy import copy import weakref @@ -44,49 +42,49 @@ 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)] @@ -97,69 +95,76 @@ class CONNECTOR: 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)) @@ -167,24 +172,24 @@ if __name__ == "__main__": 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) diff --git a/Ihm/I_ASSD.py b/Ihm/I_ASSD.py index ae8caeb1..af35a788 100644 --- a/Ihm/I_ASSD.py +++ b/Ihm/I_ASSD.py @@ -1,5 +1,5 @@ # -*- 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 @@ -17,14 +17,11 @@ # # 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__ @@ -34,24 +31,30 @@ class ASSD: 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__) diff --git a/Ihm/I_AVANT.py b/Ihm/I_AVANT.py index 068823da..a84e82e8 100644 --- a/Ihm/I_AVANT.py +++ b/Ihm/I_AVANT.py @@ -1,5 +1,5 @@ # -*- 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 @@ -18,60 +18,56 @@ # 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 diff --git a/Ihm/I_A_CLASSER.py b/Ihm/I_A_CLASSER.py index fee92f3a..4868e9fc 100644 --- a/Ihm/I_A_CLASSER.py +++ b/Ihm/I_A_CLASSER.py @@ -1,5 +1,5 @@ # -*- 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 @@ -19,20 +19,18 @@ # """ """ - -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 diff --git a/Ihm/I_ENTITE.py b/Ihm/I_ENTITE.py index 97ca3ce1..d438eeba 100644 --- a/Ihm/I_ENTITE.py +++ b/Ihm/I_ENTITE.py @@ -1,5 +1,5 @@ # -*- 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 @@ -17,28 +17,30 @@ # # 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 @@ -46,8 +48,9 @@ class ENTITE: 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): @@ -55,24 +58,24 @@ class ENTITE: 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 diff --git a/Ihm/I_ETAPE.py b/Ihm/I_ETAPE.py index 31172dd2..d20c2169 100644 --- a/Ihm/I_ETAPE.py +++ b/Ihm/I_ETAPE.py @@ -1,5 +1,5 @@ # -*- 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 @@ -20,9 +20,7 @@ """ """ # Modules Python -from __future__ import absolute_import -from __future__ import print_function -import sys,re +import sys, re import types from copy import copy @@ -30,14 +28,14 @@ from Extensions.i18n import tr 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 @@ -45,90 +43,97 @@ from . import I_MCCOMPO 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: @@ -136,37 +141,39 @@ class ETAPE(I_MCCOMPO.MCCOMPO): # # 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 @@ -175,314 +182,327 @@ class ETAPE(I_MCCOMPO.MCCOMPO): 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 @@ -490,18 +510,24 @@ class ETAPE(I_MCCOMPO.MCCOMPO): 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 diff --git a/Ihm/I_EVAL.py b/Ihm/I_EVAL.py index 358cf606..95015cb0 100644 --- a/Ihm/I_EVAL.py +++ b/Ihm/I_EVAL.py @@ -1,4 +1,4 @@ -# 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 @@ -19,22 +19,23 @@ """ """ -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) diff --git a/Ihm/I_EXCLUS.py b/Ihm/I_EXCLUS.py index 8a5f443b..e481b25d 100644 --- a/Ihm/I_EXCLUS.py +++ b/Ihm/I_EXCLUS.py @@ -1,5 +1,5 @@ # -*- 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 @@ -19,18 +19,18 @@ # """ """ - -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 diff --git a/Ihm/I_FICHIER.py b/Ihm/I_FICHIER.py index 44754ae1..b3f7cfbf 100644 --- a/Ihm/I_FICHIER.py +++ b/Ihm/I_FICHIER.py @@ -1,5 +1,5 @@ # -*- 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 @@ -17,25 +17,25 @@ # # 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 diff --git a/Ihm/I_FONCTION.py b/Ihm/I_FONCTION.py index be2a3c3f..155309e9 100644 --- a/Ihm/I_FONCTION.py +++ b/Ihm/I_FONCTION.py @@ -1,5 +1,5 @@ # -*- 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 @@ -17,15 +17,14 @@ # # 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): @@ -33,38 +32,47 @@ class FONCTION(ASSD): 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 diff --git a/Ihm/I_FORM_ETAPE.py b/Ihm/I_FORM_ETAPE.py index 41ca29ac..e4129857 100644 --- a/Ihm/I_FORM_ETAPE.py +++ b/Ihm/I_FORM_ETAPE.py @@ -1,5 +1,5 @@ # -*- 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 @@ -18,9 +18,13 @@ # 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) @@ -29,22 +33,22 @@ from .I_MACRO_ETAPE import MACRO_ETAPE 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): """ @@ -56,40 +60,40 @@ class FORM_ETAPE(MACRO_ETAPE): """ 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. @@ -97,27 +101,32 @@ class FORM_ETAPE(MACRO_ETAPE): - 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. @@ -125,25 +134,25 @@ class FORM_ETAPE(MACRO_ETAPE): - 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. @@ -151,20 +160,20 @@ class FORM_ETAPE(MACRO_ETAPE): - 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. @@ -174,13 +183,13 @@ class FORM_ETAPE(MACRO_ETAPE): """ 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) @@ -189,56 +198,57 @@ class FORM_ETAPE(MACRO_ETAPE): - 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,'','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, "", "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 @@ -246,13 +256,13 @@ class FORM_ETAPE(MACRO_ETAPE): 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: @@ -265,29 +275,30 @@ class FORM_ETAPE(MACRO_ETAPE): # 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] @@ -306,7 +317,8 @@ class FORM_ETAPE(MACRO_ETAPE): self.actif = 1 self.initModif() nom = self.getNom() - if nom == '' : return + if nom == "": + return try: self.jdc.appendFonction(self.sd) except: @@ -319,32 +331,33 @@ class FORM_ETAPE(MACRO_ETAPE): """ 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() diff --git a/Ihm/I_JDC.py b/Ihm/I_JDC.py index e308f4d6..2e397d9b 100644 --- a/Ihm/I_JDC.py +++ b/Ihm/I_JDC.py @@ -1,5 +1,5 @@ # -*- 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 @@ -20,22 +20,22 @@ """ """ # 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 @@ -44,91 +44,95 @@ try: 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' @@ -138,45 +142,46 @@ class JDC(I_OBJECT.OBJECT): # 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(): @@ -184,176 +189,186 @@ class JDC(I_OBJECT.OBJECT): # 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() @@ -365,31 +380,32 @@ class JDC(I_OBJECT.OBJECT): 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 @@ -405,100 +421,128 @@ class JDC(I_OBJECT.OBJECT): # 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: @@ -515,49 +559,49 @@ class JDC(I_OBJECT.OBJECT): # 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) @@ -565,77 +609,100 @@ class JDC(I_OBJECT.OBJECT): 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): @@ -643,19 +710,19 @@ class JDC(I_OBJECT.OBJECT): 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 @@ -667,240 +734,276 @@ class JDC(I_OBJECT.OBJECT): """ # 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 @@ -908,13 +1011,13 @@ class JDC(I_OBJECT.OBJECT): 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 @@ -924,83 +1027,105 @@ class JDC(I_OBJECT.OBJECT): # 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 diff --git a/Ihm/I_JDC_CATA.py b/Ihm/I_JDC_CATA.py index 46ada13e..92503da8 100644 --- a/Ihm/I_JDC_CATA.py +++ b/Ihm/I_JDC_CATA.py @@ -1,5 +1,5 @@ # -*- 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 @@ -17,12 +17,12 @@ # # 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() @@ -31,12 +31,11 @@ class JDC_CATA: 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) diff --git a/Ihm/I_LASSD.py b/Ihm/I_LASSD.py index 975e3b64..888d5538 100644 --- a/Ihm/I_LASSD.py +++ b/Ihm/I_LASSD.py @@ -1,5 +1,5 @@ # -*- 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 @@ -18,6 +18,7 @@ # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # + class LASSD: def __repr__(self): return self.getName() diff --git a/Ihm/I_MACRO_ETAPE.py b/Ihm/I_MACRO_ETAPE.py index 5384ede5..4cfbf3bd 100644 --- a/Ihm/I_MACRO_ETAPE.py +++ b/Ihm/I_MACRO_ETAPE.py @@ -1,5 +1,5 @@ # -*- 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 @@ -20,69 +20,66 @@ """ """ # 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. @@ -91,106 +88,115 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): # 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() @@ -206,30 +212,36 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): # 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() @@ -239,76 +251,82 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): 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() @@ -317,11 +335,11 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): 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) @@ -330,27 +348,28 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): 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 = @@ -358,97 +377,101 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): 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() @@ -457,43 +480,43 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): 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() @@ -503,7 +526,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): # 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: @@ -511,87 +534,95 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): 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 @@ -599,30 +630,36 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): 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 @@ -632,556 +669,606 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): # 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 : @@ -1189,59 +1276,65 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): # 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) diff --git a/Ihm/I_MCBLOC.py b/Ihm/I_MCBLOC.py index c96a9f80..0a9a9fba 100644 --- a/Ihm/I_MCBLOC.py +++ b/Ihm/I_MCBLOC.py @@ -1,5 +1,5 @@ # -*- 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 @@ -17,9 +17,12 @@ # # 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() diff --git a/Ihm/I_MCCOMPO.py b/Ihm/I_MCCOMPO.py index c7cf0d25..7ef1100c 100644 --- a/Ihm/I_MCCOMPO.py +++ b/Ihm/I_MCCOMPO.py @@ -1,5 +1,5 @@ # -*- 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 @@ -19,9 +19,7 @@ # """ """ -from __future__ import absolute_import -from __future__ import print_function -import string,types,sys +import string, types, sys from copy import copy import traceback @@ -32,54 +30,56 @@ from Noyau.N_MCFACT import MCFACT 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() @@ -88,118 +88,136 @@ class MCCOMPO(I_OBJECT.OBJECT): # 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: @@ -207,27 +225,34 @@ class MCCOMPO(I_OBJECT.OBJECT): # 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() @@ -237,18 +262,19 @@ class MCCOMPO(I_OBJECT.OBJECT): 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 @@ -258,29 +284,35 @@ class MCCOMPO(I_OBJECT.OBJECT): # 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() @@ -290,32 +322,36 @@ class MCCOMPO(I_OBJECT.OBJECT): # 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 : @@ -325,37 +361,38 @@ class MCCOMPO(I_OBJECT.OBJECT): 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): """ @@ -363,10 +400,11 @@ class MCCOMPO(I_OBJECT.OBJECT): """ 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] @@ -377,78 +415,80 @@ class MCCOMPO(I_OBJECT.OBJECT): 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): """ @@ -461,51 +501,51 @@ class MCCOMPO(I_OBJECT.OBJECT): """ 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): @@ -514,4 +554,4 @@ class MCCOMPO(I_OBJECT.OBJECT): def initModifUp(self): Validation.V_MCCOMPO.MCCOMPO.initModifUp(self) - CONNECTOR.Emit(self,"valid") + CONNECTOR.Emit(self, "valid") diff --git a/Ihm/I_MCFACT.py b/Ihm/I_MCFACT.py index b42c028c..53adba33 100644 --- a/Ihm/I_MCFACT.py +++ b/Ihm/I_MCFACT.py @@ -1,5 +1,5 @@ # -*- 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 @@ -17,114 +17,137 @@ # # 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) diff --git a/Ihm/I_MCLIST.py b/Ihm/I_MCLIST.py index e52a5b5c..bc1345bd 100644 --- a/Ihm/I_MCLIST.py +++ b/Ihm/I_MCLIST.py @@ -1,5 +1,5 @@ # -*- 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 @@ -17,94 +17,99 @@ # # 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 @@ -114,8 +119,8 @@ class MCList: 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 @@ -123,36 +128,36 @@ class MCList: 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() @@ -162,8 +167,9 @@ class MCList: 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] @@ -171,57 +177,58 @@ class MCList: 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() @@ -231,66 +238,71 @@ class MCList: 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 diff --git a/Ihm/I_MCSIMP.py b/Ihm/I_MCSIMP.py index 159c8f67..0640b68d 100644 --- a/Ihm/I_MCSIMP.py +++ b/Ihm/I_MCSIMP.py @@ -1,5 +1,5 @@ # -*- 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 @@ -17,7 +17,6 @@ # # 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 @@ -37,103 +36,112 @@ from . import CONNECTOR # 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) @@ -147,145 +155,153 @@ class MCSIMP(I_OBJECT.OBJECT): 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: @@ -296,24 +312,23 @@ class MCSIMP(I_OBJECT.OBJECT): 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: @@ -322,262 +337,281 @@ class MCSIMP(I_OBJECT.OBJECT): 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) @@ -592,59 +626,63 @@ class MCSIMP(I_OBJECT.OBJECT): 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): """ @@ -653,233 +691,361 @@ class MCSIMP(I_OBJECT.OBJECT): 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 diff --git a/Ihm/I_OBJECT.py b/Ihm/I_OBJECT.py index 5a2c2701..575450fa 100644 --- a/Ihm/I_OBJECT.py +++ b/Ihm/I_OBJECT.py @@ -1,5 +1,5 @@ # -*- 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 @@ -19,12 +19,12 @@ # """ """ -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 @@ -32,27 +32,27 @@ class OBJECT: 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() @@ -61,22 +61,22 @@ class OBJECT: 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 [] @@ -89,42 +89,82 @@ class OBJECT: """ 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: @@ -132,28 +172,28 @@ class OBJECT: 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 @@ -163,38 +203,40 @@ class OBJECT: 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 diff --git a/Ihm/I_PRESENT_ABSENT.py b/Ihm/I_PRESENT_ABSENT.py index e4daed95..8dfc49e9 100644 --- a/Ihm/I_PRESENT_ABSENT.py +++ b/Ihm/I_PRESENT_ABSENT.py @@ -1,5 +1,5 @@ # -*- 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 @@ -20,17 +20,19 @@ """ """ -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 diff --git a/Ihm/I_PRESENT_PRESENT.py b/Ihm/I_PRESENT_PRESENT.py index e99cf8b6..d6a06247 100644 --- a/Ihm/I_PRESENT_PRESENT.py +++ b/Ihm/I_PRESENT_PRESENT.py @@ -1,5 +1,5 @@ # -*- 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 @@ -20,16 +20,17 @@ """ """ -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 diff --git a/Ihm/I_PROC_ETAPE.py b/Ihm/I_PROC_ETAPE.py index e4c19768..1d74997b 100644 --- a/Ihm/I_PROC_ETAPE.py +++ b/Ihm/I_PROC_ETAPE.py @@ -1,5 +1,5 @@ # -*- 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 @@ -17,78 +17,89 @@ # # 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 diff --git a/Ihm/I_REGLE.py b/Ihm/I_REGLE.py index ed43ffb9..6db1bd02 100644 --- a/Ihm/I_REGLE.py +++ b/Ihm/I_REGLE.py @@ -1,5 +1,5 @@ # -*- 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 @@ -19,31 +19,31 @@ # """ """ -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 [] diff --git a/Ihm/I_TUPLE.py b/Ihm/I_TUPLE.py index 519ba37a..c291ce62 100644 --- a/Ihm/I_TUPLE.py +++ b/Ihm/I_TUPLE.py @@ -1,5 +1,5 @@ # -*- 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 @@ -18,9 +18,30 @@ # 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), + ) diff --git a/Ihm/I_UN_PARMI.py b/Ihm/I_UN_PARMI.py index c44c8529..d618fac6 100644 --- a/Ihm/I_UN_PARMI.py +++ b/Ihm/I_UN_PARMI.py @@ -1,5 +1,5 @@ # -*- 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 @@ -20,18 +20,18 @@ """ """ -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 diff --git a/Ihm/I_VALIDATOR.py b/Ihm/I_VALIDATOR.py index f5434cbd..176c34bc 100644 --- a/Ihm/I_VALIDATOR.py +++ b/Ihm/I_VALIDATOR.py @@ -1,5 +1,5 @@ # -*- 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 @@ -18,92 +18,138 @@ # 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 " diff --git a/Ihm/__init__.py b/Ihm/__init__.py index 64162464..6024bd72 100644 --- a/Ihm/__init__.py +++ b/Ihm/__init__.py @@ -1,5 +1,5 @@ # -*- 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 -- 2.39.2