# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2013 EDF R&D
+# Copyright (C) 2007-2017 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
"""
- Ce module contient la classe PARAMETRE qui sert à définir
- des objets paramètres qui sont compréhensibles et donc affichables
+ Ce module contient la classe PARAMETRE qui sert a definir
+ des objets parametres qui sont comprehensibles et donc affichables
par EFICAS.
- Ces objets sont créés à partir de la modification du fichier de commandes
+ Ces objets sont crees a partir de la modification du fichier de commandes
de l'utilisateur par le parseur de fichiers Python
"""
# import de modules Python
-import string,types
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import str
+ from builtins import range
+ from builtins import object
+except : pass
+
+import types
from math import *
import traceback
from Noyau.N_CR import CR
from Noyau import N_OBJECT
from Ihm import I_OBJECT
-from param2 import *
+from .param2 import *
from Ihm import CONNECTOR
from Extensions.i18n import tr
+from six.moves import range
class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) :
"""
- Cette classe permet de créer des objets de type PARAMETRE
+ Cette classe permet de creer des objets de type PARAMETRE
cad des affectations directes dans le jeu de commandes (ex: a=10.)
- qui sont interprétées par le parseur de fichiers Python.
- Les objets ainsi créés constituent des paramètres pour le jdc
+ qui sont interpretees par le parseur de fichiers Python.
+ Les objets ainsi crees constituent des parametres pour le jdc
"""
nature = 'PARAMETRE'
def __init__(self,nom,valeur=None):
self.nom = nom
- # La classe PARAMETRE n'a pas de définition : on utilise self pour
- # complétude
+ # La classe PARAMETRE n'a pas de definition : on utilise self pour
+ # completude
self.definition=self
- # parent ne peut être qu'un objet de type JDC
- self.jdc = self.parent = CONTEXT.get_current_step()
+ # 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.interprete_valeur(valeur)
+ #self.valeur = self.interpreteValeur(valeur)
#self.val=valeur
self.valeur = valeur
self.val=repr(valeur)
- def interprete_valeur(self,val):
+ def interpreteValeur(self,val):
"""
- Essaie d'interpréter val (chaîne de caractères)comme :
+ Essaie d'interpreter val (chaine de caracteres)comme :
- un entier
- - un réel
- - une chaîne de caractères
- - une liste d'items d'un type qui précède
- Retourne la valeur interprétée
+ - 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) == types.ListType:
+ 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 = []
return None
return l_new_val
- if type(val) == types.StringType:
+ if type(val) == bytes:
# on tente l'evaluation dans un contexte fourni par le parent s'il existe
if self.parent:
- valeur=self.parent.eval_in_context(val,self)
+ valeur=self.parent.evalInContext(val,self)
else:
try :
valeur = eval(val)
#PN je n ose pas modifier je rajoute
# refus des listes heterogenes : ne dvrait pas etre la
if valeur != None :
- if type(valeur) == types.TupleType:
+ if type(valeur) == tuple:
l_new_val = []
typ = None
for v in valeur :
typ = type(v)
else:
if type(v) != typ :
- # la liste est hétérogène --> on refuse d'interpréter
+ # la liste est heterogene --> on refuse d'interpreter
# self comme une liste
# on retourne la string initiale
- print 'liste hétérogène ',val
+ print(('liste heterogene ',val))
return val
l_new_val.append(v)
return tuple(l_new_val)
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'interpréter
+ # on retourne val comme une string car on n'a pas su l'interpreter
return val
- def get_valeurs(self):
+ def getValeurs(self):
valeurretour=[]
if self.dict_valeur != []:
for val in self.dict_valeur:
valeurretour.append(self.valeur)
return valeurretour
- def set_valeur(self,new_valeur):
+ def setValeur(self,new_valeur):
"""
- Remplace la valeur de self par new_valeur interprétée
+ Remplace la valeur de self par new_valeur interpretee
"""
- self.valeur = self.interprete_valeur(new_valeur)
+ self.valeur = self.interpreteValeur(new_valeur)
self.val=repr(self.valeur)
- self.parent.update_concept_after_etape(self,self)
- self.init_modif()
+ self.parent.updateConceptAfterEtape(self,self)
+ self.initModif()
- def set_nom(self,new_nom):
+ def setNom(self,new_nom):
"""
Change le nom du parametre
"""
- self.init_modif()
+ self.initModif()
self.nom=new_nom
- self.fin_modif()
+ self.finModif()
- def init_modif(self):
+ def initModif(self):
"""
- Méthode qui déclare l'objet courant comme modifié et propage
- cet état modifié à ses ascendants
+ Methode qui declare l'objet courant comme modifie et propage
+ cet etat modifie a ses ascendants
"""
self.state = 'modified'
if self.parent:
- self.parent.init_modif()
+ self.parent.initModif()
- def get_jdc_root(self):
+ def getJdcRoot(self):
if self.parent:
- return self.parent.get_jdc_root()
+ return self.parent.getJdcRoot()
else:
return self
def register(self):
"""
- Enregistre le paramètre dans la liste des étapes de son parent (JDC)
+ Enregistre le parametre dans la liste des etapes de son parent (JDC)
"""
- self.parent.register_parametre(self)
+ self.parent.registerParametre(self)
self.parent.register(self)
- def isvalid(self,cr='non'):
+ def isValid(self,cr='non'):
"""
Retourne 1 si self est valide, 0 sinon
- Un paramètre est considéré comme valide si :
+ 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 donné au paramètre "))
+ 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 paramètre %s ne peut valoir None" , self.nom))
+ self.cr.fatal(tr("Le parametre %s ne peut valoir None" , self.nom))
return 0
return 1
- def isoblig(self):
+ def isOblig(self):
"""
Indique si self est obligatoire ou non : retourne toujours 0
"""
return 0
- def isrepetable(self):
+ def isRepetable(self):
"""
- Indique si self est répétable ou non : retourne toujours 1
+ Indique si self est repetable ou non : retourne toujours 1
"""
return 1
- def liste_mc_presents(self):
+ def listeMcPresents(self):
return []
def supprime(self):
"""
- Méthode qui supprime toutes les boucles de références afin que
- l'objet puisse être correctement détruit par le garbage collector
+ 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
def active(self):
"""
Rend l'etape courante active.
- Il faut ajouter le paramètre au contexte global du JDC
+ Il faut ajouter le parametre au contexte global du JDC
"""
self.actif = 1
try:
- self.jdc.append_param(self)
+ self.jdc.appendParam(self)
except:
pass
CONNECTOR.Emit(self,"add",None)
def inactive(self):
"""
Rend l'etape courante inactive
- Il faut supprimer le paramètre du contexte global du JDC
+ Il faut supprimer le parametre du contexte global du JDC
"""
self.actif = 0
- self.jdc.del_param(self)
- self.jdc.delete_concept_after_etape(self,self)
+ self.jdc.delParam(self)
+ self.jdc.deleteConceptAfterEtape(self,self)
CONNECTOR.Emit(self,"supp",None)
CONNECTOR.Emit(self,"valid")
- def isactif(self):
+ def isActif(self):
"""
- Booléenne qui retourne 1 si self est actif, 0 sinon
+ Booleenne qui retourne 1 si self est actif, 0 sinon
"""
return self.actif
- def set_attribut(self,nom_attr,new_valeur):
+ 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.init_modif()
+ self.initModif()
- def supprime_sdprods(self):
+ def supprimeSdProds(self):
"""
- Il faut supprimer le paramètre qui a été entré dans la liste des
- paramètres du JDC
+ Il faut supprimer le parametre qui a ete entre dans la liste des
+ parametres du JDC
"""
- self.jdc.delete_param(self)
- self.parent.delete_concept(self)
+ self.jdc.deleteParam(self)
+ self.parent.deleteConcept(self)
- def update_context(self,d):
+ def updateContext(self,d):
"""
- Update le dictionnaire d avec le paramètre que produit self
+ Update le dictionnaire d avec le parametre que produit self
"""
d[self.nom]=self
"""
Donne un echo de self sous la forme nom = valeur
"""
- if type(self.valeur) == types.StringType:
+ if type(self.valeur) == bytes:
if self.valeur.find('\n') == -1:
# pas de retour chariot, on utilise repr
return self.nom+' = '+ repr(self.valeur)
else:
return self.nom+' = '+ repr(self.valeur)
else:
- if type(self.valeur) == types.ListType :
+ if type(self.valeur) == list :
aRetourner=self.nom+' = ['
for l in self.valeur :
aRetourner=aRetourner+str(l) +","
def __str__(self):
"""
- Retourne le nom du paramètre comme représentation de self
+ Retourne le nom du parametre comme representation de self
"""
return self.nom
- def get_sdprods(self,nom_sd):
+ def getSdprods(self,nom_sd):
"""
Retourne les concepts produits par la commande
"""
return None
def report(self):
- """ Génère l'objet rapport (classe CR) """
+ """ Genere l'objet rapport (classe CR) """
self.cr=CR()
- self.isvalid(cr='oui')
+ self.isValid(cr='oui')
return self.cr
def ident(self):
"""
- Retourne le nom interne associé à self
+ Retourne le nom interne associe a self
Ce nom n'est jamais vu par l'utilisateur dans EFICAS
"""
return self.nom
- def delete_concept(self,sd):
+ def deleteConcept(self,sd):
pass
- def replace_concept(self,old_sd,sd):
+ def replaceConcept(self,old_sd,sd):
pass
- def verif_condition_bloc(self):
+ def verifConditionBloc(self):
"""
Evalue les conditions de tous les blocs fils possibles
- (en fonction du catalogue donc de la définition) de self et
+ (en fonction du catalogue donc de la definition) de self et
retourne deux listes :
- - la première contient les noms des blocs à rajouter
- - la seconde contient les noms des blocs à supprimer
+ - la premiere contient les noms des blocs a rajouter
+ - la seconde contient les noms des blocs a supprimer
"""
return [],[]
- def verif_condition_regles(self,liste_presents):
+ def verifConditionRegles(self,liste_presents):
"""
- Retourne la liste des mots-clés à rajouter pour satisfaire les règles
- en fonction de la liste des mots-clés présents
+ Retourne la liste des mots-cles a rajouter pour satisfaire les regles
+ en fonction de la liste des mots-cles presents
"""
return []
- def verif_existence_sd(self):
+ def verifExistenceSd(self):
pass
- def control_sdprods(self,d):
+ def controlSdprods(self,d):
"""sans objet """
pass
def close(self):
pass
- def reset_context(self):
+ def resetContext(self):
pass
def eval(self):
def __adapt__(self,validator):
return validator.adapt(self.eval())
-class COMBI_PARAMETRE :
+class COMBI_PARAMETRE(object) :
def __init__(self,chainevaleur,valeur):
self.chainevaleur=chainevaleur
self.valeur=valeur
def __repr__(self):
return self.chainevaleur
- def isvalid(self):
+ def isValid(self):
if self.valeur and self.chainevaleur:
return 1
-class ITEM_PARAMETRE :
+class ITEM_PARAMETRE(object) :
def __init__(self,param_pere,item=None):
self.param_pere = param_pere
self.item = item
return self.param_pere.nom+'['+str(self.item)+']'
- def isvalid(self):
- isvalid = 1
+ def isValid(self):
+ isValid = 1
if self.item < 0:
- isvalid = 0
+ isValid = 0
try:
longueur= len(self.param_pere.dict_valeur) - 1
except:
longueur=0
if self.item > longueur :
- isvalid= 0
- return isvalid
+ isValid= 0
+ return isValid
