# -*- coding: utf-8 -*-
-# CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
+# Copyright (C) 2007-2013 EDF R&D
#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
-# ======================================================================
-import types,string
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from __future__ import absolute_import
+import types
import traceback
from copy import copy
-from repr import Repr
+from six.moves.reprlib import Repr
+from Extensions.i18n import tr
+from Extensions.eficas_exception import EficasException
+from six.moves import range
myrepr = Repr()
myrepr.maxstring = 100
myrepr.maxother = 100
from Noyau.N_utils import repr_float
import Validation
-import CONNECTOR
+from . import CONNECTOR
-# Attention : les classes ASSD,.... peuvent etre surchargées
-# dans le package Accas. Il faut donc prendre des précautions si
+# Attention : les classes ASSD,.... peuvent etre surchargees
+# dans le package Accas. Il faut donc prendre des precautions si
# on utilise les classes du Noyau pour faire des tests (isxxxx, ...)
-# Si on veut créer des objets comme des CO avec les classes du noyau
+# Si on veut creer des objets comme des CO avec les classes du noyau
# ils n'auront pas les conportements des autres packages (pb!!!)
-# Il vaut mieux les importer d'Accas mais problème d'import circulaire,
-# on ne peut pas les importer au début.
-# On fait donc un import local quand c'est nécessaire (peut occasionner
+# Il vaut mieux les importer d'Accas mais probleme d'import circulaire,
+# on ne peut pas les importer au debut.
+# On fait donc un import local quand c'est necessaire (peut occasionner
# des pbs de prformance).
from Noyau.N_ASSD import ASSD,assd
from Noyau.N_GEOM import GEOM,geom
from Extensions import parametre
from Extensions import param2
-import I_OBJECT
-import CONNECTOR
-from I_VALIDATOR import ValError,listProto
+from . import I_OBJECT
+from . import CONNECTOR
+from .I_VALIDATOR import ValError,listProto
class MCSIMP(I_OBJECT.OBJECT):
def GetText(self):
"""
- Retourne le texte a afficher dans l'arbre représentant la valeur de l'objet
- pointé par self
+ Retourne le texte a afficher dans l'arbre representant la valeur de l'objet
+ pointe par self
"""
if self.valeur == None :
return None
- elif type(self.valeur) == types.FloatType :
- # Traitement d'un flottant isolé
+ elif type(self.valeur) == float :
+ # Traitement d'un flottant isole
txt = str(self.valeur)
clefobj=self.GetNomConcept()
- if self.jdc.appli.appliEficas.dict_reels.has_key(clefobj):
- if self.jdc.appli.appliEficas.dict_reels[clefobj].has_key(self.valeur):
+ if clefobj in self.jdc.appli.appliEficas.dict_reels :
+ if self.valeur in self.jdc.appli.appliEficas.dict_reels[clefobj]:
txt=self.jdc.appli.appliEficas.dict_reels[clefobj][self.valeur]
- elif type(self.valeur) in (types.ListType,types.TupleType) :
+ elif type(self.valeur) in (list,tuple) :
+ if self.valeur==[] or self.valeur == (): return str(self.valeur)
# Traitement des listes
txt='('
sep=''
for val in self.valeur:
- if type(val) == types.FloatType :
+ if type(val) == float :
clefobj=self.GetNomConcept()
- if self.jdc.appli.appliEficas.dict_reels.has_key(clefobj):
- if self.jdc.appli.appliEficas.dict_reels[clefobj].has_key(val):
+ if clefobj in self.jdc.appli.appliEficas.dict_reels:
+ if val in self.jdc.appli.appliEficas.dict_reels[clefobj]:
txt=txt + sep +self.jdc.appli.appliEficas.dict_reels[clefobj][val]
else :
txt=txt + sep + str(val)
else :
txt=txt + sep + str(val)
else:
- txt = txt + sep+ str(val)
- if len(txt) > 200:
- #ligne trop longue, on tronque
- txt=txt+" ..."
- break
+ if isinstance(val,tuple):
+ texteVal='('
+ for i in val :
+ if isinstance(i, bytes) : texteVal = texteVal +"'"+str(i)+"',"
+ else : texteVal = texteVal + str(i)+','
+ texteVal=texteVal[:-1]+')'
+ else :
+ if isinstance(val,bytes): texteVal="'"+str(val)+"'"
+ else :texteVal=str(val)
+ txt = txt + sep+ texteVal
+
+## if len(txt) > 200:
+## #ligne trop longue, on tronque
+## txt=txt+" ..."
+## break
sep=','
+ # cas des listes de tuples de longueur 1
+ if isinstance(val,tuple) and len(self.valeur) == 1 : txt=txt+','
txt=txt+')'
else:
# Traitement des autres cas
def getval(self):
"""
- Retourne une chaîne de caractère représentant la valeur de self
+ Retourne une chaine de caractere representant la valeur de self
"""
val=self.valeur
- if type(val) == types.FloatType :
+ if type(val) == float :
clefobj=self.GetNomConcept()
- if self.jdc.appli.appliEficas.dict_reels.has_key(clefobj):
- if self.jdc.appli.appliEficas.appliEficas.dict_reels[clefobj].has_key(val):
+ if clefobj in self.jdc.appli.appliEficas.dict_reels :
+ if val in self.jdc.appli.appliEficas.appliEficas.dict_reels[clefobj] :
return self.jdc.appli.appliEficas.dict_reels[clefobj][val]
- if type(val) != types.TupleType :
+ if type(val) != tuple :
try:
return val.get_name()
except:
return val
else :
+ if val ==() or val == [] : return val
s='( '
for item in val :
try :
s=s+item.get_name()+','
except:
- s=s+`item`+','
+ s=s+repr(item)+','
s=s+' )'
return s
+ def wait_bool(self):
+ for typ in self.definition.type:
+ try :
+ if typ == bool: return True
+ except :
+ pass
+ return False
+
def wait_co(self):
"""
- Méthode booléenne qui retourne 1 si l'objet attend un objet ASSD
+ Methode booleenne qui retourne 1 si l'objet attend un objet ASSD
qui n'existe pas encore (type CO()), 0 sinon
"""
for typ in self.definition.type:
- if type(typ) == types.ClassType or isinstance(typ,type):
+ if type(typ) == type or isinstance(typ,type):
if issubclass(typ,CO) :
return 1
return 0
def wait_assd(self):
"""
- Méthode booléenne qui retourne 1 si le MCS attend un objet de type ASSD
- ou dérivé, 0 sinon
+ Methode booleenne qui retourne 1 si le MCS attend un objet de type ASSD
+ ou derive, 0 sinon
"""
for typ in self.definition.type:
- if type(typ) == types.ClassType or isinstance(typ,type):
+ if type(typ) == type or isinstance(typ,type):
if issubclass(typ,ASSD) and not issubclass(typ,GEOM):
return 1
return 0
def wait_assd_or_geom(self):
"""
- Retourne 1 si le mot-clé simple attend un objet de type
+ Retourne 1 si le mot-cle simple attend un objet de type
assd, ASSD, geom ou GEOM
Retourne 0 dans le cas contraire
"""
for typ in self.definition.type:
- if type(typ) == types.ClassType or isinstance(typ,type):
+ if type(typ) == type or isinstance(typ,type):
if typ.__name__ in ("GEOM","ASSD","geom","assd") or issubclass(typ,GEOM) :
return 1
return 0
def wait_geom(self):
"""
- Retourne 1 si le mot-clé simple attend un objet de type GEOM
+ Retourne 1 si le mot-cle simple attend un objet de type GEOM
Retourne 0 dans le cas contraire
"""
for typ in self.definition.type:
- if type(typ) == types.ClassType or isinstance(typ,type):
+ if type(typ) == type or isinstance(typ,type):
if issubclass(typ,GEOM) : return 1
return 0
+
def wait_TXM(self):
"""
- Retourne 1 si le mot-clé simple attend un objet de type TXM
+ Retourne 1 si le mot-cle simple attend un objet de type TXM
Retourne 0 dans le cas contraire
"""
for typ in self.definition.type:
"""
if self.valeur == None:
return []
- elif type(self.valeur) == types.TupleType:
+ elif type(self.valeur) == tuple:
return list(self.valeur)
- elif type(self.valeur) == types.ListType:
+ elif type(self.valeur) == list:
return self.valeur
else:
return [self.valeur]
def isoblig(self):
return self.definition.statut=='o'
+ def isImmuable(self):
+ return self.definition.homo=='constant'
+
+ def isInformation(self):
+ return self.definition.homo=='information'
+
+
+
def valid_val(self,valeur):
"""
Verifie que la valeur passee en argument (valeur) est valide
lval=listProto.adapt(valeur)
if lval is None:
valid=0
- mess="None n'est pas une valeur autorisée"
+ mess=tr("None n'est pas une valeur autorisee")
else:
try:
for val in lval:
if self.definition.validators:
self.definition.validators.convert(lval)
valid,mess=1,""
- except ValError,e:
+ except ValError as e:
mess=str(e)
valid=0
return valid,mess
for val in new_valeur:
self.typeProto.adapt(val)
self.intoProto.adapt(val)
- #on ne verifie pas la cardinalité
+ #on ne verifie pas la cardinalite
if self.definition.validators:
validite=self.definition.validators.valide_liste_partielle(new_valeur)
- except ValError,e:
+ except ValError as e:
validite=0
return validite
def eval_valeur(self,new_valeur):
"""
- Essaie d'évaluer new_valeur comme une SD, une déclaration Python
- ou un EVAL: Retourne la valeur évaluée (ou None) et le test de réussite (1 ou 0)
+ Essaie d'evaluer new_valeur comme une SD, une declaration Python
+ ou un EVAL: Retourne la valeur evaluee (ou None) et le test de reussite (1 ou 0)
"""
sd = self.jdc.get_sd_avant_etape(new_valeur,self.etape)
#sd = self.jdc.get_contexte_avant(self.etape).get(new_valeur,None)
Si new_valeur contient au moins un separateur (,), tente l'evaluation sur
la chaine splittee
"""
- if type(new_valeur) in (types.ListType,types.TupleType):
+ if new_valeur in ('True','False') and 'TXM' in self.definition.type :
+ valeur=self.eval_val_item(str(new_valeur))
+ return new_valeur
+ if type(new_valeur) in (list,tuple):
valeurretour=[]
for item in new_valeur :
valeurretour.append(self.eval_val_item(item))
def cherche_item_parametre (self,new_valeur):
try:
nomparam=new_valeur[0:new_valeur.find("[")]
- indice=new_valeur[new_valeur.find("[")+1:new_valeur.find("]")]
+ indice=new_valeur[new_valeur.find(u"[")+1:new_valeur.find(u"]")]
for p in self.jdc.params:
if p.nom == nomparam :
if int(indice) < len(p.get_valeurs()):
return None
def update_concept(self,sd):
- if type(self.valeur) in (types.ListType,types.TupleType) :
+ if type(self.valeur) in (list,tuple) :
if sd in self.valeur:
self.init_modif()
self.fin_modif()
du concept sd
Attention aux matrices
"""
- if type(self.valeur) == types.TupleType :
+ if type(self.valeur) == tuple :
if sd in self.valeur:
self.init_modif()
self.valeur=list(self.valeur)
self.valeur.remove(sd)
self.fin_modif()
- elif type(self.valeur) == types.ListType:
+ elif type(self.valeur) == list:
if sd in self.valeur:
self.init_modif()
self.valeur.remove(sd)
def replace_concept(self,old_sd,sd):
"""
Inputs :
- - old_sd=concept remplacé
+ - old_sd=concept remplace
- sd=nouveau concept
Fonction :
Met a jour la valeur du mot cle simple suite au remplacement
du concept old_sd
"""
#print "replace_concept",old_sd,sd
- if type(self.valeur) == types.TupleType :
+ if type(self.valeur) == tuple :
if old_sd in self.valeur:
self.init_modif()
self.valeur=list(self.valeur)
i=self.valeur.index(old_sd)
self.valeur[i]=sd
self.fin_modif()
- elif type(self.valeur) == types.ListType:
+ elif type(self.valeur) == list:
if old_sd in self.valeur:
self.init_modif()
i=self.valeur.index(old_sd)
if nom_co == None or nom_co == '':
new_objet=None
else:
- # Avant de créer un concept il faut s'assurer du contexte : step
+ # Avant de creer un concept il faut s'assurer du contexte : step
# courant
sd= step.get_sd_autour_etape(nom_co,self.etape,avec='oui')
if sd:
- # Si un concept du meme nom existe deja dans la portée de l'étape
- # on ne crée pas le concept
- return 0,"un concept de meme nom existe deja"
- # Il n'existe pas de concept de meme nom. On peut donc le créer
- # Il faut néanmoins que la méthode NommerSdProd de step gère les
+ # Si un concept du meme nom existe deja dans la portee de l'etape
+ # on ne cree pas le concept
+ return 0,tr("un concept de meme nom existe deja")
+ # Il n'existe pas de concept de meme nom. On peut donc le creer
+ # Il faut neanmoins que la methode NommerSdProd de step gere les
# contextes en mode editeur
- # Normalement la méthode du Noyau doit etre surchargée
- # On déclare l'étape du mot clé comme etape courante pour NommerSdprod
+ # Normalement la methode du Noyau doit etre surchargee
+ # On declare l'etape du mot cle comme etape courante pour NommerSdprod
cs= CONTEXT.get_current_step()
CONTEXT.unset_current_step()
CONTEXT.set_current_step(step)
self.fin_modif()
step.reset_context()
#print "set_valeur_co",new_objet
- return 1,"Concept créé"
+ return 1,tr("Concept cree")
def verif_existence_sd(self):
"""
- Vérifie que les structures de données utilisées dans self existent bien dans le contexte
- avant étape, sinon enlève la référea ces concepts
+ Verifie que les structures de donnees utilisees dans self existent bien dans le contexte
+ avant etape, sinon enleve la referea ces concepts
"""
#print "verif_existence_sd"
# Attention : possible probleme avec include
# A priori il n'y a pas de raison de retirer les concepts non existants
# avant etape. En fait il s'agit uniquement eventuellement de ceux crees par une macro
- l_sd_avant_etape = self.jdc.get_contexte_avant(self.etape).values()
- if type(self.valeur) in (types.TupleType,types.ListType) :
+ l_sd_avant_etape = list(self.jdc.get_contexte_avant(self.etape).values())
+ if type(self.valeur) in (tuple,list) :
l=[]
for sd in self.valeur:
if isinstance(sd,ASSD) :
def get_type(self):
"""
- Retourne le type attendu par le mot-clé simple
+ Retourne le type attendu par le mot-cle simple
"""
return self.definition.type
def update_mc_global(self):
"""
- Met a jour les mots cles globaux enregistrés dans l'étape parente
+ Met a jour les mots cles globaux enregistres dans l'etape parente
et dans le jdc parent.
Un mot cle simple peut etre global.
"""
return 0
def valide_item(self,item):
- """Valide un item isolé. Cet item est candidata l'ajout a la liste existante"""
+ """Valide un item isole. Cet item est candidata l'ajout a la liste existante"""
valid=1
try:
#on verifie le type
self.typeProto.adapt(item)
#on verifie les choix possibles
self.intoProto.adapt(item)
- #on ne verifie pas la cardinalité
+ #on ne verifie pas la cardinalite
if self.definition.validators:
valid=self.definition.validators.verif_item(item)
- except ValError,e:
+ except ValError as e:
#traceback.print_exc()
valid=0
return valid
self.typeProto.adapt(item)
#on verifie les choix possibles
self.intoProto.adapt(item)
- #on ne verifie pas la cardinalité mais on verifie les validateurs
+ #on ne verifie pas la cardinalite mais on verifie les validateurs
if self.definition.validators:
valid=self.definition.validators.verif_item(item)
comment=""
valid=1
- except ValError,e:
+ except ValError as e:
#traceback.print_exc()
- comment=str(e)
+ comment=tr(e.__str__())
valid=0
return valid,comment
def valideMatrice(self,cr):
#Attention, la matrice contient comme dernier tuple l ordre des variables
+ if self.valideEnteteMatrice()==False :
+ self.set_valid(0)
+ if cr == "oui" : self.cr.fatal(tr("La matrice n'a pas le bon entete"))
+ return 0
if self.monType.methodeCalculTaille != None :
- apply (MCSIMP.__dict__[self.monType.methodeCalculTaille],(self,))
+ MCSIMP.__dict__[self.monType.methodeCalculTaille](*(self,))
try :
#if 1 :
ok=0
#else :
pass
if cr == 'oui' :
- self.cr.fatal("La matrice n est pas une matrice "+str(self.monType.nbLigs)+","+str(self.monType.nbCols))
+ self.cr.fatal(tr("La matrice n'est pas une matrice %(n_lign)d sur %(n_col)d", \
+ {'n_lign': self.monType.nbLigs, 'n_col': self.monType.nbCols}))
self.set_valid(0)
return 0
+
def NbDeVariables(self):
listeVariables=self.jdc.get_variables(self.etape)
self.monType.nbLigs=len(listeVariables)
self.monType.nbCols=len(listeVariables)
+ def valideEnteteMatrice(self):
+ if self.jdc.get_distributions(self.etape) == () or self.valeur == None : return 0
+ if self.jdc.get_distributions(self.etape) != self.valeur[0] : return 0
+ return 1
+
+ def changeEnteteMatrice(self):
+ a=[self.jdc.get_distributions(self.etape),]
+ for t in self.valeur[1:]:
+ a.append(t)
+ self.valeur=a
+
+
+ def NbDeDistributions(self):
+ listeVariables=self.jdc.get_distributions(self.etape)
+ self.monType.nbLigs=len(listeVariables)
+ self.monType.nbCols=len(listeVariables)
#--------------------------------------------------------------------------------
