From: pascale.noyret Date: Thu, 25 Mar 2021 18:13:02 +0000 (+0100) Subject: reindent Extensions X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=a78d434e49fd175314ee72ab0eafc1693284de0c;p=tools%2Feficas.git reindent Extensions --- diff --git a/Extensions/commande_comm.py b/Extensions/commande_comm.py index 31439d93..b99239bd 100644 --- a/Extensions/commande_comm.py +++ b/Extensions/commande_comm.py @@ -20,7 +20,7 @@ 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 @@ -37,7 +37,7 @@ class COMMANDE_COMM(N_OBJECT.OBJECT,I_OBJECT.OBJECT) : """ nature = "COMMANDE_COMMENTARISEE" idracine='_comm' - + def __init__(self,texte='',parent=None,reg='oui'): self.valeur = texte if not parent : @@ -45,9 +45,9 @@ class COMMANDE_COMM(N_OBJECT.OBJECT,I_OBJECT.OBJECT) : 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 @@ -55,7 +55,7 @@ class COMMANDE_COMM(N_OBJECT.OBJECT,I_OBJECT.OBJECT) : self.state="unchanged" #self.appel = N_utils.calleeWhere(niveau=2) if reg=='oui' : self.register() - + def isValid(self): return 1 @@ -76,7 +76,7 @@ class COMMANDE_COMM(N_OBJECT.OBJECT,I_OBJECT.OBJECT) : def initModif(self): self.state = 'modified' - self.parent.initModif() + self.parent.initModif() def setValeur(self,new_valeur): """ @@ -115,16 +115,16 @@ class COMMANDE_COMM(N_OBJECT.OBJECT,I_OBJECT.OBJECT) : """ 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): """ @@ -132,17 +132,17 @@ class COMMANDE_COMM(N_OBJECT.OBJECT,I_OBJECT.OBJECT) : """ 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 @@ -185,7 +185,7 @@ class COMMANDE_COMM(N_OBJECT.OBJECT,I_OBJECT.OBJECT) : # 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, @@ -238,47 +238,46 @@ class COMMANDE_COMM(N_OBJECT.OBJECT,I_OBJECT.OBJECT) : 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 diff --git a/Extensions/commentaire.py b/Extensions/commentaire.py index 5decbe1f..d9987bc6 100644 --- a/Extensions/commentaire.py +++ b/Extensions/commentaire.py @@ -29,177 +29,175 @@ from Ihm import I_OBJECT 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 diff --git a/Extensions/eficas_exception.py b/Extensions/eficas_exception.py index 6faae636..78b4509c 100644 --- a/Extensions/eficas_exception.py +++ b/Extensions/eficas_exception.py @@ -16,7 +16,7 @@ # with this program. If not, see . """ 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. """ @@ -40,7 +40,7 @@ class EficasException(Exception): #sys.path.append(os.path.realpath("..")) from Extensions.i18n import tr self.args = (tr(msg),) - + if __name__ == "__main__": import sys diff --git a/Extensions/etape_niveau.py b/Extensions/etape_niveau.py index b7a6f003..eb9638c8 100644 --- a/Extensions/etape_niveau.py +++ b/Extensions/etape_niveau.py @@ -18,7 +18,7 @@ # 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 @@ -28,114 +28,113 @@ from Noyau import N_OBJECT 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 '' diff --git a/Extensions/interpreteur_formule.py b/Extensions/interpreteur_formule.py index 9afdbaff..22812f31 100644 --- a/Extensions/interpreteur_formule.py +++ b/Extensions/interpreteur_formule.py @@ -19,9 +19,9 @@ # 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 @@ -59,7 +59,7 @@ def cmp_function(arg1,arg2): return 0 else: return 1 - + class InterpreteurException(Exception): """ Classe servant a definir les exceptions levees par l'interpreteur de formule @@ -79,7 +79,7 @@ class Interpreteur_Formule(object): '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 @@ -120,7 +120,7 @@ class Interpreteur_Formule(object): 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 @@ -141,21 +141,21 @@ class Interpreteur_Formule(object): """ 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() @@ -205,7 +205,7 @@ class Interpreteur_Formule(object): 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 @@ -213,7 +213,7 @@ class Interpreteur_Formule(object): self.l_fonctions_binaires.sort(cmp_function) self.l_fonctions_unaires.sort(cmp_function) self.l_constantes.sort(cmp_function) - + def splitOperateurs(self,texte): """ @@ -317,7 +317,7 @@ class Interpreteur_Formule(object): 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. @@ -367,7 +367,7 @@ class Interpreteur_Formule(object): else: # aucune constante trouvee return None,texte - + def chercheArgs(self,texte): """ Cherche au debut de texte une liste d'arguments entre parentheses @@ -391,7 +391,7 @@ class Interpreteur_Formule(object): else: # on a fini d'analyser le texte : reste = None return texte,None - + def chercheOperateurUnaireOld(self,texte): """ Cherche dans texte un operateur unaire @@ -468,26 +468,26 @@ class Interpreteur_Formule(object): 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 @@ -525,7 +525,7 @@ class Interpreteur_Formule(object): operateur.interpreteFormule() texte = reste return operateur,reste - + def splitArgs(self,nom_fonction,args,nb_args): """ Tente de partager args en nb_args elements diff --git a/Extensions/jdc.py b/Extensions/jdc.py index e984c864..bb5495b0 100644 --- a/Extensions/jdc.py +++ b/Extensions/jdc.py @@ -22,21 +22,20 @@ 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) diff --git a/Extensions/jdc_include.py b/Extensions/jdc_include.py index 98467da9..c95fc774 100644 --- a/Extensions/jdc_include.py +++ b/Extensions/jdc_include.py @@ -32,325 +32,325 @@ from Accas import JDC,ASSD,AsException,JDC_CATA 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 @@ -364,5 +364,3 @@ JdC_poursuite=JDC_CATA_POURSUITE(code='ASTER', execmodul=None, A_CLASSER(('DEBUT','POURSUITE'),'FIN') ) ) - - diff --git a/Extensions/localisation.py b/Extensions/localisation.py index 1ef1aa47..0ce1f7f8 100644 --- a/Extensions/localisation.py +++ b/Extensions/localisation.py @@ -23,22 +23,22 @@ from __future__ import print_function 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 @@ -47,29 +47,29 @@ def localise(application, locale=None,file=None,translatorFichier=None, debug=Fa 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 diff --git a/Extensions/mcnuplet.py b/Extensions/mcnuplet.py index 1078fb27..7928afdf 100644 --- a/Extensions/mcnuplet.py +++ b/Extensions/mcnuplet.py @@ -21,8 +21,8 @@ """ # Modules Python from __future__ import absolute_import -try : - from builtins import str +try : + from builtins import str except : pass @@ -32,189 +32,185 @@ from Validation import V_MCCOMPO 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) + """ diff --git a/Extensions/niveau.py b/Extensions/niveau.py index 9ca012e9..97132f5d 100644 --- a/Extensions/niveau.py +++ b/Extensions/niveau.py @@ -22,32 +22,31 @@ 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 diff --git a/Extensions/nuplet.py b/Extensions/nuplet.py index 465c6f01..b7f80904 100644 --- a/Extensions/nuplet.py +++ b/Extensions/nuplet.py @@ -22,8 +22,8 @@ """ # Modules Python from __future__ import absolute_import -try : - from builtins import str +try : + from builtins import str except : pass import types @@ -35,94 +35,93 @@ from Extensions.i18n import tr 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 diff --git a/Extensions/param2.py b/Extensions/param2.py index cc198709..f4be0445 100644 --- a/Extensions/param2.py +++ b/Extensions/param2.py @@ -20,8 +20,8 @@ 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 @@ -29,13 +29,13 @@ 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): @@ -55,9 +55,9 @@ class Formula(object): 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()) @@ -79,7 +79,7 @@ class Formula(object): 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) @@ -92,13 +92,13 @@ class Formula(object): 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): @@ -116,19 +116,19 @@ 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()) @@ -156,23 +156,23 @@ class Unop2(Unop): 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): @@ -203,7 +203,7 @@ def Eval(f): 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 """ @@ -229,8 +229,8 @@ class OriginalMath(object): def __init__(self): if hasattr(self,'pi') :return import math - try : - self.toSurcharge() + try : + self.toSurcharge() except : pass def toSurcharge(self): @@ -286,15 +286,15 @@ class OriginalMath(object): 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 diff --git a/Extensions/parametre.py b/Extensions/parametre.py index 9f5bb93d..6d979071 100644 --- a/Extensions/parametre.py +++ b/Extensions/parametre.py @@ -29,8 +29,8 @@ 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 @@ -40,6 +40,7 @@ import traceback # 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 * @@ -48,374 +49,377 @@ from Extensions.i18n import tr 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 diff --git a/Extensions/parametre_eval.py b/Extensions/parametre_eval.py index 4bb03cd6..d5dfde3e 100644 --- a/Extensions/parametre_eval.py +++ b/Extensions/parametre_eval.py @@ -39,198 +39,196 @@ from . import parametre 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 diff --git a/Extensions/pluginloader.py b/Extensions/pluginloader.py index 49b47bd9..749e74ef 100644 --- a/Extensions/pluginloader.py +++ b/Extensions/pluginloader.py @@ -24,50 +24,49 @@ 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 diff --git a/Extensions/translationQT5.py b/Extensions/translationQT5.py index cc763f92..1745cd1a 100644 --- a/Extensions/translationQT5.py +++ b/Extensions/translationQT5.py @@ -22,12 +22,12 @@ tuples, or atoms. """ 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 @@ -137,7 +137,7 @@ def _reformat_qstring_from_atom(qstring, params): 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 @@ -186,7 +186,7 @@ def _reformat_qstring_from_list(qstring, params): 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 @@ -208,9 +208,9 @@ def _reformat_qstring_from_list(qstring, params): 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)): @@ -224,8 +224,8 @@ def _preprocess_atom(string): 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: @@ -241,15 +241,15 @@ def _str_toUnicode(string): 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: @@ -293,9 +293,9 @@ def tr(string, *args): 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 @@ -312,7 +312,7 @@ def tr_qt(string, *args): 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])))