+# -*- coding: utf-8 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
from Noyau.N_ASSD import ASSD,assd
from Noyau.N_GEOM import GEOM,geom
from Noyau.N_CO import CO
+import Accas
# fin attention
from Extensions import parametre
+from Extensions import param2
import I_OBJECT
+import CONNECTOR
class MCSIMP(I_OBJECT.OBJECT):
+
+ def GetNomConcept(self):
+ p=self
+ while p.parent :
+ try :
+ nomconcept=p.get_sdname()
+ return nomconcept
+ except:
+ try :
+ nomconcept= p.object.get_sdname()
+ return nomconcept
+ except :
+ pass
+ p=p.parent
+ return ""
+
def GetText(self):
"""
Retourne le texte à afficher dans l'arbre représentant la valeur de l'objet
pointé par self
"""
+
if self.valeur == None :
return None
elif type(self.valeur) == types.FloatType :
# Traitement d'un flottant isolé
- #txt = repr_float(self.valeur)
+ # txt = repr_float(self.valeur)
# Normalement str fait un travail correct
txt = str(self.valeur)
+ clefobj=self.GetNomConcept()
+ if self.jdc.appli.dict_reels.has_key(clefobj):
+ if self.jdc.appli.dict_reels[clefobj].has_key(self.valeur):
+ txt=self.jdc.appli.dict_reels[clefobj][self.valeur]
elif type(self.valeur) in (types.ListType,types.TupleType) :
# Traitement des listes
txt='('
if type(val) == types.FloatType :
# CCAR : Normalement str fait un travail correct
#txt=txt + i*',' + repr_float(val)
- txt=txt + i*',' + str(val)
+ clefobj=self.GetNomConcept()
+ if self.jdc.appli.dict_reels.has_key(clefobj):
+ if self.jdc.appli.dict_reels[clefobj].has_key(val):
+ txt=txt + i*',' +self.jdc.appli.dict_reels[clefobj][val]
+ else :
+ txt=txt + i*',' + str(val)
+ else :
+ txt=txt + i*',' + str(val)
elif isinstance(val,ASSD):
txt = txt + i*',' + val.get_name()
#PN
txt = txt + i*','+ myrepr.repr(val)
i=1
txt=txt+')'
+ elif isinstance(self.valeur,ASSD):
+ # Cas des ASSD
+ txt=self.getval()
+ elif type(self.valeur) == types.InstanceType and self.valeur.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'):
+ # Cas des PARAMETRES
+ txt=str(self.valeur)
else:
# Traitement des autres cas
- txt = self.getval()
-
- if type(txt) == types.InstanceType:
- if isinstance(txt,parametre.PARAMETRE):
- txt= str(txt)
- else:
- txt=repr(txt)
+ txt = myrepr.repr(self.valeur)
# txt peut etre une longue chaine sur plusieurs lignes.
# Il est possible de tronquer cette chaine au premier \n et
Retourne une chaîne de caractère représentant la valeur de self
"""
val=self.valeur
+ if type(val) == types.FloatType :
+ clefobj=self.GetNomConcept()
+ if self.jdc.appli.dict_reels.has_key(clefobj):
+ if self.jdc.appli.dict_reels[clefobj].has_key(val):
+ return self.jdc.appli.dict_reels[clefobj][val]
if type(val) != types.TupleType :
try:
return val.get_name()
def isoblig(self):
return self.definition.statut=='o'
-# def set_valeur(self,new_valeur,evaluation='oui'):
-# """
-# Remplace la valeur de self(si elle existe) par new_valeur
-# - si evaluation = 'oui' :
-# essaie d'évaluer new_valeur dans le contexte
-# - si evaluation = 'non' :
-# n'essaie pas d'évaluer (on stocke une string ou
-# une valeur de la liste into )
-# """
-# if evaluation == 'oui' and not self.wait_assd_or_geom():
-# valeur,test = self.eval_valeur(new_valeur)
-# if test :
-# self.val = new_valeur
-# self.valeur = valeur
-# self.init_modif()
-# self.fin_modif()
-# return 1
-# else:
-# # On n'a pas trouve de concept ni réussi à évaluer la valeur
-# # dans le contexte
-# # Si le mot cle simple attend un type CO on crée un objet de ce
-# # type de nom new_valeur
-# if self.wait_co():
-# try:
-# # Pour avoir la classe CO avec tous ses comportements
-# from Accas import CO
-# self.valeur=CO(new_valeur)
-# except:
-# traceback.print_exc()
-# return 0
-# self.init_modif()
-# self.val=self.valeur
-# self.fin_modif()
-# return 1
-# elif type(new_valeur)==types.StringType and self.wait_TXM():
-# self.init_modif()
-# self.val = new_valeur
-# self.valeur = new_valeur
-# self.fin_modif()
-# return 1
-# else:
-# return 0
-# else :
- # on ne fait aucune vérification ...
+ def valid_valeur(self,new_valeur):
+ """
+ Verifie que la valeur passee en argument (new_valeur) est valide
+ sans modifier la valeur courante (evite d'utiliser set_valeur et est plus performant)
+ """
+ old_valeur=self.valeur
+ old_val=self.val
+ self.valeur = new_valeur
+ self.val = new_valeur
+ self.state="modified"
+ validite=self.isvalid()
+ self.valeur = old_valeur
+ self.val = old_valeur
+ self.state="modified"
+ self.isvalid()
+ return validite
+
+ def valid_valeur_partielle(self,new_valeur):
+ """
+ Verifie que la valeur passee en argument (new_valeur) est partiellement valide
+ sans modifier la valeur courante (evite d'utiliser set_valeur et est plus performant)
+ """
+ old_valeur=self.valeur
+ old_val=self.val
+
+ self.valeur = new_valeur
+ self.val = new_valeur
+ self.state="modified"
+ validite=0
+ if self.isvalid():
+ validite=1
+ elif self.definition.validators :
+ validite=self.definition.validators.valide_liste_partielle(new_valeur)
+
+ if validite==0:
+ min,max=self.get_min_max()
+ if len(new_valeur) < min :
+ validite=1
+
+ self.valeur = old_valeur
+ self.val = old_valeur
+ self.state="modified"
+ self.isvalid()
+ return validite
+
+ def update_condition_bloc(self):
+ """ Met a jour les blocs conditionnels dependant du mot cle simple self
+ """
+ if self.definition.position == 'global' :
+ self.etape.deep_update_condition_bloc()
+ elif self.definition.position == 'global_jdc' :
+ self.jdc.deep_update_condition_bloc()
+ else:
+ self.parent.update_condition_bloc()
+
def set_valeur(self,new_valeur,evaluation='oui'):
+ #print "set_valeur",new_valeur
self.init_modif()
self.valeur = new_valeur
self.val = new_valeur
+ self.update_condition_bloc()
self.fin_modif()
return 1
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)
"""
- sd = self.jdc.get_contexte_avant(self.etape).get(new_valeur,None)
+ sd = self.jdc.get_sd_avant_etape(new_valeur,self.etape)
+ #sd = self.jdc.get_contexte_avant(self.etape).get(new_valeur,None)
+ #print sd
if sd :
return sd,1
+ lsd = self.jdc.cherche_list_avant(self.etape,new_valeur)
+ if lsd :
+ return lsd,1
else:
d={}
# On veut EVAL avec tous ses comportements. On utilise Accas. Perfs ??
- from Accas import EVAL
- d['EVAL']=EVAL
+ d['EVAL']=Accas.EVAL
try :
objet = eval(new_valeur,d)
return objet,1
except Exception:
+ itparam=self.cherche_item_parametre(new_valeur)
+ if itparam:
+ return itparam,1
+ try :
+ object=eval(new_valeur.valeur,d)
+ except :
+ pass
if CONTEXT.debug : traceback.print_exc()
return None,0
+ 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("]")]
+ for p in self.jdc.params:
+ if p.nom == nomparam :
+ if int(indice) < len(p.get_valeurs()):
+ itparam=parametre.ITEM_PARAMETRE(p,int(indice))
+ return itparam
+ return None
+ except:
+ return None
+
+ def update_concept(self,sd):
+ if type(self.valeur) in (types.ListType,types.TupleType) :
+ if sd in self.valeur:self.fin_modif()
+ else:
+ if sd == self.valeur:self.fin_modif()
+
def delete_concept(self,sd):
"""
Inputs :
Met a jour la valeur du mot cle simple suite à la disparition
du concept sd
"""
+ #print "delete_concept",sd
if type(self.valeur) == types.TupleType :
if sd in self.valeur:
+ self.init_modif()
self.valeur=list(self.valeur)
self.valeur.remove(sd)
- self.init_modif()
+ self.fin_modif()
elif type(self.valeur) == types.ListType:
if sd in self.valeur:
- self.valeur.remove(sd)
self.init_modif()
+ self.valeur.remove(sd)
+ self.fin_modif()
else:
if self.valeur == sd:
+ self.init_modif()
self.valeur=None
self.val=None
- self.init_modif()
+ self.fin_modif()
def replace_concept(self,old_sd,sd):
"""
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 old_sd in self.valeur:
+ self.init_modif()
self.valeur=list(self.valeur)
i=self.valeur.index(old_sd)
self.valeur[i]=sd
- self.init_modif()
+ self.fin_modif()
elif type(self.valeur) == types.ListType:
if old_sd in self.valeur:
+ self.init_modif()
i=self.valeur.index(old_sd)
self.valeur[i]=sd
- self.init_modif()
+ self.fin_modif()
else:
if self.valeur == old_sd:
+ self.init_modif()
self.valeur=sd
self.val=sd
- self.init_modif()
-
- def copy(self):
- """ Retourne une copie de self """
- objet = self.makeobjet()
- # il faut copier les listes et les tuples mais pas les autres valeurs
- # possibles (réel,SD,...)
- if type(self.valeur) in (types.ListType,types.TupleType):
- objet.valeur = copy(self.valeur)
- else:
- objet.valeur = self.valeur
- objet.val = objet.valeur
- return objet
-
- def makeobjet(self):
- return self.definition(val = None, nom = self.nom,parent = self.parent)
-
- def get_sd_utilisees(self):
- """
- Retourne une liste qui contient la SD utilisée par self si c'est le cas
- ou alors une liste vide
- """
- l=[]
- if type(self.valeur) == types.InstanceType:
- #XXX Est ce différent de isinstance(self.valeur,ASSD) ??
- if issubclass(self.valeur.__class__,ASSD) : l.append(self.valeur)
- return l
-
+ self.fin_modif()
def set_valeur_co(self,nom_co):
"""
Affecte à self l'objet de type CO et de nom nom_co
"""
+ #print "set_valeur_co",nom_co
step=self.etape.parent
if nom_co == None or nom_co == '':
new_objet=None
else:
- # Pour le moment on importe en local le CO de Accas.
- # Si problème de perfs, il faudra faire autrement
- from Accas import CO
# Avant de créer un concept il faut s'assurer du contexte : step
# courant
sd= step.get_sd_autour_etape(nom_co,self.etape,avec='oui')
CONTEXT.unset_current_step()
CONTEXT.set_current_step(step)
step.set_etape_context(self.etape)
- new_objet = CO(nom_co)
+ new_objet = Accas.CO(nom_co)
CONTEXT.unset_current_step()
CONTEXT.set_current_step(cs)
self.init_modif()
# On force l'enregistrement de new_objet en tant que concept produit
# de la macro en appelant get_type_produit avec force=1
self.etape.get_type_produit(force=1)
+ #print "set_valeur_co",new_objet
return 1,"Concept créé"
- def reparent(self,parent):
- """
- Cette methode sert a reinitialiser la parente de l'objet
- """
- self.parent=parent
- self.jdc=parent.jdc
- self.etape=parent.etape
-
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érence à ces concepts
"""
+ #print "verif_existence_sd"
+ # Attention : possible probleme avec include
l_sd_avant_etape = self.jdc.get_contexte_avant(self.etape).values()
if type(self.valeur) in (types.TupleType,types.ListType) :
l=[]
+ self.init_modif()
for sd in self.valeur:
if isinstance(sd,ASSD) :
if sd in l_sd_avant_etape :
else:
l.append(sd)
self.valeur=tuple(l)
- # Est ce init_modif ou init_modif_up
- # Normalement init_modif va avec fin_modif
- self.init_modif()
self.fin_modif()
else:
if isinstance(self.valeur,ASSD) :
if self.valeur not in l_sd_avant_etape :
- self.valeur = None
self.init_modif()
+ self.valeur = None
self.fin_modif()
def get_min_max(self):
Retourne le type attendu par le mot-clé simple
"""
return self.definition.type
+
+ def delete_mc_global(self):
+ """ Retire self des declarations globales
+ """
+ if self.definition.position == 'global' :
+ etape = self.get_etape()
+ if etape :
+ del etape.mc_globaux[self.nom]
+ elif self.definition.position == 'global_jdc' :
+ del self.jdc.mc_globaux[self.nom]
+
+ def update_mc_global(self):
+ """
+ Met a jour les mots cles globaux enregistrés dans l'étape parente
+ et dans le jdc parent.
+ Un mot cle simple peut etre global.
+ """
+ if self.definition.position == 'global' :
+ etape = self.get_etape()
+ if etape :
+ etape.mc_globaux[self.nom]=self
+ elif self.definition.position == 'global_jdc' :
+ if self.jdc:
+ self.jdc.mc_globaux[self.nom]=self
+
+ def nbrColonnes(self):
+ genea = self.get_genealogie()
+ if "VALE_C" in genea and "DEFI_FONCTION" in genea : return 3
+ if "VALE" in genea and "DEFI_FONCTION" in genea : return 2
+ print dir(self)
+ return 0
+
+#--------------------------------------------------------------------------------
#ATTENTION SURCHARGE : toutes les methodes ci apres sont des surcharges du Noyau et de Validation
# Elles doivent etre reintegrees des que possible
- def is_complexe(self,valeur):
- """ Retourne 1 si valeur est un complexe, 0 sinon """
- if type(valeur) == types.InstanceType :
- #XXX je n'y touche pas pour ne pas tout casser mais il serait
- #XXX préférable d'appeler une méthode de valeur : return valeur.is_type('C'), par exemple
- if valeur.__class__.__name__ in ('EVAL','complexe','PARAMETRE_EVAL'):
- return 1
- elif valeur.__class__.__name__ in ('PARAMETRE',):
- # il faut tester si la valeur du parametre est un entier
- #XXX ne serait ce pas plutot complexe ???? sinon expliquer
- return self.is_complexe(valeur.valeur)
- else:
- print "Objet non reconnu dans is_complexe %s" %`valeur`
- return 0
- # Pour permettre l'utilisation de complexes Python
- #elif type(valeur) == types.ComplexType:
- #return 1
- elif type(valeur) == types.ListType :
- # On n'autorise pas les listes de complexes
- return 0
- elif type(valeur) != types.TupleType :
- # Un complexe doit etre un tuple
- return 0
- else:
- if len(valeur) != 3 :
- return 0
- else:
- if type(valeur[0]) != types.StringType : return 0
- if string.strip(valeur[0]) not in ('RI','MP'):
- return 0
- else:
- if not self.is_reel(valeur[1]) or not self.is_reel(valeur[2]) : return 0
- else: return 1
-
- def is_reel(self,valeur):
- """
- Retourne 1 si valeur est un reel, 0 sinon
- """
- if type(valeur) == types.InstanceType :
- #XXX je n'y touche pas pour ne pas tout casser mais il serait
- #XXX préférable d'appeler une méthode de valeur : return valeur.is_type('R'), par exemple
- #XXX ou valeur.is_reel()
- #XXX ou encore valeur.compare(self.is_reel)
- if valeur.__class__.__name__ in ('EVAL','reel','PARAMETRE_EVAL') :
- return 1
- elif valeur.__class__.__name__ in ('PARAMETRE',):
- # il faut tester si la valeur du parametre est un réel
- return self.is_reel(valeur.valeur)
- else:
- print "Objet non reconnu dans is_reel %s" %`valeur`
- return 0
- elif type(valeur) not in (types.IntType,types.FloatType,types.LongType):
- # ce n'est pas un réel
- return 0
- else:
- return 1
-
- def is_entier(self,valeur):
- """ Retourne 1 si valeur est un entier, 0 sinon """
- if type(valeur) == types.InstanceType :
- #XXX je n'y touche pas pour ne pas tout casser mais il serait
- #XXX préférable d'appeler une méthode de valeur : return valeur.is_type('I'), par exemple
- if valeur.__class__.__name__ in ('EVAL','entier','PARAMETRE_EVAL') :
- return 1
- elif valeur.__class__.__name__ in ('PARAMETRE',):
- # il faut tester si la valeur du parametre est un entier
- return self.is_entier(valeur.valeur)
- else:
- print "Objet non reconnu dans is_reel %s" %`valeur`
- return 0
- elif type(valeur) not in (types.IntType,types.LongType):
- # ce n'est pas un entier
- return 0
- else:
- return 1
-
- def is_object_from(self,objet,classe):
- """
- Retourne 1 si valeur est un objet de la classe classe ou d'une
- sous-classe de classe, 0 sinon
- """
- if type(objet) != types.InstanceType :
- return 0
- if not objet.__class__ == classe and not issubclass(objet.__class__,classe):
- return 0
- else:
- return 1
-
- def get_valid(self):
- if hasattr(self,'valid'):
- return self.valid
- else:
- self.valid=None
- return None
-
- def set_valid(self,valid):
- old_valid=self.get_valid()
- self.valid = valid
- self.state = 'unchanged'
- if not old_valid or old_valid != self.valid :
- self.init_modif_up()
def isvalid(self,cr='non'):
"""
if self.state == 'unchanged':
return self.valid
else:
- v=self.valeur
valid = 1
- # verifiaction presence
+ v=self.valeur
+ # verification presence
if self.isoblig() and v == None :
if cr == 'oui' :
self.cr.fatal(string.join(("Mot-clé : ",self.nom," obligatoire non valorisé")))
valid = 0
if v is None:
- valid=0
- if cr == 'oui' :
- self.cr.fatal("None n'est pas une valeur autorisée")
+ valid=0
+ if cr == 'oui' :
+ self.cr.fatal("None n'est pas une valeur autorisée")
else:
- # type,into ...
- valid = self.verif_type(val=v,cr=cr)*self.verif_into(cr=cr)*self.verif_card(cr=cr)
- #
- # On verifie les validateurs s'il y en a et si necessaire (valid == 1)
- #
- if valid and self.definition.validators and not self.definition.validators.verif(self.valeur):
- if cr == 'oui' :
- self.cr.fatal(string.join(("Mot-clé : ",self.nom,"devrait avoir ",self.definition.validators.info())))
- valid=0
- # fin des validateurs
- #
+ # type,into ...
+ #PN ??? je n ose pas y toucher ???
+ #if v.__class__.__name__ in ('PARAMETRE','EVAL', 'ITEM_PARAMETRE','PARAMETRE_EVAL'):
+ if ((issubclass(v.__class__,param2.Formula)) or
+ (v.__class__.__name__ in ('EVAL', 'ITEM_PARAMETRE','PARAMETRE_EVAL'))):
+ verif_type=self.verif_typeihm(v)
+ else:
+ verif_type=self.verif_type(val=v,cr=None)
+ # cas des tuples avec un ITEM_PARAMETRE
+ if verif_type == 0:
+ if type(v) == types.TupleType :
+ new_val=[]
+ for i in v:
+ if ((issubclass(i.__class__,param2.Formula)) or
+ (i.__class__.__name__ in ('EVAL', 'ITEM_PARAMETRE','PARAMETRE_EVAL'))):
+ if self.verif_typeihm(val=i,cr=cr) == 0:
+ verif_type = 0
+ break
+ else:
+ new_val.append(i)
+ if new_val != [] :
+ verif_type=self.verif_type(val=new_val,cr=cr)
+ else :
+ # Cas d une liste de paramétre
+ verif_type=self.verif_typeliste(val=v,cr=cr)
+ else:
+ verif_type=self.verif_type(val=v,cr=cr)
+ valid = verif_type*self.verif_into(cr=cr)*self.verif_card(cr=cr)
+ #
+ # On verifie les validateurs s'il y en a et si necessaire (valid == 1)
+ #
+ if valid and self.definition.validators and not self.definition.validators.verif(self.valeur):
+ if cr == 'oui' :
+ self.cr.fatal(string.join(("Mot-clé : ",self.nom,"devrait avoir ",self.definition.validators.info())))
+ valid=0
+ # fin des validateurs
+ #
+ # cas d un item Parametre
+ if self.valeur.__class__.__name__ == 'ITEM_PARAMETRE':
+ valid=self.valeur.isvalid()
+ if valid == 0:
+ if cr == 'oui' :
+ self.cr.fatal(string.join( repr (self.valeur), " a un indice incorrect"))
self.set_valid(valid)
return self.valid
- def verif_into(self,cr='non'):
- """
- Vérifie si la valeur de self est bien dans l'ensemble discret de valeurs
- donné dans le catalogue derrière l'attribut into ou vérifie que valeur est bien compris
- entre val_min et val_max
- """
- if self.definition.into == None :
- #on est dans le cas d'un ensemble continu de valeurs possibles (intervalle)
- if type(self.valeur)==types.TupleType :
- test = 1
- for val in self.valeur :
- if type(val)!=types.StringType and type(val)!=types.InstanceType:
- test = test*self.isinintervalle(val,cr=cr)
- return test
- else :
- val = self.valeur
- if type(val)!=types.StringType and type(val)!=types.InstanceType:
- return self.isinintervalle(self.valeur,cr=cr)
- else :
- return 1
- else :
- # on est dans le cas d'un ensemble discret de valeurs possibles (into)
- # PN : pour résoudre le pb du copier /coller de la liste Ordonnee
- # if type(self.valeur) == types.TupleType :
- if type(self.valeur) in (types.ListType,types.TupleType) :
- for e in self.valeur:
- if e not in self.definition.into:
- if cr=='oui':
- self.cr.fatal(string.join(("La valeur :",`e`," n'est pas permise pour le mot-clé :",self.nom)))
- return 0
- else:
- if self.valeur == None or self.valeur not in self.definition.into:
- if cr=='oui':
- self.cr.fatal(string.join(("La valeur :",`self.valeur`," n'est pas permise pour le mot-clé :",self.nom)))
- return 0
- return 1
+ def verif_typeihm(self,val,cr='non'):
+ try :
+ val.eval()
+ return 1
+ except :
+ pass
+ return self.verif_type(val,cr)
+
+ def verif_typeliste(self,val,cr='non') :
+ verif=0
+ for v in val :
+ verif=verif+self.verif_typeihm(v,cr)
+ return verif
+