from __future__ import absolute_import
from __future__ import print_function
try :
- from builtins import object
+ from builtins import object
except : pass
class ASSD(object):
return self.etape[key]
def setName(self, nom):
- """Positionne le nom de self
+ """Positionne le nom de self
"""
self.nom = nom
return val == 'OUI'
- def getEficasAttribut(self, attribut):
+ def getEficasAttribut(self, attribut):
#print ('getEficasAttribut : ', self, attribut)
valeur=self.etape.getMocle(attribut)
try :
- valeur=self.etape.getMocle(attribut)
+ valeur=self.etape.getMocle(attribut)
except :
- valeur = None
+ valeur = None
#print (valeur)
return valeur
from .N_MCLIST import MCList
#print ('getEficasListOfAttributs pour', self,listeAttributs)
aTraiter=(self.etape,)
- while len(listeAttributs) > 0 :
- attribut=listeAttributs.pop(0)
- print ("attribut", attribut)
- nvListe=[]
- for mc in aTraiter :
- print (mc)
- try :
- resultat=mc.getMocle(attribut)
- if isinstance(resultat,MCList):
- for rmc in resultat : nvListe.append(rmc)
- else : nvListe.append(resultat)
- except : pass
- aTraiter=nvListe
+ while len(listeAttributs) > 0 :
+ attribut=listeAttributs.pop(0)
+ print ("attribut", attribut)
+ nvListe=[]
+ for mc in aTraiter :
+ print (mc)
+ try :
+ resultat=mc.getMocle(attribut)
+ if isinstance(resultat,MCList):
+ for rmc in resultat : nvListe.append(rmc)
+ else : nvListe.append(resultat)
+ except : pass
+ aTraiter=nvListe
#print ('fin getEficasListOfAttributs ', nvListe)
return nvListe
-
+
def longueurDsArbre(self):
- longueur=0
- for mc in self.mcListe :
- longueur = longueur + mc.longueurDsArbre()
- return longueur
+ longueur=0
+ for mc in self.mcListe :
+ longueur = longueur + mc.longueurDsArbre()
+ return longueur
def blocUtils():
"""Définit un ensemble de fonctions utilisables pour écrire les
from __future__ import absolute_import
try:
- from builtins import object
+ from builtins import object
except : pass
from .N_types import isInt, isFloat, isSequence
if 'I' in typ : return _convertI
elif 'R' in typ : return _convertR
if name == 'UserASSD':
- return (UserASSDConversion(typ))
+ return (UserASSDConversion(typ))
if name == 'UserASSDMultiple':
- return (UserASSDMultipleConversion(typ))
+ return (UserASSDMultipleConversion(typ))
return None
from __future__ import absolute_import
try :
- from builtins import str
- from builtins import object
+ from builtins import str
+ from builtins import object
except :
- pass
+ pass
import six
from __future__ import absolute_import
from __future__ import print_function
try :
- from builtins import str
- from builtins import object
+ from builtins import str
+ from builtins import object
except :
- pass
+ pass
import re
from . import N_CR
from . import N_OPS
"""
Cette methode doit retourner un objet dérivé de la classe OBJECT
"""
-
+
raise NotImplementedError("La méthode __call__ de la classe %s doit être implémentée"
% self.__class__.__name__)
if self.txtNomComplet != '' : return self.txtNomComplet
qui=self
while hasattr(qui, 'pere' ):
- self.txtNomComplet+='_'+qui.nom
- qui=qui.pere
+ self.txtNomComplet+='_'+qui.nom
+ qui=qui.pere
self.txtNomComplet+='_'+qui.nom
return self.txtNomComplet
geneaCompleteSousFormeDeListe=[]
qui=self
while hasattr(qui, 'pere' ):
- geneaCompleteSousFormeDeListe.append(qui)
- qui=qui.pere
+ geneaCompleteSousFormeDeListe.append(qui)
+ qui=qui.pere
geneaCompleteSousFormeDeListe.append(qui)
return geneaCompleteSousFormeDeListe
ouChercher=self
for mot in listeMCAvant:
try :
- ouChercher=ouChercher.entites[mot]
+ ouChercher=ouChercher.entites[mot]
except :
- print ('impossible de trouver : ',mot,' ',listeMCAvant)
+ print ('impossible de trouver : ',mot,' ',listeMCAvant)
(nomMC,defMC)=args.items()[0]
defMC.pere = ouChercher
defMC.pere.propageRedefinit()
ouChercher=self
for mot in listeMCAvant:
try :
- ouChercher=ouChercher.entites[mot]
+ ouChercher=ouChercher.entites[mot]
except :
- print ('impossible de trouver : ',mot,' ',listeMCAvant)
+ print ('impossible de trouver : ',mot,' ',listeMCAvant)
monSIMP=ouChercher
for (nomAttributDef,valeurAttributDef) in args.items():
- if hasattr(monSIMP, nomAttributDef) :
- setattr(monSIMP, nomAttributDef, valeurAttributDef)
- else :
- print ('pb avec ', nomAttributdef,valeurAttributMC)
+ if hasattr(monSIMP, nomAttributDef) :
+ setattr(monSIMP, nomAttributDef, valeurAttributDef)
+ else :
+ print ('pb avec ', nomAttributdef,valeurAttributMC)
monSIMP.propageRedefinit()
def propageRedefinit(self):
- # a reflechir
- self.redefinit=True
- # PNPN il faut remonter a l etape
-
+ # a reflechir
+ self.redefinit=True
+ # PNPN il faut remonter a l etape
+
def makeObjetPourVerifSignature(self,*args,**kwargs):
def dumpStructure(self,decal=0):
- if self.label == 'SIMP':
- texte = decal * ' ' + self.nom + ' \n'
- return texte
- texte = decal * ' ' + self.nom
- if self.label == 'BLOC' : texte+= " " + self.condition
+ if self.label == 'SIMP':
+ texte = decal * ' ' + self.nom + ' \n'
+ return texte
+ texte = decal * ' ' + self.nom
+ if self.label == 'BLOC' : texte+= " " + self.condition
if self.label == 'OPER' : texte+ " " + str(self.sd_prod) + "\n"
texte+=' \n'
for c in self.entites.values():
texte+=c.dumpStructure(decal+1)
texte += decal * ' ' + 'fin pour ' + self.nom + ' \n'
return texte
-
from __future__ import absolute_import
from __future__ import print_function
try :
- from builtins import str
+ from builtins import str
except :
- pass
+ pass
import types
import sys
import os
# faut il le faire ds MC_Build ?
# traitement de Pyxb si Pyxb
self.dicoPyxbDeConstruction = args.get('dicoPyxbDeConstruction', None)
- if self.dicoPyxbDeConstruction :
+ if self.dicoPyxbDeConstruction :
del args['dicoPyxbDeConstruction']
self.objPyxbDeConstruction=self.dicoPyxbDeConstruction['objEnPyxb']
- else :
+ else :
self.objPyxbDeConstruction=None
self.definition = oper
self.reuse = reuse
# pourrait etre appelee par une commande fortran faisant appel a des fonctions python
# on passe la main au parent
return self.parent.getConcept(nomsd)
-
list_instance = N_MCLIST.MCList
label = 'FACT'
- def __init__(self, fr="", docu="", regles=(), statut='f', defaut=None,ang="",fenetreIhm=None,
+ def __init__(self, fr="", docu="", regles=(), statut='f', defaut=None,ang="",fenetreIhm=None,
min=0, max=1, validators=None, **args):
"""
Un mot-clé facteur est caractérisé par les attributs suivants :
for v in val:
if type(v) == dict or isinstance(v, _F):
if dicoPyxbDeConstruction :
- objet = self.class_instance(
- nom=nom, definition=self, val=v, parent=parent,dicoPyxbDeConstruction=dicoPyxbDeConstruction[indice])
- else :
- objet = self.class_instance(
- nom=nom, definition=self, val=v, parent=parent,dicoPyxbDeConstruction=None)
+ objet = self.class_instance(
+ nom=nom, definition=self, val=v, parent=parent,dicoPyxbDeConstruction=dicoPyxbDeConstruction[indice])
+ else :
+ objet = self.class_instance(
+ nom=nom, definition=self, val=v, parent=parent,dicoPyxbDeConstruction=None)
indice=indice+1
l.append(objet)
elif isinstance(v, self.class_instance):
-# if faut gerer ici --> on passe la avec une liste de concept ?
+# if faut gerer ici --> on passe la avec une liste de concept ?
# PNPN --> si pyxb
l.append(v)
else:
l.append(N_OBJECT.ErrorObj(self, v, parent, nom))
elif type(val) == dict or isinstance(val, _F):
- if dicoPyxbDeConstruction :
+ if dicoPyxbDeConstruction :
objet = self.class_instance(
nom=nom, definition=self, val=val, parent=parent,dicoPyxbDeConstruction=dicoPyxbDeConstruction)
- else :
+ else :
objet = self.class_instance(
nom=nom, definition=self, val=val, parent=parent,dicoPyxbDeConstruction=None)
- l.append(objet)
+ l.append(objet)
elif isinstance(val, self.class_instance):
-# idem --> quand passe t on la
+# idem --> quand passe t on la
l.append(val)
else:
l.append(N_OBJECT.ErrorObj(self, val, parent, nom))
# pour tenir compte du validateFonction
- if l.jdc :
- l.cata=l.jdc.cata
- l.buildObjPyxb(l)
+ if l.jdc :
+ l.cata=l.jdc.cata
+ l.buildObjPyxb(l)
return l
def verifCata(self):
self.checkDocu()
self.checkValidators()
self.verifCataRegles()
-
-
from __future__ import division
from __future__ import absolute_import
try :
- from builtins import zip
- from builtins import str
+ from builtins import zip
+ from builtins import str
except :
- pass
+ pass
from math import sin, cos, tan, asin, acos, atan2, atan, sinh, cosh, tanh
from math import pi, exp, log, log10, sqrt
from __future__ import absolute_import
from __future__ import print_function
try :
- from builtins import str
- from builtins import range
+ from builtins import str
+ from builtins import range
except : pass
import os
import traceback
Cette methode execute le jeu de commandes compile dans le contexte
self.g_context de l'objet JDC
"""
-
+
CONTEXT.setCurrentStep(self)
# Le module nommage utilise le module linecache pour acceder
# au source des commandes du jeu de commandes.
init2 = "from " + obj_cata.__name__ + " import *"
exec(init2, self.g_context)
else :
- # ici on a un catalogue en grammaire Eficas XML
- # il faut ajouter ce qu on a construit au contexte
- for (k,v) in obj_cata.contexteXML.items() :
- self.g_context[k]=v
+ # ici on a un catalogue en grammaire Eficas XML
+ # il faut ajouter ce qu on a construit au contexte
+ for (k,v) in obj_cata.contexteXML.items() :
+ self.g_context[k]=v
# Initialisation du contexte global pour l'evaluation des conditions de BLOC
# On utilise une copie de l'initialisation du contexte du jdc
self.condition_context = self.g_context.copy()
def regUserSD(self,sd):
# utilisee pour creer les references
# se contente d appeler la methode equivalente sur le jdc
- id=self.regSD(sd)
- self.nommerSDProd(sd,sd.nom)
- return id
+ id=self.regSD(sd)
+ self.nommerSDProd(sd,sd.nom)
+ return id
def regSD(self, sd):
# if os.path.exists("fort." + str(unite)):
# fname = "fort." + str(unite)
if fname == None:
- raise AsException("Impossible de trouver le fichier correspondant")
+ raise AsException("Impossible de trouver le fichier correspondant")
if not os.path.exists(fname):
- raise AsException(fname + " n'est pas un fichier existant" )
+ raise AsException(fname + " n'est pas un fichier existant" )
fproc = open(fname, 'r')
text = fproc.read()
fproc.close()
self._reserved_kw.difference_update(
['OPER', 'MACRO', 'BLOC', 'SIMP', 'FACT', 'FORM',
'GEOM', 'MCSIMP', 'MCFACT'])
-
-
self.dictTypesASSDorUserASSDUtilises={}
self.listeUserASSDDumpes=set()
-
+
def __call__(self, procedure=None, cata=None, cata_ord_dico=None,
nom='SansNom', parent=None, **args):
"""
"""
return self.d_niveaux.get(nom_niveau, None)
-
+
def dumpStructure(self):
texte=""
for c in self.commandes:
- if not(c.label != "OPER") and not(c.label != 'PROC') : continue
- if c.label == "OPER" : texte+=c.nom + " "+ str(c.sd_prod) + "\n"
- if c.label == "PROC" : texte+=c.nom + " \n"
- texte+=c.dumpStructure()
+ if not(c.label != "OPER") and not(c.label != 'PROC') : continue
+ if c.label == "OPER" : texte+=c.nom + " "+ str(c.sd_prod) + "\n"
+ if c.label == "PROC" : texte+=c.nom + " \n"
+ texte+=c.dumpStructure()
return texte
from __future__ import absolute_import
from __future__ import print_function
try :
- from builtins import str
+ from builtins import str
except : pass
import types
import sys
Construit la liste des sous-entites du MCCOMPO
à partir du dictionnaire des arguments (valeur)
"""
-
+
#print(("____________________________MCCOMPO.buildMc ", self.nom))
if CONTEXT.debug:
print(("MCCOMPO.buildMc ", self.nom))
args = self.valeur
if args == None: args = {}
mcListe = []
-
+
# On recopie le dictionnaire des arguments pour protéger l'original des
# delete (del args[k])
# si une valeur existe dans args ou est obligatoire (generique si toutes les
# entites ont l attribut statut )
#
- if self.dicoPyxbDeConstruction and k in self.dicoPyxbDeConstruction :
- objPyxbDeConstruction=self.dicoPyxbDeConstruction[k]
- del self.dicoPyxbDeConstruction[k]
+ if self.dicoPyxbDeConstruction and k in self.dicoPyxbDeConstruction :
+ objPyxbDeConstruction=self.dicoPyxbDeConstruction[k]
+ del self.dicoPyxbDeConstruction[k]
else :
- objPyxbDeConstruction=None
+ objPyxbDeConstruction=None
#print (args.get(k, None))
objet = v(val=args.get(k, None), nom=k, parent=self,objPyxbDeConstruction=objPyxbDeConstruction)
mcListe.append(objet)
# si une valeur existe dans args ou est obligatoire (generique si toutes les
# entites ont l attribut statut )
#
- if self.dicoPyxbDeConstruction and k in self.dicoPyxbDeConstruction :
- dicoPyxbDeConstruction=self.dicoPyxbDeConstruction[k]
- del self.dicoPyxbDeConstruction[k]
+ if self.dicoPyxbDeConstruction and k in self.dicoPyxbDeConstruction :
+ dicoPyxbDeConstruction=self.dicoPyxbDeConstruction[k]
+ del self.dicoPyxbDeConstruction[k]
else :
- dicoPyxbDeConstruction=None
+ dicoPyxbDeConstruction=None
objet = v(val=args.get(k, None), nom=k, parent=self,dicoPyxbDeConstruction=dicoPyxbDeConstruction)
mcListe.append(objet)
if k in args:
def buildMcApresGlobalEnSuppression(self):
blocsDejaLa=[]
for mc in self.mcListe :
- if mc.nature == 'MCBLOC' : blocsDejaLa.append(mc)
+ if mc.nature == 'MCBLOC' : blocsDejaLa.append(mc)
for mc in blocsDejaLa :
dico_valeurs = self.creeDictCondition(self.mcListe, condition=1)
globs = self.jdc and self.jdc.condition_context or {}
defBloc = mc.definition
if not (defBloc.verifPresence(dico_valeurs, globs)):
- self.suppEntite(mc)
-
-
+ self.suppEntite(mc)
+
+
def reConstruitResteVal(self):
# normal que apres buildMcApresGlobalEnCreation les reste_val ne soient pas corrects
for mc in self.mcListe :
- if mc.nom in self.reste_val :
- del self.reste_val[mc.nom]
+ if mc.nom in self.reste_val :
+ del self.reste_val[mc.nom]
if mc.nature == 'MCBLOC' :
- ancetre=mc.parent
- for mcFDuMc in mc.mcListe :
- while ancetre.nature == 'MCBLOC' :
- ancetre=ancetre.parent
- if mcFDuMc.nom in ancetre.reste_val : del ancetre.reste_val[mcFDuMc.nom]
+ ancetre=mc.parent
+ for mcFDuMc in mc.mcListe :
+ while ancetre.nature == 'MCBLOC' :
+ ancetre=ancetre.parent
+ if mcFDuMc.nom in ancetre.reste_val : del ancetre.reste_val[mcFDuMc.nom]
if mc.nature == 'MCSIMP' : continue
if mc.nature == 'MCList' :
- for mcObj in mc.data :
- mcObj.reConstruitResteVal()
+ for mcObj in mc.data :
+ mcObj.reConstruitResteVal()
else :
- mc.reConstruitResteVal()
+ mc.reConstruitResteVal()
def buildMcApresGlobalEnCreation(self):
nouveau_args = self.reste_val
blocsDejaLa=[]
for mc in self.mcListe :
- if mc.nature == 'MCBLOC' : blocsDejaLa.append(mc.nom)
+ if mc.nature == 'MCBLOC' : blocsDejaLa.append(mc.nom)
for k, v in list(self.definition.entites.items()):
if v.label != 'BLOC': continue
if k in blocsDejaLa : continue
if v.verifPresence(dico_valeurs, globs):
bloc = v(nom=k, val=nouveau_args, parent=self,dicoPyxbDeConstruction=self.dicoPyxbDeConstruction)
if bloc :
- self.mcListe.append(bloc)
- bloc.addObjPyxb(self.chercheIndiceDsLeContenu(bloc))
- nouveau_args = self.reste_val
- self.reste_val = bloc.reste_val
-
+ self.mcListe.append(bloc)
+ bloc.addObjPyxb(self.chercheIndiceDsLeContenu(bloc))
+ nouveau_args = self.reste_val
+ self.reste_val = bloc.reste_val
+
def ordonneListe(self, mcListe):
"""
etape = self.getEtape()
if etape:
nom = mc.nom
- if not(nom in etape.mc_globaux) :
- etape.doitEtreRecalculee = True
+ if not(nom in etape.mc_globaux) :
+ etape.doitEtreRecalculee = True
etape.mc_globaux[nom] = mc
#print ('ajout de nom', mc.nom, 'ds les mc_globaux de', etape.nom)
-
+
def append_mc_global(self, mc):
"""
Ajoute le mot-clé mc à la liste des mots-clés globaux de l'étape
"""
-
+
etape = self.getEtape()
if etape:
nom = mc.nom
#traceback.print_stack()
self.dicoPyxbDeConstruction=dicoPyxbDeConstruction
if self.dicoPyxbDeConstruction :
- self.objPyxbDeConstruction=self.dicoPyxbDeConstruction['objEnPyxb']
- del self.dicoPyxbDeConstruction['objEnPyxb']
+ self.objPyxbDeConstruction=self.dicoPyxbDeConstruction['objEnPyxb']
+ del self.dicoPyxbDeConstruction['objEnPyxb']
else :
- self.objPyxbDeConstruction=None
+ self.objPyxbDeConstruction=None
self.definition = definition
self.nom = nom
self.val = val
from __future__ import absolute_import
try :
- from future import standard_library
- standard_library.install_aliases()
-except :
- pass
+ from future import standard_library
+ standard_library.install_aliases()
+except :
+ pass
from copy import copy
import types
try:
- from UserList import UserList
+ from UserList import UserList
except ImportError:
- from collections import UserList
+ from collections import UserList
for objFils in obj.getChild(name) :
maListeRetour.append(objFils)
return maListeRetour
-
+
def isBLOC(self):
"""
del dico[i]
dresu.append(dico)
return dresu
-
+
def longueurDsArbre(self):
# pour Pyxb : longueur dans le orderedcontent de pyxb
return len(self)
self.cata = None
self.niveau = None
self.etape = None
- if self.definition.creeDesObjets :
- if issubclass(self.definition.creeDesObjetsDeType, UserASSDMultiple) :
- self.convProto = ConversionFactory('UserASSDMultiple', self.definition.creeDesObjetsDeType)
- else :
- self.convProto = ConversionFactory('UserASSD', self.definition.creeDesObjetsDeType)
- else :
- self.convProto = ConversionFactory('type', typ=self.definition.type)
+ if self.definition.creeDesObjets :
+ if issubclass(self.definition.creeDesObjetsDeType, UserASSDMultiple) :
+ self.convProto = ConversionFactory('UserASSDMultiple', self.definition.creeDesObjetsDeType)
+ else :
+ self.convProto = ConversionFactory('UserASSD', self.definition.creeDesObjetsDeType)
+ else :
+ self.convProto = ConversionFactory('type', typ=self.definition.type)
self.valeur = self.getValeurEffective(self.val)
if self.definition.utiliseUneReference :
- if self.valeur != None:
- if not type(self.valeur) in (list, tuple): self.valeur.ajoutUtilisePar(self)
- else :
- #PNPN --> chgt pour Vimmp
- for v in self.valeur :
- try : v.ajoutUtilisePar(self)
- except : print ('il y a un souci ici', self.nom, self.valeur)
+ if self.valeur != None:
+ if not type(self.valeur) in (list, tuple): self.valeur.ajoutUtilisePar(self)
+ else :
+ #PNPN --> chgt pour Vimmp
+ for v in self.valeur :
+ try : v.ajoutUtilisePar(self)
+ except : print ('il y a un souci ici', self.nom, self.valeur)
self.buildObjPyxb()
self.listeNomsObjsCrees = []
Attention aux UserASSD et aux into (exple Wall gp de maille et 'Wall')
"""
if (val is None and hasattr(self.definition, 'defaut')): val = self.definition.defaut
- if self.definition.type[0] == 'TXM' and isinstance(val,str) : return val
- if self.definition.creeDesObjets :
- # isinstance(val, self.definition.creeDesObjetsDeType) ne fonctionne pas car il y a un avec cata devant et l autre non
- if val == None : return val
- if not isinstance(val,(list,tuple)) : valATraiter=[val,]
- else : valATraiter=val
- listeRetour=[]
- for v in valATraiter:
- if (not(v.__class__.__name__ == self.definition.creeDesObjetsDeType.__name__)) :
- if self.jdc != None and v in list(self.jdc.sdsDict.keys()): v=self.jdc.sdsDict[v]
- else : v=self.convProto.convert(v)
- if v.parent== None : v.initialiseParent(self)
- if issubclass(self.definition.creeDesObjetsDeType, UserASSDMultiple) :
- v.ajouteUnPere(self)
- else :
- if v.nom=='sansNom' :
- for leNom,laVariable in self.jdc.g_context.items():
- if id(laVariable)== id(v) and (leNom != 'sansNom'):
- v.initialiseNom(leNom)
- if v.parent== None : v.initialiseParent(self)
- if issubclass(self.definition.creeDesObjetsDeType, UserASSDMultiple) :
- v.ajouteUnPere(self)
- listeRetour.append(v)
- if isinstance(val,(list,tuple)) :newVal=listeRetour
- else : newVal=listeRetour[0]
- return newVal
+ if self.definition.type[0] == 'TXM' and isinstance(val,str) : return val
+ if self.definition.creeDesObjets :
+ # isinstance(val, self.definition.creeDesObjetsDeType) ne fonctionne pas car il y a un avec cata devant et l autre non
+ if val == None : return val
+ if not isinstance(val,(list,tuple)) : valATraiter=[val,]
+ else : valATraiter=val
+ listeRetour=[]
+ for v in valATraiter:
+ if (not(v.__class__.__name__ == self.definition.creeDesObjetsDeType.__name__)) :
+ if self.jdc != None and v in list(self.jdc.sdsDict.keys()): v=self.jdc.sdsDict[v]
+ else : v=self.convProto.convert(v)
+ if v.parent== None : v.initialiseParent(self)
+ if issubclass(self.definition.creeDesObjetsDeType, UserASSDMultiple) :
+ v.ajouteUnPere(self)
+ else :
+ if v.nom=='sansNom' :
+ for leNom,laVariable in self.jdc.g_context.items():
+ if id(laVariable)== id(v) and (leNom != 'sansNom'):
+ v.initialiseNom(leNom)
+ if v.parent== None : v.initialiseParent(self)
+ if issubclass(self.definition.creeDesObjetsDeType, UserASSDMultiple) :
+ v.ajouteUnPere(self)
+ listeRetour.append(v)
+ if isinstance(val,(list,tuple)) :newVal=listeRetour
+ else : newVal=listeRetour[0]
+ return newVal
if self.convProto:
- val = self.convProto.convert(val)
+ val = self.convProto.convert(val)
return val
def creeUserASSDetSetValeur(self, val):
self.state='changed'
nomVal=val
if nomVal in self.jdc.sdsDict.keys():
- if isinstance(self.jdc.sdsDict[nomVal],self.definition.creeDesObjetsDeType):
+ if isinstance(self.jdc.sdsDict[nomVal],self.definition.creeDesObjetsDeType):
if issubclass(self.definition.creeDesObjetsDeType, UserASSDMultiple) :
- p=self.parent
- while p in self.parent :
- if hasattr(p, 'listeDesReferencesCrees') : p.listeDesReferencesCrees.append(self.jdc.sdsDict[nomVal])
- else : p.listeDesReferencesCrees=[self.jdc.sdsDict[nomVal],]
- p=p.parent
- self.jdc.sdsDict[nomVal].ajouteUnPere(self)
- #return (1, 'reference ajoutee')
- else :
- return (0, 'concept non multiple deja reference')
+ p=self.parent
+ while p in self.parent :
+ if hasattr(p, 'listeDesReferencesCrees') : p.listeDesReferencesCrees.append(self.jdc.sdsDict[nomVal])
+ else : p.listeDesReferencesCrees=[self.jdc.sdsDict[nomVal],]
+ p=p.parent
+ self.jdc.sdsDict[nomVal].ajouteUnPere(self)
+ #return (1, 'reference ajoutee')
+ else :
+ return (0, 'concept non multiple deja reference')
else : return (0, 'concept d un autre type existe deja')
if self.convProto:
objVal = self.convProto.convert(nomVal)
objVal.initialiseNom(nomVal)
- if objVal.parent== None : objVal.initialiseParent(self)
+ if objVal.parent== None : objVal.initialiseParent(self)
objVal.ajouteUnPere(self)
p=self.parent
while p in self.parent :
- if hasattr(p, 'listeDesReferencesCrees') : p.listeDesReferencesCrees.append(objVal)
- else : p.listeDesReferencesCrees=[objVal,]
- p=p.parent
+ if hasattr(p, 'listeDesReferencesCrees') : p.listeDesReferencesCrees.append(objVal)
+ else : p.listeDesReferencesCrees=[objVal,]
+ p=p.parent
return (self.setValeur(objVal), 'reference creee')
def creeUserASSD(self, val):
self.state='changed'
nomVal=val
if nomVal in self.jdc.sdsDict.keys():
- if isinstance(self.jdc.sdsDict[nomVal],self.definition.creeDesObjetsDeType):
- if issubclass(self.definition.creeDesObjetsDeType, UserASSDMultiple) :
- p=self.parent
- while p in self.parent :
- if hasattr(p, 'listeDesReferencesCrees') : p.listeDesReferencesCrees.append(self.jdc.sdsDict[nomVal])
- else : p.listeDesReferencesCrees=[self.jdc.sdsDict[nomVal],]
- p=p.parent
- self.jdc.sdsDict[nomVal].ajouteUnPere(self)
- return (1,self.jdc.sdsDict[nomVal], 'reference ajoutee')
- else : return (0, None, 'concept d un autre type existe deja')
- else : return (0, None, 'concept d un autre type existe deja')
+ if isinstance(self.jdc.sdsDict[nomVal],self.definition.creeDesObjetsDeType):
+ if issubclass(self.definition.creeDesObjetsDeType, UserASSDMultiple) :
+ p=self.parent
+ while p in self.parent :
+ if hasattr(p, 'listeDesReferencesCrees') : p.listeDesReferencesCrees.append(self.jdc.sdsDict[nomVal])
+ else : p.listeDesReferencesCrees=[self.jdc.sdsDict[nomVal],]
+ p=p.parent
+ self.jdc.sdsDict[nomVal].ajouteUnPere(self)
+ return (1,self.jdc.sdsDict[nomVal], 'reference ajoutee')
+ else : return (0, None, 'concept d un autre type existe deja')
+ else : return (0, None, 'concept d un autre type existe deja')
if self.convProto:
objVal = self.convProto.convert(nomVal)
objVal.initialiseNom(nomVal)
return (1, objVal, 'reference creee')
def rattacheUserASSD(self, objASSD):
- if objASSD.parent== None : objASSD.initialiseParent(self)
+ if objASSD.parent== None : objASSD.initialiseParent(self)
p=self.parent
while p in self.parent :
- if hasattr(p, 'listeDesReferencesCrees') : p.listeDesReferencesCrees.append(objASSD)
- else : p.listeDesReferencesCrees=[objASSD,]
- p=p.parent
+ if hasattr(p, 'listeDesReferencesCrees') : p.listeDesReferencesCrees.append(objASSD)
+ else : p.listeDesReferencesCrees=[objASSD,]
+ p=p.parent
+
-
def getValeur(self):
"""
Retourne la "valeur" d'un mot-clé simple.
if isinstance(co, CO) and co.isTypCO()]
def supprime(self):
- if not type(self.valeur) in (list, tuple): lesValeurs=(self.valeur,)
- else : lesValeurs=self.valeur
- if self.valeur == None or self.valeur == [] : lesValeurs=[]
- for val in lesValeurs:
- if self.definition.creeDesObjets : val.deleteReference(self)
- else :
- if (hasattr (val, 'enleveUtilisePar')) : val.enleveUtilisePar(self)
- N_OBJECT.OBJECT.supprime(self)
-
- def getUserAssdPossible(self):
- print ('yyyyy')
+ if not type(self.valeur) in (list, tuple): lesValeurs=(self.valeur,)
+ else : lesValeurs=self.valeur
+ if self.valeur == None or self.valeur == [] : lesValeurs=[]
+ for val in lesValeurs:
+ if self.definition.creeDesObjets : val.deleteReference(self)
+ else :
+ if (hasattr (val, 'enleveUtilisePar')) : val.enleveUtilisePar(self)
+ N_OBJECT.OBJECT.supprime(self)
+
+ def getUserAssdPossible(self):
classeAChercher = self.definition.type
l=[]
dicoValeurs={}
d={}
- for (nomMC, Xpath) in self.definition.filtreVariables :
- print (nomMC, Xpath)
- if Xpath == None :
- dicoValeurs[nomMC] = getattr(self,nomMC)
- else :
- try:
- #if 1 :
- pereMC=eval(Xpath)
- if pereMC :
- exp=Xpath+'.getChild("'+nomMC+'")'
- leMotCle=eval(exp)
- else : leMotCle=None
- if leMotCle :
- if leMotCle.val : dicoValeurs[nomMC]=leMotCle.val
- elif leMotCle.definition.max != 1 : dicoValeurs[nomMC] = []
- else : dicoValeurs[nomMC] = None
- else :
- #PN PN est-ce sur ? sinon quoi None ou []
- # je pense que les 2 valeurs doivent être renseignees si le filtre depend de 2 valeurs
- return l
- except:
- return l
-
-
+ if self.definition.filtreVariables != None :
+ for (nomMC, Xpath) in self.definition.filtreVariables :
+ # print (nomMC, Xpath)
+ if Xpath == None : dicoValeurs[nomMC] = getattr(self,nomMC)
+ else :
+ try: #if 1 :
+ pereMC=eval(Xpath)
+ if pereMC :
+ exp=Xpath+'.getChild("'+nomMC+'")'
+ leMotCle=eval(exp)
+ else : leMotCle=None
+ if leMotCle :
+ if leMotCle.val : dicoValeurs[nomMC]=leMotCle.val
+ elif leMotCle.definition.max != 1 : dicoValeurs[nomMC] = []
+ else : dicoValeurs[nomMC] = None
+ else :
+ #PN PN est-ce sur ? sinon quoi None ou []
+ # je pense que les 2 valeurs doivent être renseignees si le filtre depend de 2 valeurs
+ return l
+ except:
+ return l
+
+
for k,v in self.parent.jdc.sdsDict.items():
- if (isinstance(v, classeAChercher)) :
- if self.definition.filtreExpression :
- try :
- if v.executeExpression(self.definition.filtreExpression ,dicoValeurs) : l.append(v)
- except :
- print ('il faut comprendre except pour', self.nom)
- #print (self.nom)
- #print (self.parent.nom)
- #print (k,v)
- else : l.append(v)
+ if (isinstance(v, classeAChercher)) :
+ if self.definition.filtreExpression :
+ try :
+ if v.executeExpression(self.definition.filtreExpression ,dicoValeurs) : l.append(v)
+ except :
+ print ('il faut comprendre except pour', self.nom)
+ #print (self.nom)
+ #print (self.parent.nom)
+ #print (k,v)
+ else : l.append(v)
return l
-
"""
from __future__ import absolute_import
try :
- from builtins import object
+ from builtins import object
except :
- pass
+ pass
from .N_CR import CR
return 0
def longueurDsArbre(self):
- if self.nom == "Consigne" : return 0
- if self.nom == "blocConsigne" : return 0
- return 1
+ if self.nom == "Consigne" : return 0
+ if self.nom == "blocConsigne" : return 0
+ return 1
self.cr.fatal(_(u"Type non autorisé pour le mot-clé %s : '%s'"),
self.nom, self.valeur)
return self.cr
-
-
etape = self.class_instance(oper=self, reuse=reuse, args=args)
etape.MCBuild()
while etape.doitEtreRecalculee == True :
- etape.doitEtreRecalculee = False
- etape.deepUpdateConditionBlocApresCreation()
- etape.reConstruitResteVal()
- etape.state='modified'
- #print ('on recalcule la validite depuis N_OPER')
+ etape.doitEtreRecalculee = False
+ etape.deepUpdateConditionBlocApresCreation()
+ etape.reConstruitResteVal()
+ etape.state='modified'
+ #print ('on recalcule la validite depuis N_OPER')
# etape.isValid(cr='oui')
etape.metAJourNomASSD(nomsd)
return etape.buildSd(nomsd)
from __future__ import absolute_import
try :
- from builtins import object
+ from builtins import object
except :
- pass
+ pass
from .N_utils import importObject
etape = self.class_instance(oper=self, args=args)
etape.MCBuild()
while etape.doitEtreRecalculee == True :
- etape.doitEtreRecalculee = False
- etape.deepUpdateConditionBlocApresCreation()
- etape.reConstruitResteVal()
+ etape.doitEtreRecalculee = False
+ etape.deepUpdateConditionBlocApresCreation()
+ etape.reConstruitResteVal()
return etape.buildSd()
def make_objet(self, mc_list='oui'):
"""
from __future__ import absolute_import
-try :
- from builtins import object
+try :
+ from builtins import object
except :
- pass
+ pass
import types
# -----------------------------------------------------------------------------
class CONCEPT_SENSIBLE(REGLE):
- """Règle permettant de renseigner au niveau du catalogue comment sera
- rempli le concept (valeur nominale ou dérivée(s) ou les deux...).
- """
- def __init__(self, mode, mocle='SENSIBILITE'):
- """Constructeur.
-
- mode : manière dont la commande rempli le concept
- - 'ENSEMBLE' : concept nominal ET dérivées en une seule passe
- - 'SEPARE' : concept nominal OU dérivée (une ou plusieurs)
-
- mocle : mot-clé contenant les paramètres sensibles.
- """
- REGLE.__init__(self)
- self.mocle = mocle
- self._modes = { 'ENSEMBLE' : 0, 'SEPARE' : 1 }
- self.mode = self._modes.get(mode, self._modes['ENSEMBLE'])
-
- def getText(self):
- """Pour EFICAS
- """
- return ''
-
- def verif(self, args):
- """Retourne texte + 1 si ok, 0 si nook.
- On stocke dans sd.sensi l'étape courante, c'est-à-dire celle qui
- renseigne le concept si cela n'a pas déjà été fait (car verif est
- appelé à chaque validation).
- """
- obj = args["self"]
- etape = obj.etape
- id_etape = '%s_%s' % (etape.id, id(etape))
- if etape.sd == None:
- return '',1
- if not hasattr(etape.sd,"sensi"):
- etape.sd.sensi = {}
- # si ENSEMBLE, la sd nominale est forcément produite
- if self.mode == self._modes['ENSEMBLE'] and not 'nominal' in etape.sd.sensi :
- etape.sd.sensi['nominal'] = id_etape
- # liste des paramètres sensibles
- valeur = obj[self.mocle]
- if valeur == None:
- # pas de sensibilité, la sd nominale est produite
- if not 'nominal' in etape.sd.sensi:
+ """Règle permettant de renseigner au niveau du catalogue comment sera
+ rempli le concept (valeur nominale ou dérivée(s) ou les deux...).
+ """
+ def __init__(self, mode, mocle='SENSIBILITE'):
+ """Constructeur.
+
+ mode : manière dont la commande rempli le concept
+ - 'ENSEMBLE' : concept nominal ET dérivées en une seule passe
+ - 'SEPARE' : concept nominal OU dérivée (une ou plusieurs)
+
+ mocle : mot-clé contenant les paramètres sensibles.
+ """
+ REGLE.__init__(self)
+ self.mocle = mocle
+ self._modes = { 'ENSEMBLE' : 0, 'SEPARE' : 1 }
+ self.mode = self._modes.get(mode, self._modes['ENSEMBLE'])
+
+ def getText(self):
+ """Pour EFICAS
+ """
+ return ''
+
+ def verif(self, args):
+ """Retourne texte + 1 si ok, 0 si nook.
+ On stocke dans sd.sensi l'étape courante, c'est-à-dire celle qui
+ renseigne le concept si cela n'a pas déjà été fait (car verif est
+ appelé à chaque validation).
+ """
+ obj = args["self"]
+ etape = obj.etape
+ id_etape = '%s_%s' % (etape.id, id(etape))
+ if etape.sd == None:
+ return '',1
+ if not hasattr(etape.sd,"sensi"):
+ etape.sd.sensi = {}
+ # si ENSEMBLE, la sd nominale est forcément produite
+ if self.mode == self._modes['ENSEMBLE'] and not 'nominal' in etape.sd.sensi :
etape.sd.sensi['nominal'] = id_etape
- return '', 1
- if not type(valeur) in (list, tuple):
- valeur = [valeur,]
- for v in valeur:
- if not v.getName() in etape.sd.sensi:
- etape.sd.sensi[v.getName()] = id_etape
- return '', 1
+ # liste des paramètres sensibles
+ valeur = obj[self.mocle]
+ if valeur == None:
+ # pas de sensibilité, la sd nominale est produite
+ if not 'nominal' in etape.sd.sensi:
+ etape.sd.sensi['nominal'] = id_etape
+ return '', 1
+ if not type(valeur) in (list, tuple):
+ valeur = [valeur,]
+ for v in valeur:
+ if not v.getName() in etape.sd.sensi:
+ etape.sd.sensi[v.getName()] = id_etape
+ return '', 1
# -----------------------------------------------------------------------------
class REUSE_SENSIBLE(REGLE):
- """Limite le caractère réentrant de la commande.
- On autorisera reuse seulement si le concept (au sens fortran) n'a pas déjà
- été calculé (d'après sd.sensi). Ce sera interdit dans les cas suivants :
- - sd nominale calculée et SENSIBILITE absent
- - PS1 dans SENSIBILITE et sd dérivée par rapport à PS1 calculée
- """
- def __init__(self, mocle='SENSIBILITE'):
- """Constructeur.
- mocle : mot-clé SENSIBILITE.
- """
- REGLE.__init__(self)
- self.mocle = mocle
-
- def getText(self):
- """Pour EFICAS
- """
- return ''
-
- def verif(self,args):
- """Retourne texte + 1 si ok, 0 si nook = reuse interdit.
- Comme CONCEPT_SENSIBLE est appelé avant (et à chaque validation),
- on regarde si sd.sensi[ps] a été renseigné par une étape précédente.
- """
- obj = args["self"]
- etape = obj.etape
- id_etape = '%s_%s' % (etape.id, id(etape))
- sd = etape.sd
- # si la commande n'est pas réentrante, rien à faire
- if etape.reuse is not None:
- valeur = obj[self.mocle]
- if valeur is None:
- if not hasattr(sd, 'sensi') or sd.sensi.get('nominal', id_etape) != id_etape:
- # pas de sensibilite et concept nominal déjà calculé : reuse interdit
- text = "Commande non réentrante en l'absence de sensibilité."
- return text, 0
- else:
- if not type(valeur) in (list, tuple):
- valeur = [valeur,]
- for ps in valeur:
- if hasattr(sd, 'sensi') and sd.sensi.get(ps.nom, id_etape) != id_etape:
- # concept dérivé par rapport à ps déjà calculé : reuse interdit
- text = "Commande non réentrante : dérivée par rapport à %s déjà calculée" % ps.nom
- return text, 0
- return '', 1
+ """Limite le caractère réentrant de la commande.
+ On autorisera reuse seulement si le concept (au sens fortran) n'a pas déjà
+ été calculé (d'après sd.sensi). Ce sera interdit dans les cas suivants :
+ - sd nominale calculée et SENSIBILITE absent
+ - PS1 dans SENSIBILITE et sd dérivée par rapport à PS1 calculée
+ """
+ def __init__(self, mocle='SENSIBILITE'):
+ """Constructeur.
+ mocle : mot-clé SENSIBILITE.
+ """
+ REGLE.__init__(self)
+ self.mocle = mocle
+
+ def getText(self):
+ """Pour EFICAS
+ """
+ return ''
+
+ def verif(self,args):
+ """Retourne texte + 1 si ok, 0 si nook = reuse interdit.
+ Comme CONCEPT_SENSIBLE est appelé avant (et à chaque validation),
+ on regarde si sd.sensi[ps] a été renseigné par une étape précédente.
+ """
+ obj = args["self"]
+ etape = obj.etape
+ id_etape = '%s_%s' % (etape.id, id(etape))
+ sd = etape.sd
+ # si la commande n'est pas réentrante, rien à faire
+ if etape.reuse is not None:
+ valeur = obj[self.mocle]
+ if valeur is None:
+ if not hasattr(sd, 'sensi') or sd.sensi.get('nominal', id_etape) != id_etape:
+ # pas de sensibilite et concept nominal déjà calculé : reuse interdit
+ text = "Commande non réentrante en l'absence de sensibilité."
+ return text, 0
+ else:
+ if not type(valeur) in (list, tuple):
+ valeur = [valeur,]
+ for ps in valeur:
+ if hasattr(sd, 'sensi') and sd.sensi.get(ps.nom, id_etape) != id_etape:
+ # concept dérivé par rapport à ps déjà calculé : reuse interdit
+ text = "Commande non réentrante : dérivée par rapport à %s déjà calculée" % ps.nom
+ return text, 0
+ return '', 1
# -----------------------------------------------------------------------------
class DERIVABLE(REGLE):
- """Déclare que le concept fourni derrière un mot-clé est dérivable.
- Sa présence ne suffit pas à le valider, il faut encore que son attribut
- '.sensi' soit cohérent avec le contenu du mot-clé SENSIBILITE (ou l'absence
- de celui-ci).
- """
- def __init__(self, mocle):
- """Constructeur.
- mocle : mot-clé dérivable.
- """
- REGLE.__init__(self)
- self.mocle = mocle
-
- def getText(self):
- """Pour EFICAS
- """
- return ''
-
- def verif(self,args):
- """
- """
- obj = args["self"]
- try:
- concept = obj[self.mocle]
- except IndexError:
- return '', 1
- if not type(concept) in (list, tuple):
- concept = [concept,]
- l_ps = obj["SENSIBILITE"]
- for co in concept:
- if co is None:
- text = "Concept non défini (None) sous le mot-clé %s" % self.mocle
- return text, 0
- if not l_ps:
- # pas de sensibilité
- if hasattr(co,"sensi") and not co.sensi.get('nominal'):
- text = "%s ne contient que des valeurs dérivées, utilisez le mot cle SENSIBILITE" %\
- co.nom
- return text, 0
- else:
- # sensibilité spécifiée
- if not type(l_ps) in (list, tuple):
- l_ps = [l_ps,]
- for ps in l_ps:
- if not hasattr(co,"sensi") or not co.sensi.get(ps.nom):
- text = "La dérivée de %s par rapport à %s n'est pas disponible." %\
- (co.nom, ps.nom)
- return text, 0
- return '', 1
-
+ """Déclare que le concept fourni derrière un mot-clé est dérivable.
+ Sa présence ne suffit pas à le valider, il faut encore que son attribut
+ '.sensi' soit cohérent avec le contenu du mot-clé SENSIBILITE (ou l'absence
+ de celui-ci).
+ """
+ def __init__(self, mocle):
+ """Constructeur.
+ mocle : mot-clé dérivable.
+ """
+ REGLE.__init__(self)
+ self.mocle = mocle
+
+ def getText(self):
+ """Pour EFICAS
+ """
+ return ''
+
+ def verif(self,args):
+ """
+ """
+ obj = args["self"]
+ try:
+ concept = obj[self.mocle]
+ except IndexError:
+ return '', 1
+ if not type(concept) in (list, tuple):
+ concept = [concept,]
+ l_ps = obj["SENSIBILITE"]
+ for co in concept:
+ if co is None:
+ text = "Concept non défini (None) sous le mot-clé %s" % self.mocle
+ return text, 0
+ if not l_ps:
+ # pas de sensibilité
+ if hasattr(co,"sensi") and not co.sensi.get('nominal'):
+ text = "%s ne contient que des valeurs dérivées, utilisez le mot cle SENSIBILITE" %\
+ co.nom
+ return text, 0
+ else:
+ # sensibilité spécifiée
+ if not type(l_ps) in (list, tuple):
+ l_ps = [l_ps,]
+ for ps in l_ps:
+ if not hasattr(co,"sensi") or not co.sensi.get(ps.nom):
+ text = "La dérivée de %s par rapport à %s n'est pas disponible." %\
+ (co.nom, ps.nom)
+ return text, 0
+ return '', 1
else:
self.type = (typ,)
for t in (self.type) :
- try :
- if issubclass(t,Accas.UserASSDMultiple) :
- creeDesObjetsDeType = t
- self.utiliseUneReference = True
- elif issubclass(t,Accas.UserASSD) :
- creeDesObjetsDeType = t
- self.utiliseUneReference = True
+ try :
+ if issubclass(t,Accas.UserASSDMultiple) :
+ creeDesObjetsDeType = t
+ self.utiliseUneReference = True
+ elif issubclass(t,Accas.UserASSD) :
+ creeDesObjetsDeType = t
+ self.utiliseUneReference = True
except : pass
if t == 'createObject' : self.creeDesObjets=True
- if self.utiliseUneReference :
- if self.creeDesObjets :
- self.utiliseUneReference = False
- self.creeDesObjetsDeType = creeDesObjetsDeType
- else : self.utiliseDesObjetsDeType = creeDesObjetsDeType
+ if self.utiliseUneReference :
+ if self.creeDesObjets :
+ self.utiliseUneReference = False
+ self.creeDesObjetsDeType = creeDesObjetsDeType
+ else : self.utiliseDesObjetsDeType = creeDesObjetsDeType
self.fr = fr
self.statut = statut
self.into = into
self.intoXML = intoXML
self.sortie = sortie
self.filtre = filtre
- if self.filtre :
- self.filtreExpression = self.filtre[0]
- self.filtreVariables = self.filtre[1]
+ if self.filtre :
+ self.filtreExpression = self.filtre[0]
+ self.filtreVariables = self.filtre[1]
else :
- self.filtreExpression = []
- self.filtreVariables = []
+ self.filtreExpression = []
+ self.filtreVariables = []
self.metAJour=metAJour
def verifCata(self):
self.checkInto()
self.checkPosition()
self.checkValidators()
-
+
def __call__(self, val, nom, parent=None, objPyxbDeConstruction = None):
"""
de sa valeur (val), de son nom (nom) et de son parent dans l arboresence (parent)
"""
return self.class_instance(nom=nom, definition=self, val=val, parent=parent, objPyxbDeConstruction=objPyxbDeConstruction)
-
-
from __future__ import absolute_import
from __future__ import print_function
try :
- from builtins import object
+ from builtins import object
except : pass
import traceback
import sys
class UserASSD(ASSD):
"""
- Classe de base pour definir des types de structures de donnees definie par
+ Classe de base pour definir des types de structures de donnees definie par
l utilisateur
equivalent d un concept ASSD pour un SIMP ou un FACT
Attention : le parent est a None au debut et non le MC createur que l on ne connait pas
"""
def __init__(self,nom='sansNom'):
- #print ('dans init de UserASSD pour ', nom, type(nom))
- self.nom = nom
- self.jdc = CONTEXT.getCurrentJdC()
- self.parent = None
- self.initialiseValeur()
- self.utilisePar = set()
- if self.nom != 'sansNom' : self.id = self.jdc.regSD(self)
- if self.nom != 'sansNom' : self.initialiseNom(nom)
- else : self.id = None
- self.ptr_sdj = None
+ #print ('dans init de UserASSD pour ', nom, type(nom))
+ self.nom = nom
+ self.jdc = CONTEXT.getCurrentJdC()
+ self.parent = None
+ self.initialiseValeur()
+ self.utilisePar = set()
+ if self.nom != 'sansNom' : self.id = self.jdc.regSD(self)
+ if self.nom != 'sansNom' : self.initialiseNom(nom)
+ else : self.id = None
+ self.ptr_sdj = None
def initialiseParent(self, parent):
# attention parent.parent peut être un bloc
- #print ('je passe initialiseParent pour : ', self, parent.nom)
- self.parent = parent
- self.etape = self.parent.getEtape()
- self.etape.userASSDCrees.append(self)
- if self.parent.parent != self.etape :
- if self.parent.parent.estIdentifiePar != None :
- print ('il y a un souci dans l initialisation de l identifiant pour', self.parent.parent.nom)
- print (self.parent.nom)
- print (self.nom)
- self.parent.parent.estIdentifiePar = self
+ #print ('je passe initialiseParent pour : ', self, parent.nom)
+ self.parent = parent
+ self.etape = self.parent.getEtape()
+ self.etape.userASSDCrees.append(self)
+ if self.parent.parent != self.etape :
+ if self.parent.parent.estIdentifiePar != None :
+ print ('il y a un souci dans l initialisation de l identifiant pour', self.parent.parent.nom)
+ print (self.parent.nom)
+ print (self.nom)
+ self.parent.parent.estIdentifiePar = self
def initialiseNom(self,nom):
- #print ('je passe initialiseNom pour : ', self, nom, type(nom))
- for (i,j) in list(self.jdc.sdsDict.items()) :
- if j == self :
- del(self.jdc.sdsDict[i])
- self.jdc.sdsDict[nom]=self
- self.nom=nom
- if self.nom != 'sansNom' and self.id ==None : self.id = self.jdc.regSD(self)
+ #print ('je passe initialiseNom pour : ', self, nom, type(nom))
+ for (i,j) in list(self.jdc.sdsDict.items()) :
+ if j == self :
+ del(self.jdc.sdsDict[i])
+ self.jdc.sdsDict[nom]=self
+ self.nom=nom
+ if self.nom != 'sansNom' and self.id ==None : self.id = self.jdc.regSD(self)
def initialiseValeur(self,valeur=None):
- self.valeur=valeur
+ self.valeur=valeur
def ajoutUtilisePar(self,mc):
- #print ('je passe ajoutUtilisePar pour : ', self.nom)
- self.utilisePar.add(mc)
+ #print ('je passe ajoutUtilisePar pour : ', self.nom)
+ self.utilisePar.add(mc)
def enleveUtilisePar(self,mc):
- try : self.utilisePar.remove(mc)
- except : pass
+ try : self.utilisePar.remove(mc)
+ except : pass
def renomme(self,nouveauNom):
- print ('je passe dans renomme')
- self.jdc.delConcept(self.nom)
- self.jdc.sdsDict[nouveauNom] = self
- self.setName(nouveauNom)
- for mc in (self.utilisePar):
- mc.demandeRedessine()
+ print ('je passe dans renomme')
+ self.jdc.delConcept(self.nom)
+ self.jdc.sdsDict[nouveauNom] = self
+ self.setName(nouveauNom)
+ for mc in (self.utilisePar):
+ mc.demandeRedessine()
def transfere (self,obj):
- # uniquement utise pour les lectures XML
+ # uniquement utise pour les lectures XML
self.utilisePar=obj.utilisePar
self.id=obj.id
for mc in self.utilisePar: mc.valeur=self
def deleteReference(self, mcCreateur=None):
- print ('je passe dans supprime de N_UserASSDMultiple')
+ print ('je passe dans supprime de N_UserASSDMultiple')
# meme signature que UserASSDMultiple
- for MC in self.utilisePar :
- try :
- if type(MC.valeur) in (list,tuple):
- MC.valeur=list(MC.valeur)
- while self in MC.valeur: MC.valeur.remove(self)
- if MC.valeur == [] : MC.Valeur = None
- else : MC.valeur=None
- MC.state='changed'
- MC.isValid()
- CONNECTOR.Emit(MC,"valid")
- except : pass
- # on peut avoir des listes qui contiennent plusieurs fois la meme valeur
- self.jdc.delConcept(self.nom)
+ for MC in self.utilisePar :
+ try :
+ if type(MC.valeur) in (list,tuple):
+ MC.valeur=list(MC.valeur)
+ while self in MC.valeur: MC.valeur.remove(self)
+ if MC.valeur == [] : MC.Valeur = None
+ else : MC.valeur=None
+ MC.state='changed'
+ MC.isValid()
+ CONNECTOR.Emit(MC,"valid")
+ except : pass
+ # on peut avoir des listes qui contiennent plusieurs fois la meme valeur
+ self.jdc.delConcept(self.nom)
+
+ def executeExpression(self, condition, dico) :
+ #print ('je suis dans executeExpression ', self.nom, ' ', condition)
+ dict = locals()
+ dict.update(dico)
+ #if self.nom == 'CS_Num1__CS_Num2_Velocity' :
+ # print ('--------------------------------------------------------------------------')
+ # #print ((set(("Pressure",)).intersection(set(self.getEficasAttribut("InvolvedStateVariable"))) != set()))
+ # print (self.getEficasAttribut("InvolvedStateVariable"))
+ # print ('--------------------------------------------------------------------------')
+ # return 0
+ try :
+ test = eval(condition, globals(), dict)
+ except :
+ print ('executeExpression ', self.nom, ' ', condition , 'exception')
+ test = 0
+ return test
def getEficasAttribut(self, attribut):
- print ('je suis dans getEficasAttr', attribut)
- if self.parent == None : return None
- #print ('apres if')
- # parent est le SIMP donc c est bien parent.parent
- try :
- valeur = self.parent.parent.getMocle(attribut)
- except :
- valeur = None
- #print (valeur)
- return valeur
-
-
+ print ('je suis dans getEficasAttr', attribut)
+ if self.parent == None : return None
+ # parent est le SIMP donc c est bien parent.parent
+ try :
+ valeur = self.parent.parent.getMocle(attribut)
+ except :
+ valeur = None
+ #print (valeur)
+ return valeur
+
+
def supprime(self, mcCreateur=None):
# mcCreateur utile pour N_UserASSDMultiple
- print ('je passe dans supprime de N_UserASSDMultiple')
- self.deleteReference(mcCreateur)
-
+ print ('je passe dans supprime de N_UserASSDMultiple')
+ self.deleteReference(mcCreateur)
from __future__ import absolute_import
from __future__ import print_function
try :
- from builtins import object
+ from builtins import object
except : pass
import traceback
import sys
from .N_UserASSD import UserASSD
from .N_ASSD import ASSD
-from collections import UserList
+from collections import UserList
class UserASSDMultiple(UserASSD):
"""
- Classe de base pour definir des types de structures de donnees definie par
+ Classe de base pour definir des types de structures de donnees definie par
l utilisateur
equivalent d un concept ASSD pour un SIMP ou un FACT
mais pouvant referencer 2 objets par exemple les groupes de mailles qui peuvent porter
if self not in etape.userASSDCrees : etape.userASSDCrees.append(self)
def renomme(self,nouveauNom):
- print ('je passe dans renomme')
- #import traceback
- #traceback.print_stack()
- self.jdc.delConcept(self.nom)
- self.jdc.sdsDict[nouveauNom] = self
- self.setName(nouveauNom)
- for mc in (self.utilisePar):
- mc.demandeRedessine()
-
-
+ print ('je passe dans renomme')
+ #import traceback
+ #traceback.print_stack()
+ self.jdc.delConcept(self.nom)
+ self.jdc.sdsDict[nouveauNom] = self
+ self.setName(nouveauNom)
+ for mc in (self.utilisePar):
+ mc.demandeRedessine()
+
+
def initialiseParent(self, pere):
# surcharge N_UserASSD parent ici n a pas de sens
pass
-
+
def deleteReference(self,mcCreateur):
- print ('je passe dans deleteReference', mcCreateur.nom)
- if not(mcCreateur in self.peres) : return
- self.peres.pop(self.peres.index(mcCreateur))
- if len(self.peres)==0 :
- UserASSD.deleteReference(self)
-
- def executeExpression(self, condition, dico) :
- dict = locals()
- dict.update(dico)
- test = eval(condition, globals(), dict)
- #print ('retour executeExpression' , test)
- return test
+ print ('je passe dans deleteReference', mcCreateur.nom)
+ if not(mcCreateur in self.peres) : return
+ self.peres.pop(self.peres.index(mcCreateur))
+ if len(self.peres)==0 :
+ UserASSD.deleteReference(self)
+
def getParentsWithId(self):
- #print ('je suis dans getParentsWithId ')
- listeRetour= listUserASSD()
- for pere in self.peres :
- pereWithId = pere.parent
- monEtape = pere.getEtape()
- while (pereWithId) :
- if pereWithId==monEtape :
- listeRetour.append(pereWithId)
- break
- if pereWithId.estIdentifiePar != None :
- listeRetour.append(pereWithId)
- break
- pereWithId=pereWithId.parent
- return listeRetour
+ #print ('je suis dans getParentsWithId ')
+ listeRetour= listUserASSD()
+ for pere in self.peres :
+ pereWithId = pere.parent
+ monEtape = pere.getEtape()
+ while (pereWithId) :
+ if pereWithId==monEtape :
+ listeRetour.append(pereWithId)
+ break
+ if pereWithId.estIdentifiePar != None :
+ listeRetour.append(pereWithId)
+ break
+ pereWithId=pereWithId.parent
+ return listeRetour
def getEtapes(self):
- listeRetour= listUserASSD()
- for pere in self.peres :
- if pere.etape not in listeRetour : listeRetour.append(pere.etape)
- return listeRetour
+ listeRetour= listUserASSD()
+ for pere in self.peres :
+ if pere.etape not in listeRetour : listeRetour.append(pere.etape)
+ return listeRetour
class listUserASSD(UserList):
- def getListeMotsCles(self,nomMc):
- if self.data == None : return []
- listeRetour=[]
- for concept in self.data:
- listeRetour.append(concept.getChild(nomMc).val)
- return listeRetour
-
- def getListeNomsUserASSD(self,nomMc):
- if self.data == None : return []
- listeRetour=[]
- for concept in self.data:
- listeRetour.append(concept.getChild(nomMc).val.nom)
- return listeRetour
-
- def getListeUserASSD(self,nomMc):
- if self.data == None : return []
- listeRetour=[]
- for concept in self.data:
- if concept.getChild(nomMc) :
- if concept.getChild(nomMc).val :
- listeRetour.append(concept.getChild(nomMc).val)
- return listeRetour
-
-
+ def getListeMotsCles(self,nomMc):
+ if self.data == None : return []
+ listeRetour=[]
+ for concept in self.data:
+ listeRetour.append(concept.getChild(nomMc).val)
+ return listeRetour
+
+ def getListeNomsUserASSD(self,nomMc):
+ if self.data == None : return []
+ listeRetour=[]
+ for concept in self.data:
+ listeRetour.append(concept.getChild(nomMc).val.nom)
+ return listeRetour
+
+ def getListeUserASSD(self,nomMc):
+ if self.data == None : return []
+ listeRetour=[]
+ for concept in self.data:
+ if concept.getChild(nomMc) :
+ if concept.getChild(nomMc).val :
+ listeRetour.append(concept.getChild(nomMc).val)
+ return listeRetour
from __future__ import absolute_import
from __future__ import print_function
try :
- from builtins import str
- from builtins import object
+ from builtins import str
+ from builtins import object
except : pass
-
+
import types
import traceback
import re
if self.isComplexe(obj):
return obj
elif type_permis == 'TXM':
- if isStr(obj):
- return obj
+ if isStr(obj):
+ return obj
elif type_permis == 'shell':
if isStr(obj):
return obj
elif type_permis == 'Fichier':
import os
try :
- if (len(typ) > 2 and typ[2] == "Sauvegarde") or os.path.isfile(obj):
- return obj
- else:
- raise ValError( "%s n'est pas un fichier valide" % repr(obj))
- except :
+ if (len(typ) > 2 and typ[2] == "Sauvegarde") or os.path.isfile(obj):
+ return obj
+ else:
+ raise ValError( "%s n'est pas un fichier valide" % repr(obj))
+ except :
raise ValError( "%s n'est pas un fichier valide" % repr(obj))
elif type_permis == 'FichierNoAbs':
elif type_permis == 'Repertoire':
import os
- try :
- if os.path.isdir(obj): return obj
- else: raise ValError( "%s n'est pas un repertoire valide" % repr(obj))
+ try :
+ if os.path.isdir(obj): return obj
+ else: raise ValError( "%s n'est pas un repertoire valide" % repr(obj))
except :
- raise ValError( "%s n'est pas un repertoire valide" % repr(obj))
+ raise ValError( "%s n'est pas un repertoire valide" % repr(obj))
elif type_permis == 'FichierOuRepertoire':
import os
- try :
- if os.path.isdir(obj) or os.path.isfile(obj): return obj
- else: raise ValError( "%s n'est pas un fichier ou un repertoire valide" % repr(obj))
+ try :
+ if os.path.isdir(obj) or os.path.isfile(obj): return obj
+ else: raise ValError( "%s n'est pas un fichier ou un repertoire valide" % repr(obj))
except :
- raise ValError( "%s n'est pas un fichier ou un repertoire valide" % repr(obj))
+ raise ValError( "%s n'est pas un fichier ou un repertoire valide" % repr(obj))
elif type(type_permis) == type or isinstance(type_permis, type):
try:
if self.isObjectFrom(obj, type_permis):
registry = {}
def __init__(self, name, into=None, val_min=float('-inf'), val_max=float('inf')):
-
+
PProtocol.__init__(
self, name, into=into, val_min=val_min, val_max=val_max)
self.val_min = val_min
self.val_max = val_max
def default(self, obj, into, val_min, val_max):
- if type(into) ==types.FunctionType :
- maListeDeValeur=into()
- into=maListeDeValeur
+ if type(into) ==types.FunctionType :
+ maListeDeValeur=into()
+ into=maListeDeValeur
if into:
if obj not in into:
raise ValError(
if type(valeur) == bytes or type(valeur) == str:
return 1
elif isinstance(valeur, type_permis):
- return 1
+ return 1
return 0
def verif(self, valeur):
def __init__(self,MotClef ):
self.MotClef=MotClef
self.MCSimp=None
-
+
def convert(self, lval):
try : valeur=lval[0]
except : return lval
else : longueur=len(parent.getChild(self.MotClef))
pos=parent.getIndexChild(self.MCSimp.nom)+1
- while longueur < valeur :
- parent.inhibeValidator=1
- parent.addEntite(self.MotClef,pos)
- pos=pos+1
- parent.inhibeValidator=0
- longueur=len(parent.getChild(self.MotClef))
-
- if longueur > valeur :
- parent.inhibeValide=1
- parentObj=parent.getChild(self.MotClef)
- obj=parent.getChild(self.MotClef)[-1]
- parentObj.suppEntite(obj)
- longueur=len(parent.getChild(self.MotClef))
- parent.inhibeValide=0
+ while longueur < valeur :
+ parent.inhibeValidator=1
+ parent.addEntite(self.MotClef,pos)
+ pos=pos+1
+ parent.inhibeValidator=0
+ longueur=len(parent.getChild(self.MotClef))
+
+ if longueur > valeur :
+ parent.inhibeValide=1
+ parentObj=parent.getChild(self.MotClef)
+ obj=parent.getChild(self.MotClef)[-1]
+ parentObj.suppEntite(obj)
+ longueur=len(parent.getChild(self.MotClef))
+ parent.inhibeValide=0
return lval
def info(self):
from __future__ import absolute_import
try :
- from past.builtins import cmp
+ from past.builtins import cmp
except :
- pass
+ pass
try:
- from UserDict import UserDict
+ from UserDict import UserDict
except ImportError:
- from collections import UserDict
+ from collections import UserDict
class _F(UserDict):
from __future__ import print_function
from __future__ import division
try :
- from builtins import str
- from builtins import object
+ from builtins import str
+ from builtins import object
except :
- pass
+ pass
import sys
# Modules EFICAS
SEP = '_'
try :
- cur_frame = sys._getframe
+ cur_frame = sys._getframe
except :
- print ('pb avec la version de python pour cur_frame = sys._getframe')
+ print ('pb avec la version de python pour cur_frame = sys._getframe')
def calleeWhere(niveau=4):
"""
from . import context
try :
- import __builtin__
- __builtin__.CONTEXT = context
-except :
- import builtins
- builtins.CONTEXT = context
+ import __builtin__
+ __builtin__.CONTEXT = context
+except :
+ import builtins
+ builtins.CONTEXT = context
# Classes de base
# Modules Python
from __future__ import absolute_import
try :
- from builtins import str
+ from builtins import str
except :
- pass
+ pass
import re
import linecache
import sys
# lineno = f_lineno(f) # Ne marche pas toujours
co = f.f_code
if sys.version_info >= (3,0) :
- filename = co.co_filename
- else :
- import six
- filename = six.text_type(co.co_filename, getEncoding())
+ filename = co.co_filename
+ else :
+ import six
+ filename = six.text_type(co.co_filename, getEncoding())
name = co.co_name
# pattern pour identifier le debut de la commande
pattern_oper = re.compile(regex1 % ope)
from __future__ import absolute_import
try :
- from builtins import str
+ from builtins import str
except : pass
import locale
