from __future__ import absolute_import
from __future__ import print_function
try :
- from builtins import str
+ from builtins import str
except : pass
import os,traceback
import re
"""
nature = "COMMANDE_COMMENTARISEE"
idracine='_comm'
-
+
def __init__(self,texte='',parent=None,reg='oui'):
self.valeur = texte
if not parent :
else:
self.jdc = self.parent = parent
if hasattr(self.parent,'etape'):
- self.etape = self.parent.etape
+ self.etape = self.parent.etape
else :
- self.etape = None
+ self.etape = None
self.definition=self
self.nom = ''
self.niveau = self.parent.niveau
self.state="unchanged"
#self.appel = N_utils.calleeWhere(niveau=2)
if reg=='oui' : self.register()
-
+
def isValid(self):
return 1
def initModif(self):
self.state = 'modified'
- self.parent.initModif()
+ self.parent.initModif()
def setValeur(self,new_valeur):
"""
"""
Indique si self est repetable ou non : retourne toujours 1
"""
- return 1
+ return 1
def getAttribut(self,nom_attribut) :
"""
Retourne l'attribut de nom nom_attribut de self (ou herite)
"""
if hasattr(self,nom_attribut) :
- return getattr(self,nom_attribut)
+ return getattr(self,nom_attribut)
else :
- return None
+ return None
def getFr(self):
"""
"""
if self.jdc.code=='ASTER' : return self.definition.fr
try :
- return getattr(self.definition,self.jdc.lang)
+ return getattr(self.definition,self.jdc.lang)
except:
- return ''
+ return ''
def listeMcPresents(self):
return []
def supprime(self):
- """
+ """
Methode qui supprime toutes les boucles de references afin que l'objet puisse
- etre correctement detruit par le garbage collector
+ etre correctement detruit par le garbage collector
"""
self.parent = None
self.etape = None
# on essaie de creer un objet JDC...
CONTEXT.unsetCurrentStep()
if re.search('Fin Commentaire',self.valeur) :
- self.valeur=self.valeur.replace('Fin Commentaire','')
+ self.valeur=self.valeur.replace('Fin Commentaire','')
J=self.jdc.__class__(procedure=self.valeur,
definition=self.jdc.definition,
cata=self.jdc.cata,
Booleenne qui retourne 1 si self est valide, 0 sinon
"""
return self.actif
-
+
def verifConditionBloc(self):
- """
- Evalue les conditions de tous les blocs fils possibles
- (en fonction du catalogue donc de la definition) de self et
- retourne deux listes :
- - la premiere contient les noms des blocs a rajouter
- - la seconde contient les noms des blocs a supprimer
- """
- return [],[]
+ """
+ Evalue les conditions de tous les blocs fils possibles
+ (en fonction du catalogue donc de la definition) de self et
+ retourne deux listes :
+ - la premiere contient les noms des blocs a rajouter
+ - la seconde contient les noms des blocs a supprimer
+ """
+ return [],[]
def 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
- """
- return []
+ """
+ Retourne la liste des mots-cles a rajouter pour satisfaire les regles
+ en fonction de la liste des mots-cles presents
+ """
+ return []
def reparent(self,parent):
- """
- Cette methode sert a reinitialiser la parente de l'objet
- """
- self.parent=parent
- self.jdc=parent.getJdcRoot()
- self.etape=self
+ """
+ Cette methode sert a reinitialiser la parente de l'objet
+ """
+ self.parent=parent
+ self.jdc=parent.getJdcRoot()
+ self.etape=self
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
- --> sans objet pour les commandes commentarisees
- """
- pass
-
+ """
+ Verifie que les structures de donnees utilisees dans self existent bien dans le contexte
+ avant etape, sinon enleve la reference a ces concepts
+ --> sans objet pour les commandes commentarisees
+ """
+ pass
+
def controlSdprods(self,d):
- """sans objet pour les commandes commentarisees"""
- pass
+ """sans objet pour les commandes commentarisees"""
+ pass
def close(self):
- pass
+ pass
def resetContext(self):
- pass
-
+ pass
from Extensions.i18n import tr
class COMMENTAIRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT) :
- """
- Cette classe permet de creer des objets de type COMMENTAIRE
- """
- nature = 'COMMENTAIRE'
- idracine = '_comm'
-
- def __init__(self,valeur,parent=None):
- # parent est un objet de type OBJECT (ETAPE ou MC ou JDC...)
- self.valeur=valeur
- if not parent :
- self.jdc = self.parent = CONTEXT.getCurrentStep()
- else:
- self.jdc = self.parent = parent
- # La classe COMMENTAIRE n'a pas de definition. On utilise self
- # pour completude
- self.definition=self
- self.nom=''
- self.niveau = self.parent.niveau
- self.actif=1
- self.state="unchanged"
- self.register()
- self.fenetreIhm=None
-
- def register(self):
- """
- Enregistre le commentaire dans la liste des etapes de son parent
- lorsque celui-ci est un JDC
"""
- if self.parent.nature == 'JDC':
- # le commentaire est entre deux commandes:
- # il faut l'enregistrer dans la liste des etapes
- self.parent.register(self)
-
- def copy(self):
- c=COMMENTAIRE(valeur=self.valeur,parent=self.jdc)
- return c
-
- def isValid(self):
- """
- Retourne 1 si self est valide, 0 sinon
- Retourne toujours 1 car un commentaire est toujours valide
- """
- return 1
-
- def isOblig(self):
- """ Indique si self est obligatoire ou non : retourne toujours 0 """
- return 0
-
- def isRepetable(self):
- """ Indique si self est repetable ou non : retourne toujours 1 """
- return 1
-
- def active(self):
- """
- Rend l'etape courante active
- """
- self.actif = 1
-
- def inactive(self):
- """
- Rend l'etape courante inactive
- NB : un commentaire est toujours actif !
- """
- self.actif = 1
-
- def isActif(self):
- """
- Booleenne qui retourne 1 si self est valide, 0 sinon
- """
- return self.actif
-
- def supprime(self):
- """
- Methode qui supprime toutes les boucles de references afin que
- l'objet puisse etre correctement detruit par le garbage collector
- """
- self.parent=None
- self.jdc=None
- self.definition = None
- self.niveau = None
-
- def listeMcPresents(self):
- return []
-
- def getValeur(self) :
- """ Retourne la valeur de self, cad le contenu du commentaire """
- try :
- return self.valeur
- except:
- return None
-
- def setValeur(self,new_valeur):
- """
- Remplace la valeur de self(si elle existe) par new_valeur
- """
- self.valeur = new_valeur
- self.initModif()
-
- def initModif(self):
- self.state = 'modified'
- if self.parent:
- self.parent.initModif()
-
- def supprimeSdProds(self):
- pass
-
- def updateContext(self,d):
- """
- Update le dictionnaire d avec les concepts ou objets produits par self
- --> ne fait rien pour un commentaire
- """
- pass
-
- def report(self):
- """ Genere l'objet rapport (classe CR) """
- self.cr=CR()
- if not self.isValid(): self.cr.warn(tr("Objet commentaire non valorise"))
- return self.cr
-
- def ident(self):
- """ Retourne le nom interne associe a self
- Ce nom n'est jamais vu par l'utilisateur dans EFICAS
- """
- return self.nom
-
- def deleteConcept(self,sd):
- pass
-
- def replaceConcept (self,old_sd,sd):
- pass
-
- def verifConditionBloc(self):
- """
- Evalue les conditions de tous les blocs fils possibles
- (en fonction du catalogue donc de la definition) de self et
- retourne deux listes :
- - la premiere contient les noms des blocs a rajouter
- - la seconde contient les noms des blocs a supprimer
- """
- return [],[]
-
- def verifConditionRegles(self,liste_presents):
+ Cette classe permet de creer des objets de type COMMENTAIRE
"""
- Retourne la liste des mots-cles a rajouter pour satisfaire les regles
- en fonction de la liste des mots-cles presents
- """
- return []
-
- def getSdprods(self,nom_sd):
- """
- Retourne les concepts produits par la commande
- """
- return None
-
- def verifExistenceSd(self):
- pass
-
- def getFr(self):
- """
- Retourne le commentaire lui meme tronque a la 1ere ligne
- """
- return self.valeur.split('\n',1)[0]
-
- def controlSdprods(self,d):
- """sans objet """
- pass
-
- def close(self):
- pass
-
- def resetContext(self):
- pass
-
-
+ nature = 'COMMENTAIRE'
+ idracine = '_comm'
+
+ def __init__(self,valeur,parent=None):
+ # parent est un objet de type OBJECT (ETAPE ou MC ou JDC...)
+ self.valeur=valeur
+ if not parent :
+ self.jdc = self.parent = CONTEXT.getCurrentStep()
+ else:
+ self.jdc = self.parent = parent
+ # La classe COMMENTAIRE n'a pas de definition. On utilise self
+ # pour completude
+ self.definition=self
+ self.nom=''
+ self.niveau = self.parent.niveau
+ self.actif=1
+ self.state="unchanged"
+ self.register()
+ self.fenetreIhm=None
+
+ def register(self):
+ """
+ Enregistre le commentaire dans la liste des etapes de son parent
+ lorsque celui-ci est un JDC
+ """
+ if self.parent.nature == 'JDC':
+ # le commentaire est entre deux commandes:
+ # il faut l'enregistrer dans la liste des etapes
+ self.parent.register(self)
+
+ def copy(self):
+ c=COMMENTAIRE(valeur=self.valeur,parent=self.jdc)
+ return c
+
+ def isValid(self):
+ """
+ Retourne 1 si self est valide, 0 sinon
+ Retourne toujours 1 car un commentaire est toujours valide
+ """
+ return 1
+
+ def isOblig(self):
+ """ Indique si self est obligatoire ou non : retourne toujours 0 """
+ return 0
+
+ def isRepetable(self):
+ """ Indique si self est repetable ou non : retourne toujours 1 """
+ return 1
+
+ def active(self):
+ """
+ Rend l'etape courante active
+ """
+ self.actif = 1
+
+ def inactive(self):
+ """
+ Rend l'etape courante inactive
+ NB : un commentaire est toujours actif !
+ """
+ self.actif = 1
+
+ def isActif(self):
+ """
+ Booleenne qui retourne 1 si self est valide, 0 sinon
+ """
+ return self.actif
+
+ def supprime(self):
+ """
+ Methode qui supprime toutes les boucles de references afin que
+ l'objet puisse etre correctement detruit par le garbage collector
+ """
+ self.parent=None
+ self.jdc=None
+ self.definition = None
+ self.niveau = None
+
+ def listeMcPresents(self):
+ return []
+
+ def getValeur(self) :
+ """ Retourne la valeur de self, cad le contenu du commentaire """
+ try :
+ return self.valeur
+ except:
+ return None
+
+ def setValeur(self,new_valeur):
+ """
+ Remplace la valeur de self(si elle existe) par new_valeur
+ """
+ self.valeur = new_valeur
+ self.initModif()
+
+ def initModif(self):
+ self.state = 'modified'
+ if self.parent:
+ self.parent.initModif()
+
+ def supprimeSdProds(self):
+ pass
+
+ def updateContext(self,d):
+ """
+ Update le dictionnaire d avec les concepts ou objets produits par self
+ --> ne fait rien pour un commentaire
+ """
+ pass
+
+ def report(self):
+ """ Genere l'objet rapport (classe CR) """
+ self.cr=CR()
+ if not self.isValid(): self.cr.warn(tr("Objet commentaire non valorise"))
+ return self.cr
+
+ def ident(self):
+ """ Retourne le nom interne associe a self
+ Ce nom n'est jamais vu par l'utilisateur dans EFICAS
+ """
+ return self.nom
+
+ def deleteConcept(self,sd):
+ pass
+
+ def replaceConcept (self,old_sd,sd):
+ pass
+
+ def verifConditionBloc(self):
+ """
+ Evalue les conditions de tous les blocs fils possibles
+ (en fonction du catalogue donc de la definition) de self et
+ retourne deux listes :
+ - la premiere contient les noms des blocs a rajouter
+ - la seconde contient les noms des blocs a supprimer
+ """
+ return [],[]
+
+ def 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
+ """
+ return []
+
+ def getSdprods(self,nom_sd):
+ """
+ Retourne les concepts produits par la commande
+ """
+ return None
+
+ def verifExistenceSd(self):
+ pass
+
+ def getFr(self):
+ """
+ Retourne le commentaire lui meme tronque a la 1ere ligne
+ """
+ return self.valeur.split('\n',1)[0]
+
+ def controlSdprods(self,d):
+ """sans objet """
+ pass
+
+ def close(self):
+ pass
+
+ def resetContext(self):
+ pass
# with this program. If not, see <http://www.gnu.org/licenses/>.
"""
Creates the ``EficasException`` class for the EDF Eficas application.
-This class supports the internationalization mechanism provided in
+This class supports the internationalization mechanism provided in
the ``i18n`` module.
"""
#sys.path.append(os.path.realpath(".."))
from Extensions.i18n import tr
self.args = (tr(msg),)
-
+
if __name__ == "__main__":
import sys
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
"""
- Ce module contient la classe ETAPE_NIVEAU qui sert a
+ Ce module contient la classe ETAPE_NIVEAU qui sert a
concretiser les niveaux au sein d'un JDC
"""
from __future__ import absolute_import
class ETAPE_NIVEAU(N_OBJECT.OBJECT):
- def __init__(self,niveau,parent):
- self.parent = parent
- self.jdc = self.parent.getJdcRoot()
- self.niveau = self
- self.definition = niveau
- self.etapes=[]
- self.etapes_niveaux = []
- self.dict_niveaux={}
- self.editmode = 0
- self.state="undetermined"
- self.buildNiveaux()
-
- def buildNiveaux(self):
- for niveau in self.definition.l_niveaux:
- etape_niveau = ETAPE_NIVEAU(niveau,self)
- self.etapes_niveaux.append(etape_niveau)
- self.dict_niveaux[niveau.nom]=etape_niveau
-
- def register(self,etape):
- """
- Enregistre la commande etape :
- - si editmode = 0 : on est en mode relecture d'un fichier de commandes
- auquel cas on ajoute etape a la fin de la liste self.etapes
- - si editmode = 1 : on est en mode ajout d'etape depuis eficas auquel cas
- cette methode ne fait rien, c'est addEntite qui enregistre etape
- a la bonne place dans self.etapes
- """
- if self.editmode : return
- self.etapes.append(etape)
-
- def unregister(self,etape):
- """
- Desenregistre l'etape du niveau
- """
- self.etapes.remove(etape)
-
- def ident(self):
- return self.definition.label
-
- def isActif(self):
- #print 'Niveau : ',self.definition.nom
- #print '\tactif =',self.definition.actif
- if self.definition.actif == 1 :
- return 1
- else :
- # self.actif est une condition a evaluer dans un certain contexte ...
- d = self.creeDictValeurs()
- try:
- t=eval(self.definition.actif,d)
- return t
- except:
- traceback.print_exc()
- return 0
-
- def creeDictValeurs(self):
- """
- Retourne le dictionnaire des freres aines de self compose des couples :
- {nom_frere isValid()}
- """
- d={}
- for niveau in self.parent.etapes_niveaux:
- if niveau is self : break
- d[niveau.definition.nom]=niveau.isValid()
- return d
-
- def isValid(self):
- """ Methode booleenne qui retourne 0 si le niveau est invalide, 1 sinon """
- if self.etapes_niveaux == []:
- if len(self.etapes) == 0:
- return self.definition.valide_vide
- else:
- for etape in self.etapes :
- if not etape.isValid() : return 0
- return 1
- else:
- for etape_niveau in self.etapes_niveaux :
- if not etape_niveau.isValid() : return 0
- return 1
-
- def accept(self,visitor):
- visitor.visitETAPE_NIVEAU(self)
-
- def addEntite(self,name,pos_rel):
- self.editmode = 1
- try :
- pos_abs=self.jdc.getNbEtapesAvant(self)+pos_rel
- cmd = self.jdc.addEntite(name,pos_abs)
- self.etapes.insert(pos_rel,cmd)
- self.editmode = 0
- return cmd
- except:
- traceback.print_exc()
- self.editmode = 0
- return None
-
- def suppEntite(self,etape) :
- """ Classe ETAPE_NIVEAU
- Supprime une etape
- """
- self.jdc.suppEntite(etape)
-
-
- def getFr(self):
- """
- Retourne le texte d'aide dans la langue choisie
- """
- try :
- return getattr(self.definition,self.jdc.lang)
- except:
- return ''
-
+ def __init__(self,niveau,parent):
+ self.parent = parent
+ self.jdc = self.parent.getJdcRoot()
+ self.niveau = self
+ self.definition = niveau
+ self.etapes=[]
+ self.etapes_niveaux = []
+ self.dict_niveaux={}
+ self.editmode = 0
+ self.state="undetermined"
+ self.buildNiveaux()
+
+ def buildNiveaux(self):
+ for niveau in self.definition.l_niveaux:
+ etape_niveau = ETAPE_NIVEAU(niveau,self)
+ self.etapes_niveaux.append(etape_niveau)
+ self.dict_niveaux[niveau.nom]=etape_niveau
+
+ def register(self,etape):
+ """
+ Enregistre la commande etape :
+ - si editmode = 0 : on est en mode relecture d'un fichier de commandes
+ auquel cas on ajoute etape a la fin de la liste self.etapes
+ - si editmode = 1 : on est en mode ajout d'etape depuis eficas auquel cas
+ cette methode ne fait rien, c'est addEntite qui enregistre etape
+ a la bonne place dans self.etapes
+ """
+ if self.editmode : return
+ self.etapes.append(etape)
+
+ def unregister(self,etape):
+ """
+ Desenregistre l'etape du niveau
+ """
+ self.etapes.remove(etape)
+
+ def ident(self):
+ return self.definition.label
+
+ def isActif(self):
+ #print 'Niveau : ',self.definition.nom
+ #print '\tactif =',self.definition.actif
+ if self.definition.actif == 1 :
+ return 1
+ else :
+ # self.actif est une condition a evaluer dans un certain contexte ...
+ d = self.creeDictValeurs()
+ try:
+ t=eval(self.definition.actif,d)
+ return t
+ except:
+ traceback.print_exc()
+ return 0
+
+ def creeDictValeurs(self):
+ """
+ Retourne le dictionnaire des freres aines de self compose des couples :
+ {nom_frere isValid()}
+ """
+ d={}
+ for niveau in self.parent.etapes_niveaux:
+ if niveau is self : break
+ d[niveau.definition.nom]=niveau.isValid()
+ return d
+
+ def isValid(self):
+ """ Methode booleenne qui retourne 0 si le niveau est invalide, 1 sinon """
+ if self.etapes_niveaux == []:
+ if len(self.etapes) == 0:
+ return self.definition.valide_vide
+ else:
+ for etape in self.etapes :
+ if not etape.isValid() : return 0
+ return 1
+ else:
+ for etape_niveau in self.etapes_niveaux :
+ if not etape_niveau.isValid() : return 0
+ return 1
+
+ def accept(self,visitor):
+ visitor.visitETAPE_NIVEAU(self)
+
+ def addEntite(self,name,pos_rel):
+ self.editmode = 1
+ try :
+ pos_abs=self.jdc.getNbEtapesAvant(self)+pos_rel
+ cmd = self.jdc.addEntite(name,pos_abs)
+ self.etapes.insert(pos_rel,cmd)
+ self.editmode = 0
+ return cmd
+ except:
+ traceback.print_exc()
+ self.editmode = 0
+ return None
+
+ def suppEntite(self,etape) :
+ """ Classe ETAPE_NIVEAU
+ Supprime une etape
+ """
+ self.jdc.suppEntite(etape)
+
+
+ def getFr(self):
+ """
+ Retourne le texte d'aide dans la langue choisie
+ """
+ try :
+ return getattr(self.definition,self.jdc.lang)
+ except:
+ return ''
#
from __future__ import absolute_import
from __future__ import print_function
-try :
- from builtins import str
- from builtins import object
+try :
+ from builtins import str
+ from builtins import object
except : pass
import re,sys,types
return 0
else:
return 1
-
+
class InterpreteurException(Exception):
"""
Classe servant a definir les exceptions levees par l'interpreteur de formule
'LOG10','SIN','COS','TAN','ASIN','ACOS','ATAN','SINH',
'COSH','TANH','HEAVYSID']
l_constantes = ['PI','RD_RG','DG_RD']
-
+
def __init__(self,formule=None,constantes=[],fonctions=[],parent=None):
"""
Constructeur d'interpreteurs de formule Aster
if nom[0] in ('+','-') : nom = nom[1:]
self.cr.debut = tr("Debut Fonction %s", nom)
self.cr.fin = tr("Fin Fonction %s", nom)
-
+
def str(self):
"""
Retourne une liste de chaines de caracteres representant la formule
"""
txt = self.cr.report()
return txt
-
+
def enregistre(self,fils):
"""
Enregistre un operateur fils dans la liste des children
"""
self.l_children.append(fils)
self.cr.add(fils.cr)
-
+
def isValid(self):
"""
Booleenne qui retourne 1 si la formule est valide, 0 sinon
Methode externe
"""
self.l_operateurs = []
- self.cr.purge() # on vide le cr
+ self.cr.purge() # on vide le cr
self.initCr() # on initialise le cr
self.interpreteFormule()
return self.cr.estvide()
self.d_fonctions_unaires[new_fonc[0]] = self.getNbArgs(new_fonc)
#self.d_fonctions_unaires.update(self.new_fonctions_unaires)
self.l_fonctions_unaires = list(self.d_fonctions_unaires.keys())
-
+
def ordonneListes(self):
"""
Ordonne les listes de fonctions unaires et binaires
self.l_fonctions_binaires.sort(cmp_function)
self.l_fonctions_unaires.sort(cmp_function)
self.l_constantes.sort(cmp_function)
-
+
def splitOperateurs(self,texte):
"""
else:
# on n'a pas trouve de nombre
return None,texte
-
+
def chercheConstanteOld(self,texte):
"""
Recherche une constante en debut de texte parmi la liste des constantes.
else:
# aucune constante trouvee
return None,texte
-
+
def chercheArgs(self,texte):
"""
Cherche au debut de texte une liste d'arguments entre parentheses
else:
# on a fini d'analyser le texte : reste = None
return texte,None
-
+
def chercheOperateurUnaireOld(self,texte):
"""
Cherche dans texte un operateur unaire
elif texte[0] == '-':
# Il faut pouvoir trapper les expressions du type exp(-(x+1)) ...
try :
- args,reste = self.chercheArgs(texte[1:])
+ args,reste = self.chercheArgs(texte[1:])
except InterpreteurException as e:
raise InterpreteurException (e.__str__())
if not args :
- # Il ne s'agit pas de '-' comme operateur unaire --> on retourne None
- return None,texte
+ # Il ne s'agit pas de '-' comme operateur unaire --> on retourne None
+ return None,texte
else:
- identificateur = '-'
- args = self.splitArgs(identificateur,args,self.d_fonctions_unaires[identificateur])
- formule_operateur = (identificateur,'',self.t_formule[2],args)
- operateur = Interpreteur_Formule(formule = formule_operateur,
- constantes = self.new_constantes,
- fonctions = self.new_fonctions_unaires,
- parent = self)
- operateur.interpreteFormule()
- texte = reste
- return operateur,reste
+ identificateur = '-'
+ args = self.splitArgs(identificateur,args,self.d_fonctions_unaires[identificateur])
+ formule_operateur = (identificateur,'',self.t_formule[2],args)
+ operateur = Interpreteur_Formule(formule = formule_operateur,
+ constantes = self.new_constantes,
+ fonctions = self.new_fonctions_unaires,
+ parent = self)
+ operateur.interpreteFormule()
+ texte = reste
+ return operateur,reste
else:
return None,texte
-
+
def chercheOperateurBinaire(self,texte):
"""
Cherche dans texte un operateur unaire
operateur.interpreteFormule()
texte = reste
return operateur,reste
-
+
def splitArgs(self,nom_fonction,args,nb_args):
"""
Tente de partager args en nb_args elements
pour traiter les niveaux au sein d'un JDC
"""
from __future__ import absolute_import
-try :
- from builtins import object
+try :
+ from builtins import object
except : pass
from . import etape_niveau
class JDC(object):
- def __init__(self):
- self.dict_niveaux={}
- self.buildNiveaux()
-
- def buildNiveaux(self):
- for niveau in self.definition.l_niveaux:
- etape_niv = etape_niveau.ETAPE_NIVEAU(niveau,self)
- self.etapes_niveaux.append(etape_niv)
- self.dict_niveaux[niveau.nom]=etape_niv
- self.dict_niveaux.update(etape_niv.dict_niveaux)
+ def __init__(self):
+ self.dict_niveaux={}
+ self.buildNiveaux()
+ def buildNiveaux(self):
+ for niveau in self.definition.l_niveaux:
+ etape_niv = etape_niveau.ETAPE_NIVEAU(niveau,self)
+ self.etapes_niveaux.append(etape_niv)
+ self.dict_niveaux[niveau.nom]=etape_niv
+ self.dict_niveaux.update(etape_niv.dict_niveaux)
from Ihm import CONNECTOR
class JDC_POURSUITE(JDC):
- def __init__(self,definition=None,procedure=None,cata=None,
- cata_ord_dico=None,parent=None,
- nom='SansNom',appli=None,context_ini=None,
- jdc_pere=None,etape_include=None,prefix_include=None,
- recorded_units=None,old_recorded_units=None,**args):
-
- JDC.__init__(self, definition=definition,
- procedure=procedure,
- cata=cata,
- cata_ord_dico=cata_ord_dico,
- parent=parent,
- nom=nom,
- appli=appli,
- context_ini=context_ini,
- **args
- )
- self.jdc_pere=jdc_pere
- self.etape_include=etape_include
- self.prefix_include=prefix_include
- if recorded_units is not None:self.recorded_units=recorded_units
- if old_recorded_units is not None:self.old_recorded_units=old_recorded_units
-
- def o_register(self,sd):
- return self.jdc_pere.o_register(sd)
-
- def nommerSDProd(self,sd,sdnom,restrict='non'):
- """
- Nomme la SD apres avoir verifie que le nommage est possible : nom
- non utilise
- Ajoute un prefixe s'il est specifie (INCLUDE_MATERIAU)
- Si le nom est deja utilise, leve une exception
- Met le concept cree dans le contexe global g_context
- """
- #print "nommerSDProd",sd,sdnom,restrict
- if self.prefix_include:
- if sdnom != self.prefix_include:sdnom=self.prefix_include+sdnom
-
- if sdnom != '' and sdnom[0] == '_':
- # Si le nom du concept commence par le caractere _ on lui attribue
- # un identificateur automatique comme dans JEVEUX (voir gcncon)
- #
- # nom commencant par __ : il s'agit de concepts qui seront detruits
- # nom commencant par _ : il s'agit de concepts intermediaires qui seront gardes
- # ATTENTION : il faut traiter differemment les concepts dont le nom
- # commence par _ mais qui sont des concepts nommes automatiquement par
- # une eventuelle sous macro.
- if sdnom[1] in string.digits:
- # Ce concept provient probablement d'une sous macro (cas improbable)
- #pas de renommage
- pass
- elif sdnom[1] == '_':
- #cas d'un concept a ne pas conserver apres execution de la commande
- sdnom=sd.id[2:]
- pass
- else:
- sdnom=sd.id[2:]
- pass
-
- o=self.sdsDict.get(sdnom,None)
- if isinstance(o,ASSD):
- raise AsException(tr("Nom de concept deja defini : %s" ,sdnom))
-
- # On pourrait verifier que le jdc_pere apres l'etape etape_include
- # ne contient pas deja un concept de ce nom
- #if self.jdc_pere.getSdApresEtapeAvecDetruire(sdnom,etape=self.etape_include):
- # Il existe un concept apres self => impossible d'inserer
- # raise AsException("Nom de concept deja defini : %s" % sdnom)
- # On a choisi de ne pas faire ce test ici mais de le faire en bloc
- # si necessaire apres en appelant la methode verifContexte
-
- # ATTENTION : Il ne faut pas ajouter sd dans sds car il s y trouve deja.
- # Ajoute a la creation (appel de regSD).
- self.sdsDict[sdnom]=sd
- sd.nom=sdnom
-
- # En plus si restrict vaut 'non', on insere le concept dans le contexte du JDC
- if restrict == 'non':
- self.g_context[sdnom]=sd
-
- def getVerifContexte(self):
- #print "getVerifContexte"
- j_context=self.getContexteAvant(None)
- self.verifContexte(j_context)
- return j_context
-
- def forceContexte(self,contexte):
- for nom_sd,sd in list(contexte.items()):
- if not isinstance(sd,ASSD):continue
- autre_sd= self.jdc_pere.getSdApresEtapeAvecDetruire(nom_sd,sd,
- etape=self.etape_include)
- if autre_sd is None:continue
- if sd is not autre_sd:
- # Il existe un autre concept de meme nom produit par une etape apres self
- # on detruit ce concept pour pouvoir inserer les etapes du jdc_include
- if sd.etape:
- sd.etape.supprimeSdprod(sd)
-
- return contexte
-
- def verifContexte(self,context):
- """
- Cette methode verifie si le contexte passe en argument (context)
- peut etre insere dans le jdc pere de l'include.
- Elle verifie que les concepts contenus dans ce contexte n'entrent
- pas en conflit avec les concepts produits dans le jdc pere
- apres l'include.
- Si le contexte ne peut pas etre insere, la methode leve une
- exception sinon elle retourne le contexte inchange
- """
- #print "verifContexte"
- for nom_sd,sd in list(context.items()):
- if not isinstance(sd,ASSD):continue
- autre_sd= self.jdc_pere.getSdApresEtapeAvecDetruire(nom_sd,sd,
- etape=self.etape_include)
- if autre_sd is None:continue
- if sd is not autre_sd:
- # Il existe un concept produit par une etape apres self
- # => impossible d'inserer
- raise Exception("Impossible d'inclure le fichier. Un concept de nom " +
- "%s existe deja dans le jeu de commandes." % nom_sd)
-
- return context
-
- def getListeCmd(self):
- """
- Retourne la liste des commandes du catalogue
- """
- if self.jdc_pere is None:
- return JDC.getListeCmd(self)
- return self.jdc_pere.getListeCmd()
-
- def getGroups(self):
- """
- Retourne la liste des commandes du catalogue par groupes
- """
- if self.jdc_pere is None:
- return JDC.getGroups(self)
- return self.jdc_pere.getGroups()
-
- def initModif(self):
- """
- Met l'etat de l'etape a : modifie
- Propage la modification au parent
-
- Attention : initModif doit etre appele avant de realiser une modification
- La validite devra etre recalculee apres cette modification
- mais par un appel a finModif pour preserver l'etat modified
- de tous les objets entre temps
- """
- #print "jdc_include.initModif",self,self.etape_include
- self.state = 'modified'
- if self.etape_include:
- self.etape_include.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
- """
- #print "jdc_include.finModif",self,self.etape_include
- CONNECTOR.Emit(self,"valid")
- if self.etape_include:
- self.etape_include.finModif()
-
- def supprime(self):
- """
- On ne supprime rien directement pour un jdc auxiliaire d'include ou de poursuite
- Utiliser supprime_aux
- """
- pass
-
- def supprime_aux(self):
- #print "supprime_aux",self
- JDC.supprime(self)
- self.jdc_pere=None
- self.etape_include=None
- # self.cata_ordonne_dico={}
- self.appli=None
- # self.context_ini={}
- # self.procedure=None
-
- def getContexteAvant(self,etape):
- """
- Retourne le dictionnaire des concepts connus avant etape
- On tient compte des concepts produits par le jdc pere
- en reactualisant le contexte initial context_ini
- 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
- """
- #print "jdc_include.getContexteAvant",etape,etape and etape.nom
- if self.etape_include:
- new_context=self.etape_include.parent.getContexteAvant(self.etape_include).copy()
- self.context_ini=new_context
- d= JDC.getContexteAvant(self,etape)
- return d
-
- def resetContext(self):
- #print "jdc_include.resetContext",self,self.nom
- if self.etape_include:
- self.etape_include.parent.resetContext()
- new_context=self.etape_include.parent.getContexteAvant(self.etape_include).copy()
- self.context_ini=new_context
- JDC.resetContext(self)
-
- 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
- """
- if self.etape_include:
- sd=self.etape_include.parent.getSdApresEtape(nom_sd,self.etape_include,'non')
- if sd:return sd
- return JDC.getSdApresEtape(self,nom_sd,etape,avec)
-
- def getSdApresEtapeAvecDetruire(self,nom_sd,sd,etape,avec='non'):
- """
- On veut savoir ce que devient le concept sd de nom nom_sd apres etape.
- Il peut etre detruit, remplace ou conserve
- 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_include.getSdApresEtapeAvecDetruire",nom_sd,sd,id(sd)
- autre_sd=JDC.getSdApresEtapeAvecDetruire(self,nom_sd,sd,etape,avec)
- # si autre_sd vaut None le concept sd a ete detruit. On peut terminer
- # la recherche en retournant None
- # Si autre_sd ne vaut pas sd, le concept a ete redefini. On peut terminer
- # la recherche en retournant le concept nouvellement defini
- # Sinon, on poursuit la recherche dans les etapes du niveau superieur.
- if autre_sd is None or autre_sd is not sd :return autre_sd
- return self.etape_include.parent.getSdApresEtapeAvecDetruire(nom_sd,sd,self.etape_include,'non')
-
- def deleteConcept(self,sd):
- """
- 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
- """
- # Nettoyage des etapes de l'include
- JDC.deleteConcept(self,sd)
- # Nettoyage des etapes du parent
- if self.etape_include:
- self.etape_include.parent.deleteConceptAfterEtape(self.etape_include,sd)
-
- def deleteConceptAfterEtape(self,etape,sd):
- """
- Fonction : Mettre a jour les etapes du JDC qui sont apres etape suite a
- la disparition du concept sd
- """
- # Nettoyage des etapes de l'include
- JDC.deleteConceptAfterEtape(self,etape,sd)
- # Nettoyage des etapes du parent
- if self.etape_include:
- self.etape_include.parent.deleteConceptAfterEtape(self.etape_include,sd)
-
- def updateConceptAfterEtape(self,etape,sd):
- """
- Fonction : mettre a jour les etapes du JDC suite a une modification
- du concept sd (principalement renommage)
- """
- JDC.updateConceptAfterEtape(self,etape,sd)
- if self.etape_include:
- self.etape_include.parent.updateConceptAfterEtape(self.etape_include,sd)
-
- def replaceConceptAfterEtape(self,etape,old_sd,sd):
- """
- Fonction : Mettre a jour les etapes du JDC qui sont apres etape suite au
- remplacement du concept old_sd par sd
- """
- # Nettoyage des etapes de l'include
- JDC.replaceConceptAfterEtape(self,etape,old_sd,sd)
- # Nettoyage des etapes du parent
- if self.etape_include:
- self.etape_include.parent.replaceConceptAfterEtape(self.etape_include,old_sd,sd)
-
- def changeFichier(self,fichier):
- if self.etape_include:
- self.etape_include.fichier_ini=fichier
- self.finModif()
-
- def controlContextApres(self,etape):
- """
- Cette methode verifie que les etapes apres l'etape etape
- ont bien des concepts produits acceptables (pas de conflit de
- nom principalement)
- Si des concepts produits ne sont pas acceptables ils sont supprimes.
- Effectue les verifications sur les etapes du jdc mais aussi sur les
- jdc parents s'ils existent.
- """
- #print "jdc_include.controlContextApres",self,etape
- #Regularise les etapes du jdc apres l'etape etape
- self.controlJdcContextApres(etape)
- if self.etape_include:
- #print "CONTROL_INCLUDE:",self.etape_include,self.etape_include.nom
- # il existe un jdc pere. On propage la regularisation
- self.etape_include.parent.controlContextApres(self.etape_include)
+ def __init__(self,definition=None,procedure=None,cata=None,
+ cata_ord_dico=None,parent=None,
+ nom='SansNom',appli=None,context_ini=None,
+ jdc_pere=None,etape_include=None,prefix_include=None,
+ recorded_units=None,old_recorded_units=None,**args):
+
+ JDC.__init__(self, definition=definition,
+ procedure=procedure,
+ cata=cata,
+ cata_ord_dico=cata_ord_dico,
+ parent=parent,
+ nom=nom,
+ appli=appli,
+ context_ini=context_ini,
+ **args
+ )
+ self.jdc_pere=jdc_pere
+ self.etape_include=etape_include
+ self.prefix_include=prefix_include
+ if recorded_units is not None:self.recorded_units=recorded_units
+ if old_recorded_units is not None:self.old_recorded_units=old_recorded_units
+
+ def o_register(self,sd):
+ return self.jdc_pere.o_register(sd)
+
+ def nommerSDProd(self,sd,sdnom,restrict='non'):
+ """
+ Nomme la SD apres avoir verifie que le nommage est possible : nom
+ non utilise
+ Ajoute un prefixe s'il est specifie (INCLUDE_MATERIAU)
+ Si le nom est deja utilise, leve une exception
+ Met le concept cree dans le contexe global g_context
+ """
+ #print "nommerSDProd",sd,sdnom,restrict
+ if self.prefix_include:
+ if sdnom != self.prefix_include:sdnom=self.prefix_include+sdnom
+
+ if sdnom != '' and sdnom[0] == '_':
+ # Si le nom du concept commence par le caractere _ on lui attribue
+ # un identificateur automatique comme dans JEVEUX (voir gcncon)
+ #
+ # nom commencant par __ : il s'agit de concepts qui seront detruits
+ # nom commencant par _ : il s'agit de concepts intermediaires qui seront gardes
+ # ATTENTION : il faut traiter differemment les concepts dont le nom
+ # commence par _ mais qui sont des concepts nommes automatiquement par
+ # une eventuelle sous macro.
+ if sdnom[1] in string.digits:
+ # Ce concept provient probablement d'une sous macro (cas improbable)
+ #pas de renommage
+ pass
+ elif sdnom[1] == '_':
+ #cas d'un concept a ne pas conserver apres execution de la commande
+ sdnom=sd.id[2:]
+ pass
+ else:
+ sdnom=sd.id[2:]
+ pass
+
+ o=self.sdsDict.get(sdnom,None)
+ if isinstance(o,ASSD):
+ raise AsException(tr("Nom de concept deja defini : %s" ,sdnom))
+
+ # On pourrait verifier que le jdc_pere apres l'etape etape_include
+ # ne contient pas deja un concept de ce nom
+ #if self.jdc_pere.getSdApresEtapeAvecDetruire(sdnom,etape=self.etape_include):
+ # Il existe un concept apres self => impossible d'inserer
+ # raise AsException("Nom de concept deja defini : %s" % sdnom)
+ # On a choisi de ne pas faire ce test ici mais de le faire en bloc
+ # si necessaire apres en appelant la methode verifContexte
+
+ # ATTENTION : Il ne faut pas ajouter sd dans sds car il s y trouve deja.
+ # Ajoute a la creation (appel de regSD).
+ self.sdsDict[sdnom]=sd
+ sd.nom=sdnom
+
+ # En plus si restrict vaut 'non', on insere le concept dans le contexte du JDC
+ if restrict == 'non':
+ self.g_context[sdnom]=sd
+
+ def getVerifContexte(self):
+ #print "getVerifContexte"
+ j_context=self.getContexteAvant(None)
+ self.verifContexte(j_context)
+ return j_context
+
+ def forceContexte(self,contexte):
+ for nom_sd,sd in list(contexte.items()):
+ if not isinstance(sd,ASSD):continue
+ autre_sd= self.jdc_pere.getSdApresEtapeAvecDetruire(nom_sd,sd,
+ etape=self.etape_include)
+ if autre_sd is None:continue
+ if sd is not autre_sd:
+ # Il existe un autre concept de meme nom produit par une etape apres self
+ # on detruit ce concept pour pouvoir inserer les etapes du jdc_include
+ if sd.etape:
+ sd.etape.supprimeSdprod(sd)
+
+ return contexte
+
+ def verifContexte(self,context):
+ """
+ Cette methode verifie si le contexte passe en argument (context)
+ peut etre insere dans le jdc pere de l'include.
+ Elle verifie que les concepts contenus dans ce contexte n'entrent
+ pas en conflit avec les concepts produits dans le jdc pere
+ apres l'include.
+ Si le contexte ne peut pas etre insere, la methode leve une
+ exception sinon elle retourne le contexte inchange
+ """
+ #print "verifContexte"
+ for nom_sd,sd in list(context.items()):
+ if not isinstance(sd,ASSD):continue
+ autre_sd= self.jdc_pere.getSdApresEtapeAvecDetruire(nom_sd,sd,
+ etape=self.etape_include)
+ if autre_sd is None:continue
+ if sd is not autre_sd:
+ # Il existe un concept produit par une etape apres self
+ # => impossible d'inserer
+ raise Exception("Impossible d'inclure le fichier. Un concept de nom " +
+ "%s existe deja dans le jeu de commandes." % nom_sd)
+
+ return context
+
+ def getListeCmd(self):
+ """
+ Retourne la liste des commandes du catalogue
+ """
+ if self.jdc_pere is None:
+ return JDC.getListeCmd(self)
+ return self.jdc_pere.getListeCmd()
+
+ def getGroups(self):
+ """
+ Retourne la liste des commandes du catalogue par groupes
+ """
+ if self.jdc_pere is None:
+ return JDC.getGroups(self)
+ return self.jdc_pere.getGroups()
+
+ def initModif(self):
+ """
+ Met l'etat de l'etape a : modifie
+ Propage la modification au parent
+
+ Attention : initModif doit etre appele avant de realiser une modification
+ La validite devra etre recalculee apres cette modification
+ mais par un appel a finModif pour preserver l'etat modified
+ de tous les objets entre temps
+ """
+ #print "jdc_include.initModif",self,self.etape_include
+ self.state = 'modified'
+ if self.etape_include:
+ self.etape_include.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
+ """
+ #print "jdc_include.finModif",self,self.etape_include
+ CONNECTOR.Emit(self,"valid")
+ if self.etape_include:
+ self.etape_include.finModif()
+
+ def supprime(self):
+ """
+ On ne supprime rien directement pour un jdc auxiliaire d'include ou de poursuite
+ Utiliser supprime_aux
+ """
+ pass
+
+ def supprime_aux(self):
+ #print "supprime_aux",self
+ JDC.supprime(self)
+ self.jdc_pere=None
+ self.etape_include=None
+ # self.cata_ordonne_dico={}
+ self.appli=None
+ # self.context_ini={}
+ # self.procedure=None
+
+ def getContexteAvant(self,etape):
+ """
+ Retourne le dictionnaire des concepts connus avant etape
+ On tient compte des concepts produits par le jdc pere
+ en reactualisant le contexte initial context_ini
+ 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
+ """
+ #print "jdc_include.getContexteAvant",etape,etape and etape.nom
+ if self.etape_include:
+ new_context=self.etape_include.parent.getContexteAvant(self.etape_include).copy()
+ self.context_ini=new_context
+ d= JDC.getContexteAvant(self,etape)
+ return d
+
+ def resetContext(self):
+ #print "jdc_include.resetContext",self,self.nom
+ if self.etape_include:
+ self.etape_include.parent.resetContext()
+ new_context=self.etape_include.parent.getContexteAvant(self.etape_include).copy()
+ self.context_ini=new_context
+ JDC.resetContext(self)
+
+ 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
+ """
+ if self.etape_include:
+ sd=self.etape_include.parent.getSdApresEtape(nom_sd,self.etape_include,'non')
+ if sd:return sd
+ return JDC.getSdApresEtape(self,nom_sd,etape,avec)
+
+ def getSdApresEtapeAvecDetruire(self,nom_sd,sd,etape,avec='non'):
+ """
+ On veut savoir ce que devient le concept sd de nom nom_sd apres etape.
+ Il peut etre detruit, remplace ou conserve
+ 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_include.getSdApresEtapeAvecDetruire",nom_sd,sd,id(sd)
+ autre_sd=JDC.getSdApresEtapeAvecDetruire(self,nom_sd,sd,etape,avec)
+ # si autre_sd vaut None le concept sd a ete detruit. On peut terminer
+ # la recherche en retournant None
+ # Si autre_sd ne vaut pas sd, le concept a ete redefini. On peut terminer
+ # la recherche en retournant le concept nouvellement defini
+ # Sinon, on poursuit la recherche dans les etapes du niveau superieur.
+ if autre_sd is None or autre_sd is not sd :return autre_sd
+ return self.etape_include.parent.getSdApresEtapeAvecDetruire(nom_sd,sd,self.etape_include,'non')
+
+ def deleteConcept(self,sd):
+ """
+ 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
+ """
+ # Nettoyage des etapes de l'include
+ JDC.deleteConcept(self,sd)
+ # Nettoyage des etapes du parent
+ if self.etape_include:
+ self.etape_include.parent.deleteConceptAfterEtape(self.etape_include,sd)
+
+ def deleteConceptAfterEtape(self,etape,sd):
+ """
+ Fonction : Mettre a jour les etapes du JDC qui sont apres etape suite a
+ la disparition du concept sd
+ """
+ # Nettoyage des etapes de l'include
+ JDC.deleteConceptAfterEtape(self,etape,sd)
+ # Nettoyage des etapes du parent
+ if self.etape_include:
+ self.etape_include.parent.deleteConceptAfterEtape(self.etape_include,sd)
+
+ def updateConceptAfterEtape(self,etape,sd):
+ """
+ Fonction : mettre a jour les etapes du JDC suite a une modification
+ du concept sd (principalement renommage)
+ """
+ JDC.updateConceptAfterEtape(self,etape,sd)
+ if self.etape_include:
+ self.etape_include.parent.updateConceptAfterEtape(self.etape_include,sd)
+
+ def replaceConceptAfterEtape(self,etape,old_sd,sd):
+ """
+ Fonction : Mettre a jour les etapes du JDC qui sont apres etape suite au
+ remplacement du concept old_sd par sd
+ """
+ # Nettoyage des etapes de l'include
+ JDC.replaceConceptAfterEtape(self,etape,old_sd,sd)
+ # Nettoyage des etapes du parent
+ if self.etape_include:
+ self.etape_include.parent.replaceConceptAfterEtape(self.etape_include,old_sd,sd)
+
+ def changeFichier(self,fichier):
+ if self.etape_include:
+ self.etape_include.fichier_ini=fichier
+ self.finModif()
+
+ def controlContextApres(self,etape):
+ """
+ Cette methode verifie que les etapes apres l'etape etape
+ ont bien des concepts produits acceptables (pas de conflit de
+ nom principalement)
+ Si des concepts produits ne sont pas acceptables ils sont supprimes.
+ Effectue les verifications sur les etapes du jdc mais aussi sur les
+ jdc parents s'ils existent.
+ """
+ #print "jdc_include.controlContextApres",self,etape
+ #Regularise les etapes du jdc apres l'etape etape
+ self.controlJdcContextApres(etape)
+ if self.etape_include:
+ #print "CONTROL_INCLUDE:",self.etape_include,self.etape_include.nom
+ # il existe un jdc pere. On propage la regularisation
+ self.etape_include.parent.controlContextApres(self.etape_include)
class JDC_INCLUDE(JDC_POURSUITE):
- def getListeCmd(self):
- """
- Retourne la liste des commandes du catalogue
- """
- if self.jdc_pere is None:
- return JDC.getListeCmd(self)
- return [e for e in self.jdc_pere.getListeCmd() if e not in ("DEBUT","POURSUITE","FIN") ]
-
- def activeEtapes(self):
- for e in self.etapes:
- e.active()
+ def getListeCmd(self):
+ """
+ Retourne la liste des commandes du catalogue
+ """
+ if self.jdc_pere is None:
+ return JDC.getListeCmd(self)
+ return [e for e in self.jdc_pere.getListeCmd() if e not in ("DEBUT","POURSUITE","FIN") ]
+
+ def activeEtapes(self):
+ for e in self.etapes:
+ e.active()
class JDC_CATA_INCLUDE(JDC_CATA):
- class_instance=JDC_INCLUDE
+ class_instance=JDC_INCLUDE
class JDC_CATA_POURSUITE(JDC_CATA):
- class_instance=JDC_POURSUITE
+ class_instance=JDC_POURSUITE
from Accas import AU_MOINS_UN,A_CLASSER
A_CLASSER(('DEBUT','POURSUITE'),'FIN')
)
)
-
-
import os
try :
- from PyQt5.QtCore import QTranslator
- code_translator = QTranslator()
- eficas_translator = QTranslator()
+ from PyQt5.QtCore import QTranslator
+ code_translator = QTranslator()
+ eficas_translator = QTranslator()
except :
- code_translator = None
- eficas_translator = None
- print ('pas d import de qt, pas de traduction')
-
+ code_translator = None
+ eficas_translator = None
+ print ('pas d import de qt, pas de traduction')
+
def localise(application, locale=None,file=None,translatorFichier=None, debug=False ):
"""
"""
- if code_translator == None :
- print ('qt not avalaible, no translation')
- return
+ if code_translator == None :
+ print ('qt not avalaible, no translation')
+ return
from PyQt5.QtCore import QLibraryInfo
from PyQt5.QtCore import QLocale
from PyQt5.QtWidgets import QApplication
sys_locale = QLocale.system().name()
if locale is None: locale="fr"
-
+
if locale=="ang" : locale="en"
if file != None and debug :
- print ('chargement de ', file,monPath)
- print (eficas_translator.load(file,monPath))
- print (QApplication.installTranslator(eficas_translator))
+ print ('chargement de ', file,monPath)
+ print (eficas_translator.load(file,monPath))
+ print (QApplication.installTranslator(eficas_translator))
elif eficas_translator.load("eficas_" + locale, monPath):
- QApplication.installTranslator(eficas_translator)
+ QApplication.installTranslator(eficas_translator)
elif debug:
- print ("Unable to load Eficas translator!")
-
+ print ("Unable to load Eficas translator!")
+
if debug : print ('translatorFichier :' ,translatorFichier)
if translatorFichier != None :
- if (code_translator.load(translatorFichier)) and debug:
- print (translatorFichier, ' loaded')
- elif (code_translator.load(translatorFichier+'_'+locale) and debug):
- print(translatorFichier+'_'+locale+ ' loaded')
- elif debug :
- print ("Unable to load Code translator! No file or No translation" + translatorFichier)
- if debug : print (QApplication.installTranslator(code_translator))
- else : QApplication.installTranslator(code_translator)
-
+ if (code_translator.load(translatorFichier)) and debug:
+ print (translatorFichier, ' loaded')
+ elif (code_translator.load(translatorFichier+'_'+locale) and debug):
+ print(translatorFichier+'_'+locale+ ' loaded')
+ elif debug :
+ print ("Unable to load Code translator! No file or No translation" + translatorFichier)
+ if debug : print (QApplication.installTranslator(code_translator))
+ else : QApplication.installTranslator(code_translator)
+
if __name__ == "__main__":
import sys
"""
# Modules Python
from __future__ import absolute_import
-try :
- from builtins import str
+try :
+ from builtins import str
except : pass
from Extensions.i18n import tr
class MCNUPLET(V_MCCOMPO.MCCOMPO,N_MCCOMPO.MCCOMPO):
- """
- """
- nature = "MCNUPLET"
- txt_nat="Nuplet : "
-
- def __init__(self,val,definition,nom,parent):
- # val contient la valeur initial du nuplet
- self.val = val
- if val == None: self.val=()
- self.definition=definition
- self.nom=nom
- self.parent = parent
- # getValeurEffective affecte la valeur par defaut si necessaire
- self.valeur=self.getValeurEffective(self.val)
- if parent :
- self.jdc = self.parent.jdc
- self.niveau = self.parent.niveau
- self.etape = self.parent.etape
- else:
- # Le mot cle a ete cree sans parent
- self.jdc = None
- self.niveau = None
- self.etape = None
- self.state = 'undetermined'
- self.actif=1
- self.mcListe=self.buildMc()
-
- def buildMc(self):
- """
- Construit la liste des sous-entites de MCNUPLET
- a partir de la liste des arguments (valeur)
- """
- args = self.valeur
- if args ==None : args =()
- mcListe=[]
-
- # on cree les sous entites du NUPLET a partir des valeurs initiales
- k=0
- for v in self.definition.entites:
- if k < len(args):
- val=args[k]
+ """
+ """
+ nature = "MCNUPLET"
+ txt_nat="Nuplet : "
+
+ def __init__(self,val,definition,nom,parent):
+ #print ('MCNUPLET pour', nom)
+ # val contient la valeur initial du nuplet
+ self.val = val
+ if val == None: self.val=()
+ self.definition=definition
+ self.nom=nom
+ self.parent = parent
+ # getValeurEffective affecte la valeur par defaut si necessaire
+ self.valeur=self.getValeurEffective(self.val)
+ if parent :
+ self.jdc = self.parent.jdc
+ self.niveau = self.parent.niveau
+ self.etape = self.parent.etape
else:
- val=None
- objet=v(val=val,nom=repr(k),parent=self)
- if hasattr(objet.definition,'position'):
- if objet.definition.position == 'global' :
- self.append_mc_global(objet)
- #XXX et global_jdc ??
- mcListe.append(objet)
- k=k+1
- # Un nuplet n'a pas de mots inconnus
- self.reste_val={}
- return mcListe
-
- def isValid(self,cr='non'):
- """
- Indique si self (MCNUPLET) est un objet valide ou non : retourne 1 si oui, 0 sinon
- """
- if self.state == 'unchanged' :
- return self.valid
- else:
- valid = 1
- if hasattr(self,'valid'):
- old_valid = self.valid
+ # Le mot cle a ete cree sans parent
+ self.jdc = None
+ self.niveau = None
+ self.etape = None
+ self.state = 'undetermined'
+ self.actif=1
+ self.mcListe=self.buildMc()
+
+ def buildMc(self):
+ """
+ Construit la liste des sous-entites de MCNUPLET
+ a partir de la liste des arguments (valeur)
+ """
+ args = self.valeur
+ if args ==None : args =()
+ mcListe=[]
+
+ # on cree les sous entites du NUPLET a partir des valeurs initiales
+ k=0
+ for v in self.definition.entites:
+ if k < len(args):
+ val=args[k]
+ else:
+ val=None
+ objet=v(val=val,nom=repr(k),parent=self)
+ if hasattr(objet.definition,'position'):
+ if objet.definition.position == 'global' :
+ self.append_mc_global(objet)
+ #XXX et global_jdc ??
+ mcListe.append(objet)
+ k=k+1
+ # Un nuplet n'a pas de mots inconnus
+ self.reste_val={}
+ return mcListe
+
+ def isValid(self,cr='non'):
+ """
+ Indique si self (MCNUPLET) est un objet valide ou non : retourne 1 si oui, 0 sinon
+ """
+ if self.state == 'unchanged' :
+ return self.valid
else:
- old_valid = None
- for child in self.mcListe :
- if not child.isValid():
- valid = 0
- break
- if len(self.mcListe) != len(self.definition.entites):
- valid=0
- if cr == 'oui' :
- self.cr.fatal(''.join(("Nuplet : ",self.nom,tr("Longueur incorrecte"))))
- self.valid = valid
- self.state = 'unchanged'
- if old_valid:
- if old_valid != self.valid : self.initModifUp()
- return self.valid
-
- def __getitem__(self,key):
- """
- Retourne le key eme element du nuplet
- """
- # Un nuplet est toujours une liste de mots cles simples
- # On retourne donc la valeur
- return self.mcListe[key].valeur
-
- def __str__(self):
- """
- Retourne une representation du nuplet sous forme de chaine
- de caracteres
- """
- s='('
- for e in self.mcListe:
- s=s + str(e.valeur) + ','
- return s + ')'
-
- def __repr__(self):
- """
- Retourne une representation du nuplet sous forme de chaine
- de caracteres
- """
- s='('
- for e in self.mcListe:
- s=s + str(e.valeur) + ','
- return s + ')'
-
- def getRegles(self):
- """
- Retourne la liste des regles attachees au nuplet
- """
- return []
-
- def verifConditionBloc(self):
- """
- Verifie s'il y a des blocs sous le nuplet et retourne
- les blocs en question
- """
- # Il n y a pas de BLOCs sous un NUPLET
- return [],[]
-
- def isRepetable(self):
- """
- Indique si le NUPLET peut etre repete.
- Retourne 1 si c'est le cas.
- Retourne 0 dans le cas contraire.
- L'information est donnee par le catalogue, cad la definition de self
- """
- if self.definition.min != self.definition.max :
- return 1
- else :
- return 0
-
- def makeobjet(self):
- return self.definition(val = None, nom = self.nom,parent = self.parent)
-
- def getValeur(self):
- """
- Cette methode doit retourner la valeur de l'objet. Elle est utilisee par
- creeDictValeurs pour construire un dictionnaire contenant les mots cles
- d'une etape.
- Dans le cas d'un nuplet, on retournera comme valeur une liste des valeurs
- des mots cle simples contenus.
- """
- l=[]
- for v in self.mcListe:
- l.append(v.valeur)
- return l
-
- def getVal(self):
- """
- Une autre methode qui retourne une "autre" valeur du mot cle facteur.
- Elle est utilisee par la methode getMocle
- """
- l=[]
- for v in self.mcListe:
- l.append(v.valeur)
- return l
-
- def isOblig(self):
- return self.definition.statut=='o'
-
- def getFr(self):
- """
- Retourne le texte d'aide dans la langue choisie
- """
- try :
- return getattr(self.definition,self.jdc.lang)
- except:
- return ''
-
- def creeDictValeurs(self,liste=[],condition=0):
- dico={}
- return dico
-
- def updateConditionBloc(self):
- """
- Realise l'update des blocs conditionnels fils de self
- et propage au parent (rien a faire pour nuplet)
- """
-
-
-
-
-
+ valid = 1
+ if hasattr(self,'valid'):
+ old_valid = self.valid
+ else:
+ old_valid = None
+ for child in self.mcListe :
+ if not child.isValid():
+ valid = 0
+ break
+ if len(self.mcListe) != len(self.definition.entites):
+ valid=0
+ if cr == 'oui' :
+ self.cr.fatal(''.join(("Nuplet : ",self.nom,tr("Longueur incorrecte"))))
+ self.valid = valid
+ self.state = 'unchanged'
+ if old_valid:
+ if old_valid != self.valid : self.initModifUp()
+ return self.valid
+
+ def __getitem__(self,key):
+ """
+ Retourne le key eme element du nuplet
+ """
+ # Un nuplet est toujours une liste de mots cles simples
+ # On retourne donc la valeur
+ return self.mcListe[key].valeur
+
+ def __str__(self):
+ """
+ Retourne une representation du nuplet sous forme de chaine
+ de caracteres
+ """
+ s='('
+ for e in self.mcListe:
+ s=s + str(e.valeur) + ','
+ return s + ')'
+
+ def __repr__(self):
+ """
+ Retourne une representation du nuplet sous forme de chaine
+ de caracteres
+ """
+ s='('
+ for e in self.mcListe:
+ s=s + str(e.valeur) + ','
+ return s + ')'
+
+ def getRegles(self):
+ """
+ Retourne la liste des regles attachees au nuplet
+ """
+ return []
+
+ def verifConditionBloc(self):
+ """
+ Verifie s'il y a des blocs sous le nuplet et retourne
+ les blocs en question
+ """
+ # Il n y a pas de BLOCs sous un NUPLET
+ return [],[]
+
+ def isRepetable(self):
+ """
+ Indique si le NUPLET peut etre repete.
+ Retourne 1 si c'est le cas.
+ Retourne 0 dans le cas contraire.
+ L'information est donnee par le catalogue, cad la definition de self
+ """
+ if self.definition.min != self.definition.max :
+ return 1
+ else :
+ return 0
+
+ def makeobjet(self):
+ return self.definition(val = None, nom = self.nom,parent = self.parent)
+
+ def getValeur(self):
+ """
+ Cette methode doit retourner la valeur de l'objet. Elle est utilisee par
+ creeDictValeurs pour construire un dictionnaire contenant les mots cles
+ d'une etape.
+ Dans le cas d'un nuplet, on retournera comme valeur une liste des valeurs
+ des mots cle simples contenus.
+ """
+ l=[]
+ for v in self.mcListe:
+ l.append(v.valeur)
+ return l
+
+ def getVal(self):
+ """
+ Une autre methode qui retourne une "autre" valeur du mot cle facteur.
+ Elle est utilisee par la methode getMocle
+ """
+ l=[]
+ for v in self.mcListe:
+ l.append(v.valeur)
+ return l
+
+ def isOblig(self):
+ return self.definition.statut=='o'
+
+ def getFr(self):
+ """
+ Retourne le texte d'aide dans la langue choisie
+ """
+ try :
+ return getattr(self.definition,self.jdc.lang)
+ except:
+ return ''
+
+ def creeDictValeurs(self,liste=[],condition=0):
+ dico={}
+ return dico
+
+ def updateConditionBloc(self):
+ """
+ Realise l'update des blocs conditionnels fils de self
+ et propage au parent (rien a faire pour nuplet)
+ """
des groupes de commandes dans le catalogue
"""
-try :
- from builtins import object
+try :
+ from builtins import object
except : pass
class NIVEAU(object):
- def __init__(self,nom='',label='',niveaux=(),valide_vide=1,actif=1):
- self.nom = nom
- self.label = label
- self.statut='o'
- self.min = 1
- self.max = 1
- self.entites = []
- self.l_noms_entites=[]
- self.valide_vide = valide_vide
- self.actif = actif
- self.d_niveaux = {}
- self.l_niveaux = niveaux
- for niveau in niveaux:
- self.d_niveaux[niveau.nom]=niveau
- self.d_niveaux.update(niveau.d_niveaux)
+ def __init__(self,nom='',label='',niveaux=(),valide_vide=1,actif=1):
+ self.nom = nom
+ self.label = label
+ self.statut='o'
+ self.min = 1
+ self.max = 1
+ self.entites = []
+ self.l_noms_entites=[]
+ self.valide_vide = valide_vide
+ self.actif = actif
+ self.d_niveaux = {}
+ self.l_niveaux = niveaux
+ for niveau in niveaux:
+ self.d_niveaux[niveau.nom]=niveau
+ self.d_niveaux.update(niveau.d_niveaux)
- def enregistre(self,commande):
- self.entites.append(commande)
- self.l_noms_entites.append(commande.nom)
-
- def getListeCmd(self):
- self.l_noms_entites.sort()
- return self.l_noms_entites
+ def enregistre(self,commande):
+ self.entites.append(commande)
+ self.l_noms_entites.append(commande.nom)
+ def getListeCmd(self):
+ self.l_noms_entites.sort()
+ return self.l_noms_entites
"""
# Modules Python
from __future__ import absolute_import
-try :
- from builtins import str
+try :
+ from builtins import str
except : pass
import types
from . import mcnuplet
class NUPL(N_ENTITE.ENTITE,I_ENTITE.ENTITE):
- """
- """
- class_instance = mcnuplet.MCNUPLET
- list_instance = N_MCLIST.MCList
- label='NUPLET'
- CR=N_CR.CR
+ """
+ """
+ class_instance = mcnuplet.MCNUPLET
+ list_instance = N_MCLIST.MCList
+ label='NUPLET'
+ CR=N_CR.CR
- def __init__(self,fr="",ang="",docu="",statut='f',defaut=None,min=0,max=1,
- elements=None):
- N_ENTITE.ENTITE.__init__(self)
- I_ENTITE.ENTITE.__init__(self)
- self.fr=fr
- self.ang=ang
- self.docu=docu
- self.statut=statut
- self.defaut=defaut
- self.min=min
- self.max=max
- if self.max =='**' : self.max=float('inf')
- if self.min =='**' : self.min=float('-inf')
- self.entites=elements
- self.regles=()
- # on force le statut des sous entites a obligatoire
- for e in elements:e.statut='o'
- self.idracine="NUPLET"
- self.affecter_parente()
+ def __init__(self,fr="",ang="",docu="",statut='f',defaut=None,min=0,max=1,
+ elements=None):
+ N_ENTITE.ENTITE.__init__(self)
+ I_ENTITE.ENTITE.__init__(self)
+ self.fr=fr
+ self.ang=ang
+ self.docu=docu
+ self.statut=statut
+ self.defaut=defaut
+ self.min=min
+ self.max=max
+ if self.max =='**' : self.max=float('inf')
+ if self.min =='**' : self.min=float('-inf')
+ self.entites=elements
+ self.regles=()
+ # on force le statut des sous entites a obligatoire
+ for e in elements:e.statut='o'
+ self.idracine="NUPLET"
+ self.affecter_parente()
- def verifCata(self):
- """
- Cette methode sert a valider les attributs de l'objet de definition
- de la classe NUPL
- """
- if type(self.min) != int :
- if self.min != '**' and self.min != float('-inf'):
- self.cr.fatal(tr("L'attribut 'min' doit etre un entier : ")+str(self.min))
- if type(self.max) != int :
- if self.max != '**' and self.max != float('inf'):
- self.cr.fatal(tr("L'attribut 'max' doit etre un entier : ")+str(self.max))
- if self.min > self.max :
- self.cr.fatal(tr("Nombres d'occurrence min et max invalides :") +str(self.min)+","+str(self.max))
- if type(self.fr) != bytes and type(self.fr) != str :
- self.cr.fatal(tr("L'attribut 'fr' doit etre une chaine de caracteres"))
- if self.statut not in ['o','f','c','d']:
- self.cr.fatal(tr("L'attribut 'statut' doit valoir 'o','f','c' ou 'd'"))
- if type(self.docu) != bytes and type(self.docu) != str :
- self.cr.fatal(tr("L'attribut 'docu' doit etre une chaine de caracteres"))
- self.verifCataRegles()
+ def verifCata(self):
+ """
+ Cette methode sert a valider les attributs de l'objet de definition
+ de la classe NUPL
+ """
+ if type(self.min) != int :
+ if self.min != '**' and self.min != float('-inf'):
+ self.cr.fatal(tr("L'attribut 'min' doit etre un entier : ")+str(self.min))
+ if type(self.max) != int :
+ if self.max != '**' and self.max != float('inf'):
+ self.cr.fatal(tr("L'attribut 'max' doit etre un entier : ")+str(self.max))
+ if self.min > self.max :
+ self.cr.fatal(tr("Nombres d'occurrence min et max invalides :") +str(self.min)+","+str(self.max))
+ if type(self.fr) != bytes and type(self.fr) != str :
+ self.cr.fatal(tr("L'attribut 'fr' doit etre une chaine de caracteres"))
+ if self.statut not in ['o','f','c','d']:
+ self.cr.fatal(tr("L'attribut 'statut' doit valoir 'o','f','c' ou 'd'"))
+ if type(self.docu) != bytes and type(self.docu) != str :
+ self.cr.fatal(tr("L'attribut 'docu' doit etre une chaine de caracteres"))
+ self.verifCataRegles()
- def __call__(self,val,nom,parent):
- """
- Construit la structure de donnees pour un NUPLET a partir de sa definition (self)
- de sa valeur (val), de son nom (nom) et de son parent dans l arboresence (parent)
- """
- if (type(val) == tuple or type(val) == list) and type(val[0]) == tuple:
- # On est en presence d une liste de nuplets
- l=self.list_instance()
- l.init(nom=nom,parent=parent)
- for v in val:
- objet=self.class_instance(nom=nom,definition=self,val=v,parent=parent)
- l.append(objet)
- return l
- else:
- # on est en presence d un seul nuplet
- return self.class_instance(nom=nom,definition=self,val=val,parent=parent)
+ def __call__(self,val,nom,parent):
+ """
+ Construit la structure de donnees pour un NUPLET a partir de sa definition (self)
+ de sa valeur (val), de son nom (nom) et de son parent dans l arboresence (parent)
+ """
+ if (type(val) == tuple or type(val) == list) and type(val[0]) == tuple:
+ # On est en presence d une liste de nuplets
+ l=self.list_instance()
+ l.init(nom=nom,parent=parent)
+ for v in val:
+ objet=self.class_instance(nom=nom,definition=self,val=v,parent=parent)
+ l.append(objet)
+ return l
+ else:
+ # on est en presence d un seul nuplet
+ return self.class_instance(nom=nom,definition=self,val=val,parent=parent)
- def report(self):
- """
- Methode qui cree le rapport de verification du catalogue du nuplet
- """
- self.cr = self.CR()
- self.verifCata()
- for v in self.entites :
- cr = v.report()
- cr.debut =tr("Debut ")+v.__class__.__name__+ ' : '
- cr.fin =tr("Fin ")+v.__class__.__name__+ ' : '
- self.cr.add(cr)
- return self.cr
-
- def affecter_parente(self):
- """
- Cette methode a pour fonction de donner un nom et un pere aux
- sous entites qui n'ont aucun moyen pour atteindre leur parent
- directement
- Il s'agit principalement des mots cles
- """
- k=0
- for v in self.entites:
- v.pere = self
- v.nom = str(k)
- k=k+1
+ def report(self):
+ """
+ Methode qui cree le rapport de verification du catalogue du nuplet
+ """
+ self.cr = self.CR()
+ self.verifCata()
+ for v in self.entites :
+ cr = v.report()
+ cr.debut =tr("Debut ")+v.__class__.__name__+ ' : '
+ cr.fin =tr("Fin ")+v.__class__.__name__+ ' : '
+ self.cr.add(cr)
+ return self.cr
+ def affecter_parente(self):
+ """
+ Cette methode a pour fonction de donner un nom et un pere aux
+ sous entites qui n'ont aucun moyen pour atteindre leur parent
+ directement
+ Il s'agit principalement des mots cles
+ """
+ k=0
+ for v in self.entites:
+ v.pere = self
+ v.nom = str(k)
+ k=k+1
from __future__ import division
from __future__ import absolute_import
try :
- from builtins import str
- from builtins import object
+ from builtins import str
+ from builtins import object
except : pass
import math
import types
import six
try:
- import Numeric
+ import Numeric
except:
- try:
- import numpy
- Numeric = numpy
- except ImportError:
- Numeric = None
+ try:
+ import numpy
+ Numeric = numpy
+ except ImportError:
+ Numeric = None
def mkf(value):
val=self.eval()
if val is None:return 0
try:
- return len(val)
+ return len(val)
except:
- return 1
+ return 1
def __complex__(self): return complex(self.eval())
def __int__(self): return int(self.eval())
def __long__(self): return int(self.eval())
def __rfloordiv__(self, other): return Binop('//', other, self)
def __pow__(self, other): return Binop('**', self, other)
def __rpow__(self, other): return Binop('**', other, self)
- def __getitem__(self,i):
+ def __getitem__(self,i):
if i > len(self) : raise StopIteration
return Binop('[]',self,i)
def __cmp__( self, other ): return self.eval().__cmp__(other)
def __hash__(self):return id(self)
def _div(a,b):
- if isinstance(a,six.integer_types) and isinstance(b,six.integer_types):
- if a%b:
- return a/b
+ if isinstance(a,six.integer_types) and isinstance(b,six.integer_types):
+ if a%b:
+ return a/b
+ else:
+ return a//b
else:
- return a//b
- else:
- return a/b
+ return a/b
class Binop(Formula):
def __str__(self):
if self.op == '[]':
- return "%s[%s]" % (self.values[0], self.values[1])
+ return "%s[%s]" % (self.values[0], self.values[1])
else:
- return "(%s %s %s)" % (self.values[0], self.op, self.values[1])
+ return "(%s %s %s)" % (self.values[0], self.op, self.values[1])
def __repr__(self):
if self.op == '[]':
- return "%s[%s]" % (self.values[0], self.values[1])
+ return "%s[%s]" % (self.values[0], self.values[1])
else:
- return "(%s %s %s)" % (self.values[0], self.op, self.values[1])
+ return "(%s %s %s)" % (self.values[0], self.op, self.values[1])
def eval(self):
result= self.opmap[self.op](self.values[0].eval(),
self.values[1].eval())
while isinstance(result,Formula):
- result=result.eval()
+ result=result.eval()
return result
def __adapt__(self,validator):
return validator.adapt(self.eval())
self._op = op
self._arg=[]
for a in arg:
- self._arg.append(mkf(a))
+ self._arg.append(mkf(a))
def __str__(self):
s="%s(" % self._nom
for a in self._arg:
- s=s+str(a)+','
+ s=s+str(a)+','
s=s+")"
return s
def __repr__(self):
s="%s(" % self._nom
for a in self._arg:
- s=s+str(a)+','
+ s=s+str(a)+','
s=s+")"
return s
def eval(self):
l=[]
for a in self._arg:
- l.append(a.eval())
+ l.append(a.eval())
return self._op(*l)
class Constant(Formula):
def cos(f): return Unop('ncos', f)
def sin(f): return Unop('nsin', f)
-def array(f,*tup,**args):
+def array(f,*tup,**args):
"""array de Numeric met en defaut la mecanique des parametres
on la supprime dans ce cas. Il faut que la valeur du parametre soit bien definie
"""
def __init__(self):
if hasattr(self,'pi') :return
import math
- try :
- self.toSurcharge()
+ try :
+ self.toSurcharge()
except : pass
def toSurcharge(self):
def toOriginal(self):
import math
try:
- import Numeric
+ import Numeric
except:
- import numpy
- Numeric = numpy
+ import numpy
+ Numeric = numpy
- try :
- Numeric.cos=originalMath.numeric_ncos
- Numeric.sin=originalMath.numeric_nsin
- Numeric.array=originalMath.numeric_narray
+ try :
+ Numeric.cos=originalMath.numeric_ncos
+ Numeric.sin=originalMath.numeric_nsin
+ Numeric.array=originalMath.numeric_narray
except : pass
math.sin=originalMath.sin
math.cos=originalMath.cos
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 de modules Eficas
from Noyau.N_CR import CR
from Noyau.N_UserASSD import UserASSD
+from Noyau.N_UserASSDMultiple import UserASSDMultiple
from Noyau import N_OBJECT
from Ihm import I_OBJECT
from .param2 import *
class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) :
- """
- Cette classe permet de creer des objets de type PARAMETRE
- cad des affectations directes dans le jeu de commandes (ex: a=10.)
- qui sont interpretees par le parseur de fichiers Python.
- Les objets ainsi crees constituent des parametres pour le jdc
- """
-
- nature = 'PARAMETRE'
- idracine = 'param'
-
- def __new__(cls,nom,valeur=None):
- # on est en relecture du .comm: l objet a ete detecte comme parametre par le parsing
- # mais il s agit d une reference, une UserASDD
- if (issubclass(valeur.__class__, UserASSD)):
- valeur.initialiseNom(nom)
- return valeur
- try :
- return super(PARAMETRE, cls).__new__(cls,*args,**kwargs)
- except :
- return super(PARAMETRE, cls).__new__(cls)
-
-
- def __init__(self,nom,valeur=None):
- #print ('__init__ de parametre pour', nom,valeur)
- self.nom = nom
- # La classe PARAMETRE n'a pas de definition : on utilise self pour
- # completude
- self.definition=self
- # parent ne peut etre qu'un objet de type JDC
- self.jdc = self.parent = CONTEXT.getCurrentStep()
- self.niveau=self.parent.niveau
- self.actif=1
- self.state='undetermined'
- self.register()
- self.dict_valeur=[]
- #self.valeur = self.interpreteValeur(valeur)
- #self.val=valeur
- self.valeur = valeur
- self.val=repr(valeur)
- self.fenetreIhm=None
-
- def interpreteValeur(self,val):
"""
- Essaie d'interpreter val (chaine de caracteres)comme :
- - un entier
- - un reel
- - une chaine de caracteres
- - une liste d'items d'un type qui precede
- Retourne la valeur interpretee
- """
- #if not val : return None
- valeur = None
-
- if type(val) == list:
- # Un premier traitement a ete fait lors de la saisie
- # permet de tester les parametres qui sont des listes
- l_new_val = []
- for v in val :
- try :
- valeur=eval(str(v))
- l_new_val.append(v)
- except :
- return None
- return l_new_val
-
- if type(val) == bytes or type(val) == str:
- # on tente l'evaluation dans un contexte fourni par le parent s'il existe
- if self.parent:
- valeur=self.parent.evalInContext(val,self)
- else:
- try :
- valeur = eval(val)
- except:
- #traceback.print_exc()
- pass
- #PN je n ose pas modifier je rajoute
- # refus des listes heterogenes : ne dvrait pas etre la
- if valeur != None :
- if type(valeur) == tuple:
+ Cette classe permet de creer des objets de type PARAMETRE
+ cad des affectations directes dans le jeu de commandes (ex: a=10.)
+ qui sont interpretees par le parseur de fichiers Python.
+ Les objets ainsi crees constituent des parametres pour le jdc
+ """
+
+ nature = 'PARAMETRE'
+ idracine = 'param'
+
+ def __new__(cls,nom,valeur=None):
+ # on est en relecture du .comm: l objet a ete detecte comme parametre par le parsing
+ # mais il s agit d une reference, une UserASDD
+ if (issubclass(valeur.__class__, UserASSDMultiple)):
+ valeur.initialiseNom(nom)
+ return valeur
+ if (issubclass(valeur.__class__, UserASSD)):
+ valeur.initialiseNom(nom)
+ return valeur
+ try :
+ return super(PARAMETRE, cls).__new__(cls,*args,**kwargs)
+ except :
+ return super(PARAMETRE, cls).__new__(cls)
+
+
+ def __init__(self,nom,valeur=None):
+ #print ('__init__ de parametre pour', nom,valeur)
+ self.nom = nom
+ # La classe PARAMETRE n'a pas de definition : on utilise self pour
+ # completude
+ self.definition=self
+ # parent ne peut etre qu'un objet de type JDC
+ self.jdc = self.parent = CONTEXT.getCurrentStep()
+ self.niveau=self.parent.niveau
+ self.actif=1
+ self.state='undetermined'
+ self.register()
+ self.dict_valeur=[]
+ #self.valeur = self.interpreteValeur(valeur)
+ #self.val=valeur
+ self.valeur = valeur
+ self.val=repr(valeur)
+ self.fenetreIhm=None
+
+ def interpreteValeur(self,val):
+ """
+ Essaie d'interpreter val (chaine de caracteres)comme :
+ - un entier
+ - un reel
+ - une chaine de caracteres
+ - une liste d'items d'un type qui precede
+ Retourne la valeur interpretee
+ """
+ #if not val : return None
+ valeur = None
+
+ if type(val) == list:
+ # Un premier traitement a ete fait lors de la saisie
+ # permet de tester les parametres qui sont des listes
l_new_val = []
- typ = None
- for v in valeur :
- if not typ:
- typ = type(v)
- else:
- if type(v) != typ :
- # la liste est heterogene --> on refuse d'interpreter
- # self comme une liste
- # on retourne la string initiale
- print(('liste heterogene ',val))
- return val
- l_new_val.append(v)
- return tuple(l_new_val)
-
- if valeur != None :
- if type(valeur).__name__ == 'list':
- self.dict_valeur=[]
- for i in range(len(valeur)):
- self.dict_valeur.append(valeur[i])
- return valeur
- # on retourne val comme une string car on n'a pas su l'interpreter
- return val
-
- def getValeurs(self):
- valeurretour=[]
- if self.dict_valeur != []:
- for val in self.dict_valeur:
- valeurretour.append(val)
- else:
- valeurretour.append(self.valeur)
- return valeurretour
-
- def setValeur(self,new_valeur):
- """
- Remplace la valeur de self par new_valeur interpretee
- """
- self.valeur = self.interpreteValeur(new_valeur)
- self.val=repr(self.valeur)
- self.parent.updateConceptAfterEtape(self,self)
- self.initModif()
-
- def setNom(self,new_nom):
- """
- Change le nom du parametre
- """
- self.initModif()
- self.nom=new_nom
- self.finModif()
-
- def initModif(self):
- """
- Methode qui declare l'objet courant comme modifie et propage
- cet etat modifie a ses ascendants
- """
- self.state = 'modified'
- if self.parent:
- self.parent.initModif()
-
- def getJdcRoot(self):
- if self.parent:
- return self.parent.getJdcRoot()
- else:
- return self
-
- def register(self):
- """
- Enregistre le parametre dans la liste des etapes de son parent (JDC)
- """
- self.parent.registerParametre(self)
- self.parent.register(self)
-
- def isValid(self,cr='non'):
- """
- Retourne 1 si self est valide, 0 sinon
- Un parametre est considere comme valide si :
- - il a un nom
- - il a une valeur
- """
- if self.nom == '' :
- if cr == 'oui':
- self.cr.fatal(tr("Pas de nom donne au parametre "))
- return 0
- else:
- if self.valeur == None :
- if cr == 'oui' :
- self.cr.fatal(tr("Le parametre %s ne peut valoir None" , self.nom))
+ for v in val :
+ try :
+ valeur=eval(str(v))
+ l_new_val.append(v)
+ except :
+ return None
+ return l_new_val
+
+ if type(val) == bytes or type(val) == str:
+ # on tente l'evaluation dans un contexte fourni par le parent s'il existe
+ if self.parent:
+ valeur=self.parent.evalInContext(val,self)
+ else:
+ try :
+ valeur = eval(val)
+ except:
+ #traceback.print_exc()
+ pass
+ #PN je n ose pas modifier je rajoute
+ # refus des listes heterogenes : ne dvrait pas etre la
+ if valeur != None :
+ if type(valeur) == tuple:
+ l_new_val = []
+ typ = None
+ for v in valeur :
+ if not typ:
+ typ = type(v)
+ else:
+ if type(v) != typ :
+ # la liste est heterogene --> on refuse d'interpreter
+ # self comme une liste
+ # on retourne la string initiale
+ print(('liste heterogene ',val))
+ return val
+ l_new_val.append(v)
+ return tuple(l_new_val)
+
+ if valeur != None :
+ if type(valeur).__name__ == 'list':
+ self.dict_valeur=[]
+ for i in range(len(valeur)):
+ self.dict_valeur.append(valeur[i])
+ return valeur
+ # on retourne val comme une string car on n'a pas su l'interpreter
+ return val
+
+ def getValeurs(self):
+ valeurretour=[]
+ if self.dict_valeur != []:
+ for val in self.dict_valeur:
+ valeurretour.append(val)
+ else:
+ valeurretour.append(self.valeur)
+ return valeurretour
+
+ def setValeur(self,new_valeur):
+ """
+ Remplace la valeur de self par new_valeur interpretee
+ """
+ self.valeur = self.interpreteValeur(new_valeur)
+ self.val=repr(self.valeur)
+ self.parent.updateConceptAfterEtape(self,self)
+ self.initModif()
+
+ def setNom(self,new_nom):
+ """
+ Change le nom du parametre
+ """
+ self.initModif()
+ self.nom=new_nom
+ self.finModif()
+
+ def initModif(self):
+ """
+ Methode qui declare l'objet courant comme modifie et propage
+ cet etat modifie a ses ascendants
+ """
+ self.state = 'modified'
+ if self.parent:
+ self.parent.initModif()
+
+ def getJdcRoot(self):
+ if self.parent:
+ return self.parent.getJdcRoot()
+ else:
+ return self
+
+ def register(self):
+ """
+ Enregistre le parametre dans la liste des etapes de son parent (JDC)
+ """
+ self.parent.registerParametre(self)
+ self.parent.register(self)
+
+ def isValid(self,cr='non'):
+ """
+ Retourne 1 si self est valide, 0 sinon
+ Un parametre est considere comme valide si :
+ - il a un nom
+ - il a une valeur
+ """
+ if self.nom == '' :
+ if cr == 'oui':
+ self.cr.fatal(tr("Pas de nom donne au parametre "))
return 0
- return 1
-
- def isOblig(self):
- """
- Indique si self est obligatoire ou non : retourne toujours 0
- """
- return 0
-
- def isRepetable(self):
- """
- Indique si self est repetable ou non : retourne toujours 1
- """
- return 1
-
- def listeMcPresents(self):
- return []
-
- def supprime(self):
- """
- Methode qui supprime toutes les boucles de references afin que
- l'objet puisse etre correctement detruit par le garbage collector
- """
- self.parent = None
- self.jdc = None
- self.definition=None
- self.niveau=None
+ else:
+ if self.valeur == None :
+ if cr == 'oui' :
+ self.cr.fatal(tr("Le parametre %s ne peut valoir None" , self.nom))
+ return 0
+ return 1
+
+ def isOblig(self):
+ """
+ Indique si self est obligatoire ou non : retourne toujours 0
+ """
+ return 0
- def active(self):
- """
- Rend l'etape courante active.
- Il faut ajouter le parametre au contexte global du JDC
- """
- self.actif = 1
- try:
- self.jdc.appendParam(self)
- except:
+ def isRepetable(self):
+ """
+ Indique si self est repetable ou non : retourne toujours 1
+ """
+ return 1
+
+ def listeMcPresents(self):
+ return []
+
+ def supprime(self):
+ """
+ Methode qui supprime toutes les boucles de references afin que
+ l'objet puisse etre correctement detruit par le garbage collector
+ """
+ self.parent = None
+ self.jdc = None
+ self.definition=None
+ self.niveau=None
+
+ def active(self):
+ """
+ Rend l'etape courante active.
+ Il faut ajouter le parametre au contexte global du JDC
+ """
+ self.actif = 1
+ try:
+ self.jdc.appendParam(self)
+ except:
+ pass
+ CONNECTOR.Emit(self,"add",None)
+ CONNECTOR.Emit(self,"valid")
+
+ def inactive(self):
+ """
+ Rend l'etape courante inactive
+ Il faut supprimer le parametre du contexte global du JDC
+ """
+ self.actif = 0
+ self.jdc.delParam(self)
+ self.jdc.deleteConceptAfterEtape(self,self)
+ CONNECTOR.Emit(self,"supp",None)
+ CONNECTOR.Emit(self,"valid")
+
+ def isActif(self):
+ """
+ Booleenne qui retourne 1 si self est actif, 0 sinon
+ """
+ return self.actif
+
+ def setAttribut(self,nom_attr,new_valeur):
+ """
+ Remplace la valeur de self.nom_attr par new_valeur)
+ """
+ if hasattr(self,nom_attr):
+ setattr(self,nom_attr,new_valeur)
+ self.initModif()
+
+ def supprimeSdProds(self):
+ """
+ Il faut supprimer le parametre qui a ete entre dans la liste des
+ parametres du JDC
+ """
+ self.jdc.deleteParam(self)
+ self.parent.deleteConcept(self)
+
+ def updateContext(self,d):
+ """
+ Update le dictionnaire d avec le parametre que produit self
+ """
+ d[self.nom]=self
+
+ def __repr__(self):
+ """
+ Donne un echo de self sous la forme nom = valeur
+ """
+ if type(self.valeur) == bytes or type(self.valeur) == str :
+ if self.valeur.find('\n') == -1:
+ # pas de retour chariot, on utilise repr
+ return self.nom+' = '+ repr(self.valeur)
+ elif self.valeur.find('"""') == -1:
+ # retour chariot mais pas de triple ", on formatte
+ return self.nom+' = """'+self.valeur+'"""'
+ else:
+ return self.nom+' = '+ repr(self.valeur)
+ else:
+ if type(self.valeur) == list :
+ aRetourner=self.nom+' = ['
+ for l in self.valeur :
+ aRetourner=aRetourner+str(l) +","
+ aRetourner=aRetourner[0:-1]+']'
+ return aRetourner
+ return self.nom+' = '+ str(self.valeur)
+
+ def __str__(self):
+ """
+ Retourne le nom du parametre comme representation de self
+ """
+ return self.nom
+
+ def getSdprods(self,nom_sd):
+ """
+ Retourne les concepts produits par la commande
+ """
+ return None
+
+ def report(self):
+ """ Genere l'objet rapport (classe CR) """
+ self.cr=CR()
+ self.isValid(cr='oui')
+ return self.cr
+
+ def ident(self):
+ """
+ Retourne le nom interne associe a self
+ Ce nom n'est jamais vu par l'utilisateur dans EFICAS
+ """
+ return self.nom
+
+ def deleteConcept(self,sd):
pass
- CONNECTOR.Emit(self,"add",None)
- CONNECTOR.Emit(self,"valid")
- def inactive(self):
- """
- Rend l'etape courante inactive
- Il faut supprimer le parametre du contexte global du JDC
- """
- self.actif = 0
- self.jdc.delParam(self)
- self.jdc.deleteConceptAfterEtape(self,self)
- CONNECTOR.Emit(self,"supp",None)
- CONNECTOR.Emit(self,"valid")
-
- def isActif(self):
- """
- Booleenne qui retourne 1 si self est actif, 0 sinon
- """
- return self.actif
-
- def setAttribut(self,nom_attr,new_valeur):
- """
- Remplace la valeur de self.nom_attr par new_valeur)
- """
- if hasattr(self,nom_attr):
- setattr(self,nom_attr,new_valeur)
- self.initModif()
-
- def supprimeSdProds(self):
- """
- Il faut supprimer le parametre qui a ete entre dans la liste des
- parametres du JDC
- """
- self.jdc.deleteParam(self)
- self.parent.deleteConcept(self)
-
- def updateContext(self,d):
- """
- Update le dictionnaire d avec le parametre que produit self
- """
- d[self.nom]=self
-
- def __repr__(self):
- """
- Donne un echo de self sous la forme nom = valeur
- """
- if type(self.valeur) == bytes or type(self.valeur) == str :
- if self.valeur.find('\n') == -1:
- # pas de retour chariot, on utilise repr
- return self.nom+' = '+ repr(self.valeur)
- elif self.valeur.find('"""') == -1:
- # retour chariot mais pas de triple ", on formatte
- return self.nom+' = """'+self.valeur+'"""'
- else:
- return self.nom+' = '+ repr(self.valeur)
- else:
- if type(self.valeur) == list :
- aRetourner=self.nom+' = ['
- for l in self.valeur :
- aRetourner=aRetourner+str(l) +","
- aRetourner=aRetourner[0:-1]+']'
- return aRetourner
- return self.nom+' = '+ str(self.valeur)
-
- def __str__(self):
- """
- Retourne le nom du parametre comme representation de self
- """
- return self.nom
-
- def getSdprods(self,nom_sd):
- """
- Retourne les concepts produits par la commande
- """
- return None
-
- def report(self):
- """ Genere l'objet rapport (classe CR) """
- self.cr=CR()
- self.isValid(cr='oui')
- return self.cr
-
- def ident(self):
- """
- Retourne le nom interne associe a self
- Ce nom n'est jamais vu par l'utilisateur dans EFICAS
- """
- return self.nom
-
- def deleteConcept(self,sd):
- pass
-
- def replaceConcept(self,old_sd,sd):
- pass
-
- def verifConditionBloc(self):
- """
- Evalue les conditions de tous les blocs fils possibles
- (en fonction du catalogue donc de la definition) de self et
- retourne deux listes :
- - la premiere contient les noms des blocs a rajouter
- - la seconde contient les noms des blocs a supprimer
- """
- return [],[]
-
- def 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
- """
- return []
+ def replaceConcept(self,old_sd,sd):
+ pass
- def verifExistenceSd(self):
- pass
+ def verifConditionBloc(self):
+ """
+ Evalue les conditions de tous les blocs fils possibles
+ (en fonction du catalogue donc de la definition) de self et
+ retourne deux listes :
+ - la premiere contient les noms des blocs a rajouter
+ - la seconde contient les noms des blocs a supprimer
+ """
+ return [],[]
+
+ def 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
+ """
+ return []
+
+ def verifExistenceSd(self):
+ pass
- def controlSdprods(self,d):
- """sans objet """
- pass
+ def controlSdprods(self,d):
+ """sans objet """
+ pass
- def close(self):
- pass
+ def close(self):
+ pass
- def resetContext(self):
- pass
+ def resetContext(self):
+ pass
- def eval(self):
- if isinstance(self.valeur,Formula):
- return self.valeur.eval()
- else:
- return self.valeur
+ def eval(self):
+ if isinstance(self.valeur,Formula):
+ return self.valeur.eval()
+ else:
+ return self.valeur
- def __adapt__(self,validator):
- return validator.adapt(self.eval())
+ def __adapt__(self,validator):
+ return validator.adapt(self.eval())
class COMBI_PARAMETRE(object) :
- def __init__(self,chainevaleur,valeur):
- self.chainevaleur=chainevaleur
- self.valeur=valeur
+ def __init__(self,chainevaleur,valeur):
+ self.chainevaleur=chainevaleur
+ self.valeur=valeur
- def __repr__(self):
- return self.chainevaleur
+ def __repr__(self):
+ return self.chainevaleur
- def isValid(self):
- if self.valeur and self.chainevaleur:
- return 1
+ def isValid(self):
+ if self.valeur and self.chainevaleur:
+ return 1
class ITEM_PARAMETRE(object) :
- def __init__(self,param_pere,item=None):
- self.param_pere = param_pere
- self.item = item
-
-
- def __repr__(self):
- return self.param_pere.nom+'['+str(self.item)+']'
-
-
- def isValid(self):
- isValid = 1
- if self.item < 0:
- isValid = 0
- try:
- longueur= len(self.param_pere.dict_valeur) - 1
- except:
- longueur=0
- if self.item > longueur :
- isValid= 0
- return isValid
+ def __init__(self,param_pere,item=None):
+ self.param_pere = param_pere
+ self.item = item
+
+
+ def __repr__(self):
+ return self.param_pere.nom+'['+str(self.item)+']'
+
+
+ def isValid(self):
+ isValid = 1
+ if self.item < 0:
+ isValid = 0
+ try:
+ longueur= len(self.param_pere.dict_valeur) - 1
+ except:
+ longueur=0
+ if self.item > longueur :
+ isValid= 0
+ return isValid
pattern_eval = re.compile(r'^(EVAL)([ \t\r\f\v]*)\(([\w\W]*)')
class PARAMETRE_EVAL(parametre.PARAMETRE) :
- """
- Cette classe permet de creer des objets de type PARAMETRE_EVAL
- cad des affectations directes evaluees dans le jeu de commandes (ex: a=EVAL('''10.*SQRT(25)'''))
- qui sont interpretees par le parseur de fichiers Python.
- Les objets ainsi crees constituent des parametres evalues pour le jdc
- """
- nature = 'PARAMETRE_EVAL'
- idracine='param_eval'
-
- def __init__(self,nom,valeur=None):
- # parent ne peut etre qu'un objet de type JDC
- import Accas
- self.Accas_EVAL=Accas.EVAL
- self.valeur = self.interpreteValeur(valeur)
- self.val = valeur
- self.nom = nom
- self.jdc = self.parent = CONTEXT.getCurrentStep()
- self.definition=self
- self.niveau = self.parent.niveau
- self.actif=1
- self.state='undetermined'
- # Ceci est-il indispensable ???
- #self.appel = N_utils.calleeWhere(niveau=2)
- self.register()
-
- def __repr__(self):
"""
- Donne un echo de self sous la forme nom = valeur
- """
- return self.nom+' = '+ repr(self.valeur)
-
- def __str__(self):
- """
- Retourne le nom du parametre evalue comme representation de self
- """
- return self.nom
-
- def interpreteValeur(self,val):
- """
- Essaie d'interpreter val (chaine de caracteres ou None) comme :
- une instance de Accas.EVAL
- Retourne la valeur interpretee
- """
- if not val : return None
- d={}
- val = val.strip()
- if val[-1] == ';' : val = val[0:-1]
- d['EVAL'] = self.Accas_EVAL
- try:
- valeur = eval(val,{},d)
- return valeur
- except:
- traceback.print_exc()
- print(("Le texte %s n'est pas celui d'un parametre evalue" %val))
- return None
-
- def setValeur(self,new_valeur):
- """
- Remplace la valeur de self par new_valeur interpretee.
- """
- self.valeur = self.interpreteValeur(new_valeur)
- self.val = new_valeur
- self.initModif()
-
- def getNom(self) :
- """
- Retourne le nom du parametre
- """
- return self.nom
-
- def getValeur(self):
- """
- Retourne la valeur de self, cad le texte de l'objet class_eval.EVAL
- """
- if self.valeur :
- return self.valeur.valeur
- else:
- return ''
-
- def verifEval(self,exp_eval=None,cr='non'):
- """
- Cette methode a pour but de verifier si l'expression EVAL
- est syntaxiquement correcte.
- Retourne :
- - un booleen, qui vaut 1 si licite, 0 sinon
- - un message d'erreurs ('' si illicite)
- """
- if not exp_eval:
+ Cette classe permet de creer des objets de type PARAMETRE_EVAL
+ cad des affectations directes evaluees dans le jeu de commandes (ex: a=EVAL('''10.*SQRT(25)'''))
+ qui sont interpretees par le parseur de fichiers Python.
+ Les objets ainsi crees constituent des parametres evalues pour le jdc
+ """
+ nature = 'PARAMETRE_EVAL'
+ idracine='param_eval'
+
+ def __init__(self,nom,valeur=None):
+ # parent ne peut etre qu'un objet de type JDC
+ import Accas
+ self.Accas_EVAL=Accas.EVAL
+ self.valeur = self.interpreteValeur(valeur)
+ self.val = valeur
+ self.nom = nom
+ self.jdc = self.parent = CONTEXT.getCurrentStep()
+ self.definition=self
+ self.niveau = self.parent.niveau
+ self.actif=1
+ self.state='undetermined'
+ # Ceci est-il indispensable ???
+ #self.appel = N_utils.calleeWhere(niveau=2)
+ self.register()
+
+ def __repr__(self):
+ """
+ Donne un echo de self sous la forme nom = valeur
+ """
+ return self.nom+' = '+ repr(self.valeur)
+
+ def __str__(self):
+ """
+ Retourne le nom du parametre evalue comme representation de self
+ """
+ return self.nom
+
+ def interpreteValeur(self,val):
+ """
+ Essaie d'interpreter val (chaine de caracteres ou None) comme :
+ une instance de Accas.EVAL
+ Retourne la valeur interpretee
+ """
+ if not val : return None
+ d={}
+ val = val.strip()
+ if val[-1] == ';' : val = val[0:-1]
+ d['EVAL'] = self.Accas_EVAL
+ try:
+ valeur = eval(val,{},d)
+ return valeur
+ except:
+ traceback.print_exc()
+ print(("Le texte %s n'est pas celui d'un parametre evalue" %val))
+ return None
+
+ def setValeur(self,new_valeur):
+ """
+ Remplace la valeur de self par new_valeur interpretee.
+ """
+ self.valeur = self.interpreteValeur(new_valeur)
+ self.val = new_valeur
+ self.initModif()
+
+ def getNom(self) :
+ """
+ Retourne le nom du parametre
+ """
+ return self.nom
+
+ def getValeur(self):
+ """
+ Retourne la valeur de self, cad le texte de l'objet class_eval.EVAL
+ """
if self.valeur :
- exp_eval = self.valeur.valeur[3:-3] # on enleve les triples guillemets
+ return self.valeur.valeur
else:
- exp_eval = None
- if exp_eval :
- # on construit un interpreteur de formule
- formule=(self.nom,'',None,exp_eval)
- # 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)
- # on cree un objet verificateur
- verificateur = interpreteur_formule.Interpreteur_Formule(formule=formule,
- constantes = l_ctes,
- fonctions = l_form)
- if cr == 'oui' :
- if not verificateur.cr.estvide():
- self.cr.fatal(verificateur.cr.getMessFatal())
- return verificateur.isValid(),''.join(verificateur.cr.crfatal)
- else:
- # pas d'expression EVAL --> self non valide
- if cr == 'oui' :
- self.cr.fatal(tr("Le parametre EVAL %s ne peut valoir None") , self.nom)
- return 0,tr("Le parametre EVAL ne peut valoir None")
-
- def verifNom(self,nom=None,cr='non'):
- """
- Verifie si le nom passe en argument (si aucun prend le nom courant)
- est un nom valide pour un parametre EVAL
- Retourne :
- - un booleen, qui vaut 1 si nom licite, 0 sinon
- - un message d'erreurs ('' si illicite)
- """
- if not nom :
- nom = self.nom
- if nom == "" :
- if cr == 'oui' : self.cr.fatal(tr("Pas de nom donne au parametre EVAL"))
- return 0,"Pas de nom donne au parametre EVAL"
- if len(nom) > 8 :
- if cr == 'oui' : self.cr.fatal(tr("Un nom de parametre ne peut depasser 8 caracteres"))
- return 0,"Un nom de parametre ne peut depasser 8 caracteres"
- sd = self.parent.getSdAutourEtape(nom,self)
- if sd :
- if cr == 'oui' : self.cr.fatal(tr("Un concept de nom %s existe deja !"), nom)
- return 0,"Un concept de nom %s existe deja !" %nom
- return 1,''
-
- def verifParametreEval(self,param=None,cr='non'):
- """
- Verifie la validite du parametre EVAL passe en argument.
- Ce nouveau parametre est passe sous la forme d'un tuple : (nom,valeur)
- Si aucun tuple passe, prend les valeurs courantes de l'objet
- Retourne :
- - un booleen, qui vaut 1 si EVAL licite, 0 sinon
+ return ''
+
+ def verifEval(self,exp_eval=None,cr='non'):
+ """
+ Cette methode a pour but de verifier si l'expression EVAL
+ est syntaxiquement correcte.
+ Retourne :
+ - un booleen, qui vaut 1 si licite, 0 sinon
- un message d'erreurs ('' si illicite)
- """
- if not param :
- if self.valeur :
- param = (self.nom,self.valeur.valeur)
+ """
+ if not exp_eval:
+ if self.valeur :
+ exp_eval = self.valeur.valeur[3:-3] # on enleve les triples guillemets
+ else:
+ exp_eval = None
+ if exp_eval :
+ # on construit un interpreteur de formule
+ formule=(self.nom,'',None,exp_eval)
+ # 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)
+ # on cree un objet verificateur
+ verificateur = interpreteur_formule.Interpreteur_Formule(formule=formule,
+ constantes = l_ctes,
+ fonctions = l_form)
+ if cr == 'oui' :
+ if not verificateur.cr.estvide():
+ self.cr.fatal(verificateur.cr.getMessFatal())
+ return verificateur.isValid(),''.join(verificateur.cr.crfatal)
else:
- param = (self.nom,None)
- test_nom,erreur_nom = self.verifNom(param[0],cr=cr)
- test_eval,erreur_eval = self.verifEval(param[1],cr=cr)
- # test global = produit des tests partiels
- test = test_nom*test_eval
- # message d'erreurs global = concatenation des messages partiels
- erreur = ''
- if not test :
- for mess in (erreur_nom,erreur_eval):
- erreur = erreur+(len(mess) > 0)*'\n'+mess
- return test,erreur
-
- def update(self,param):
- """
- Methode externe.
- Met a jour les champs nom, valeur de self
- par les nouvelles valeurs passees dans le tuple formule.
- On stocke les valeurs SANS verifications.
- """
- self.initModif()
- self.setNom(param[0])
- self.setValeur('EVAL("""'+param[1]+'""")')
-
- def isValid(self,cr='non'):
- """
- Retourne 1 si self est valide, 0 sinon
- Un parametre evalue est considere comme valide si :
- - il a un nom
- - il a une valeur qui est interpretable par l'interpreteur de FORMULEs
- """
- resu,erreur= self.verifParametreEval(cr=cr)
- return resu
-
- def report(self):
- """
- Genere l'objet rapport (classe CR)
- """
- self.cr = CR()
- self.isValid(cr='oui')
- return self.cr
-
- def setNom(self,new_nom):
- """
- Remplace le nom de self par new_nom
- """
- self.nom = new_nom
-
-
+ # pas d'expression EVAL --> self non valide
+ if cr == 'oui' :
+ self.cr.fatal(tr("Le parametre EVAL %s ne peut valoir None") , self.nom)
+ return 0,tr("Le parametre EVAL ne peut valoir None")
+
+ def verifNom(self,nom=None,cr='non'):
+ """
+ Verifie si le nom passe en argument (si aucun prend le nom courant)
+ est un nom valide pour un parametre EVAL
+ Retourne :
+ - un booleen, qui vaut 1 si nom licite, 0 sinon
+ - un message d'erreurs ('' si illicite)
+ """
+ if not nom :
+ nom = self.nom
+ if nom == "" :
+ if cr == 'oui' : self.cr.fatal(tr("Pas de nom donne au parametre EVAL"))
+ return 0,"Pas de nom donne au parametre EVAL"
+ if len(nom) > 8 :
+ if cr == 'oui' : self.cr.fatal(tr("Un nom de parametre ne peut depasser 8 caracteres"))
+ return 0,"Un nom de parametre ne peut depasser 8 caracteres"
+ sd = self.parent.getSdAutourEtape(nom,self)
+ if sd :
+ if cr == 'oui' : self.cr.fatal(tr("Un concept de nom %s existe deja !"), nom)
+ return 0,"Un concept de nom %s existe deja !" %nom
+ return 1,''
+
+ def verifParametreEval(self,param=None,cr='non'):
+ """
+ Verifie la validite du parametre EVAL passe en argument.
+ Ce nouveau parametre est passe sous la forme d'un tuple : (nom,valeur)
+ Si aucun tuple passe, prend les valeurs courantes de l'objet
+ Retourne :
+ - un booleen, qui vaut 1 si EVAL licite, 0 sinon
+ - un message d'erreurs ('' si illicite)
+ """
+ if not param :
+ if self.valeur :
+ param = (self.nom,self.valeur.valeur)
+ else:
+ param = (self.nom,None)
+ test_nom,erreur_nom = self.verifNom(param[0],cr=cr)
+ test_eval,erreur_eval = self.verifEval(param[1],cr=cr)
+ # test global = produit des tests partiels
+ test = test_nom*test_eval
+ # message d'erreurs global = concatenation des messages partiels
+ erreur = ''
+ if not test :
+ for mess in (erreur_nom,erreur_eval):
+ erreur = erreur+(len(mess) > 0)*'\n'+mess
+ return test,erreur
+
+ def update(self,param):
+ """
+ Methode externe.
+ Met a jour les champs nom, valeur de self
+ par les nouvelles valeurs passees dans le tuple formule.
+ On stocke les valeurs SANS verifications.
+ """
+ self.initModif()
+ self.setNom(param[0])
+ self.setValeur('EVAL("""'+param[1]+'""")')
+
+ def isValid(self,cr='non'):
+ """
+ Retourne 1 si self est valide, 0 sinon
+ Un parametre evalue est considere comme valide si :
+ - il a un nom
+ - il a une valeur qui est interpretable par l'interpreteur de FORMULEs
+ """
+ resu,erreur= self.verifParametreEval(cr=cr)
+ return resu
+
+ def report(self):
+ """
+ Genere l'objet rapport (classe CR)
+ """
+ self.cr = CR()
+ self.isValid(cr='oui')
+ return self.cr
+
+ def setNom(self,new_nom):
+ """
+ Remplace le nom de self par new_nom
+ """
+ self.nom = new_nom
from __future__ import absolute_import
import glob,os,sys,traceback
try:
- from UserDict import UserDict
+ from UserDict import UserDict
except ImportError:
- from collections import UserDict
+ from collections import UserDict
class PluginLoader(UserDict):
- def __init__(self,module):
- UserDict.__init__(self)
- self.plugin_dir=module.__path__[0]
- self.plugin_setName=module.__name__
- _module_list = glob.glob( os.path.join( self.plugin_dir,
- '%s*py' % self.plugin_setName,
- )
- )
- _module_list.sort()
+ def __init__(self,module):
+ UserDict.__init__(self)
+ self.plugin_dir=module.__path__[0]
+ self.plugin_setName=module.__name__
+ _module_list = glob.glob( os.path.join( self.plugin_dir,
+ '%s*py' % self.plugin_setName,
+ )
+ )
+ _module_list.sort()
- for _module_name in _module_list:
+ for _module_name in _module_list:
- _module_name = os.path.basename(_module_name)[:-3]
- _import_name = '%s.%s' % ( self.plugin_setName,
- _module_name )
+ _module_name = os.path.basename(_module_name)[:-3]
+ _import_name = '%s.%s' % ( self.plugin_setName,
+ _module_name )
- try:
- _module = __import__( _import_name )
- except:
- sys.stderr.write('\n--- Plugin Module Error ---\n')
- traceback.print_exc()
- sys.stderr.write('---------------------------\n\n')
- continue
- try:
- _module = getattr(_module, _module_name)
- except AttributeError:
- sys.stderr.write('ERROR: Could not retrieve %s\n' % _import_name)
+ try:
+ _module = __import__( _import_name )
+ except:
+ sys.stderr.write('\n--- Plugin Module Error ---\n')
+ traceback.print_exc()
+ sys.stderr.write('---------------------------\n\n')
+ continue
+ try:
+ _module = getattr(_module, _module_name)
+ except AttributeError:
+ sys.stderr.write('ERROR: Could not retrieve %s\n' % _import_name)
- try:
- info = _module.entryPoint()
- except AttributeError:
- pass
- else:
- self.addEntryPoint(info)
+ try:
+ info = _module.entryPoint()
+ except AttributeError:
+ pass
+ else:
+ self.addEntryPoint(info)
- def addEntryPoint(self,infoDict):
- name=infoDict['name']
- factory=infoDict['factory']
- self[name]=factory
-
+ def addEntryPoint(self,infoDict):
+ name=infoDict['name']
+ factory=infoDict['factory']
+ self[name]=factory
"""
from __future__ import absolute_import
-try :
- from builtins import zip
- from builtins import map
- from builtins import range
-except :
- pass
+try :
+ from builtins import zip
+ from builtins import map
+ from builtins import range
+except :
+ pass
from .eficas_exception import EficasException
import re
Module-internal method.
Returns a formatted string from an unformatted string
- and an integer or a float specifying the parameter of
+ and an integer or a float specifying the parameter of
the string.
"""
from PyQt5.QtCore import QRegExp
Module-internal method.
Returns a formatted string from an unformatted string
- and a list whose concatenation specifies the parameter
+ and a list whose concatenation specifies the parameter
of the string.
"""
# XXX to add further functionality, e.g. list processing
def _preprocess_atom(string):
"""
_preprocess_atom(string-or-number-or-unicode) -> unicode
- Test if input is a Unicode object or a number; if so, then return it;
- otherwise, test if the input is a string; if so, then try to create
- a Unicode object out of it. To this end, assume the string is encoded
+ Test if input is a Unicode object or a number; if so, then return it;
+ otherwise, test if the input is a string; if so, then try to create
+ a Unicode object out of it. To this end, assume the string is encoded
in utf-8; if this fails, then assume the string is encoded in Latin-9.
"""
if isinstance(string, (six.text_type, int, float, complex)):
def _str_toUnicode(string):
"""
_str_toUnicode(string) -> unicode
- Tries to create a Unicode object out of the input string; assumes
- the string is UTF-8 encoded; if not, then assume the string is
+ Tries to create a Unicode object out of the input string; assumes
+ the string is UTF-8 encoded; if not, then assume the string is
Latin-9 encoded.
"""
try:
def tr(string, *args):
"""tr(string-or-unicode, iterable-or-float-or-int) -> unicode
tr(string-or-unicode) -> unicode
-
- Returns a formatted Unicode object from an unformatted
- string or Unicode object with formatting specifications, and,
+
+ Returns a formatted Unicode object from an unformatted
+ string or Unicode object with formatting specifications, and,
optionally, an iterable or an int or float.
Lets Python do the string formatting."""
try :
- from PyQt5.QtWidgets import QApplication
+ from PyQt5.QtWidgets import QApplication
except :
- return string
+ return string
string = _preprocess_atom(string)
if len(args) == 0:
def tr_qt(string, *args):
"""tr_qt(string, iterable-or-float-or-int) -> unicode
t_qtr(string) -> unicode
-
- Returns a formatted string from an unformatted
- Unicode string with formatting specifications, and,
+
+ Returns a formatted string from an unformatted
+ Unicode string with formatting specifications, and,
optionally, an iterable or an int or float.
Lets PyQt4 do the string formatting. To this end,
a conversion from Python to Qt string formatting
r = _reformat_qstring_from_dict(r, args[0])
elif isinstance(args[0], tuple):
r = _reformat_qstring_from_tuple(r, args[0])
- # XXX Pay attention to this: distinguish between tuple,
+ # XXX Pay attention to this: distinguish between tuple,
# dict and dict with key given in string.
elif r.count("%") in range(2) and r.count("%(") == 0:
r = _reformat_qstring_from_atom(r, _preproces_atom(repr(args[0])))
