-#@ MODIF N_ASSD Noyau DATE 14/09/2004 AUTEUR MCOURTOI M.COURTOIS
+#@ MODIF N_ASSD Noyau DATE 22/02/2005 AUTEUR DURAND C.DURAND
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
d=self.__dict__.copy()
for key in ('parent','etape','jdc'):
if d.has_key(key):del d[key]
+ for key in d.keys():
+ if key[0]=='_':del d[key]
return d
class assd(ASSD):
-#@ MODIF N_CO Noyau DATE 14/09/2004 AUTEUR MCOURTOI M.COURTOIS
+#@ MODIF N_CO Noyau DATE 22/02/2005 AUTEUR DURAND C.DURAND
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
else:
self.nom=nom
+ def is_object(valeur):
+ """
+ Indique si valeur est d'un type conforme à la classe (retourne 1)
+ ou non conforme (retourne 0)
+ """
+ if hasattr(valeur,'_etape') :
+ # valeur est un concept CO qui a ete transforme par type_sdprod
+ if valeur.etape == valeur._etape:
+ # le concept est bien produit par l'etape
+ return 1
+ return 0
+
-#@ MODIF N_ETAPE Noyau DATE 14/09/2004 AUTEUR MCOURTOI M.COURTOIS
+#@ MODIF N_ETAPE Noyau DATE 22/02/2005 AUTEUR DURAND C.DURAND
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
return self.sd
def get_type_produit(self):
+ try:
+ return self.get_type_produit_brut()
+ except:
+ return None
+
+ def get_type_produit_brut(self):
"""
Retourne le type du concept résultat de l'étape
Deux cas :
"""
if type(self.definition.sd_prod) == types.FunctionType:
d=self.cree_dict_valeurs(self.mc_liste)
- try:
- sd_prod= apply(self.definition.sd_prod,(),d)
- except:
- #traceback.print_exc()
- return None
+ sd_prod= apply(self.definition.sd_prod,(),d)
else:
sd_prod=self.definition.sd_prod
return sd_prod
if hasattr(old_etape,"sdnom") :
self.sdnom = old_etape.sdnom
- def get_sd_utilisees(self):
- """
- Retourne la liste des concepts qui sont utilisés à l'intérieur d'une commande
- ( comme valorisation d'un MCS)
- """
- l=[]
- for child in self.mc_liste:
- l.extend(child.get_sd_utilisees())
- return l
-
- def get_sd_mcs_utilisees(self):
- """
- Retourne la ou les SD utilisée par self sous forme d'un dictionnaire :
- . Si aucune sd n'est utilisée, le dictionnaire est vide.
- . Sinon, les clés du dictionnaire sont les mots-clés derrière lesquels on
- trouve des sd ; la valeur est la liste des sd attenante.
- Exemple : { 'VALE_F': [ <Cata.cata.para_sensi instance at 0x9419854>,
- <Cata.cata.para_sensi instance at 0x941a204> ],
- 'MODELE': [<Cata.cata.modele instance at 0x941550c>] }
- """
- dico = {}
- for child in self.mc_liste:
- daux = child.get_sd_mcs_utilisees()
- for cle in daux.keys():
- dico[cle] = daux[cle]
- return dico
-
def reparent(self,parent):
"""
Cette methode sert a reinitialiser la parente de l'objet
-#@ MODIF N_MACRO_ETAPE Noyau DATE 14/09/2004 AUTEUR MCOURTOI M.COURTOIS
+#@ MODIF N_MACRO_ETAPE Noyau DATE 22/02/2005 AUTEUR DURAND C.DURAND
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
from N_Exception import AsException
import N_utils
from N_utils import AsType
+from N_CO import CO
class MACRO_ETAPE(N_ETAPE.ETAPE):
"""
self.jdc = self.parent.get_jdc_root()
self.id=self.parent.register(self)
self.niveau=None
+ self.UserError=self.jdc.UserError
else:
self.jdc = self.parent =None
self.id=None
self.niveau=None
+ self.UserError="UserError"
def Build_sd(self,nom):
"""
self.reset_current_step()
raise AsException("Etape ",self.nom,'ligne : ',self.appel[0],
'fichier : ',self.appel[1],e)
- except (EOFError,self.jdc.UserError):
+ except (EOFError,self.UserError):
# Le retablissement du step courant n'est pas strictement necessaire. On le fait pour des raisons de coherence
self.reset_current_step()
raise
self.Execute()
return sd
+ def mark_CO(self):
+ """
+ Marquage des concepts CO d'une macro-commande
+ """
+ # On marque les concepts CO pour verification ulterieure de leur bonne utilisation
+ l=self.get_all_co()
+ for c in l:
+ #if not hasattr(c,"_etape") or c._etape is not c.etape:
+ c._etape=self
+ return l
+
def get_sd_prod(self):
"""
Retourne le concept résultat d'une macro étape
"""
sd_prod=self.definition.sd_prod
self.typret=None
+ # On marque les concepts CO pour verification ulterieure de leur bonne utilisation
+ self.mark_CO()
+
if type(self.definition.sd_prod) == types.FunctionType:
d=self.cree_dict_valeurs(self.mc_liste)
try:
# les concepts produits dans self.sdprods, il faut le mettre à zéro avant de l'appeler
self.sdprods=[]
sd_prod= apply(sd_prod,(self,),d)
- except (EOFError,self.jdc.UserError):
+ except (EOFError,self.UserError):
raise
except:
if CONTEXT.debug: traceback.print_exc()
return self.sd
def get_type_produit(self,force=0):
+ try:
+ return self.get_type_produit_brut(force)
+ except:
+ #traceback.print_exc()
+ return None
+
+ def get_type_produit_brut(self,force=0):
"""
Retourne le type du concept résultat de l'étape et eventuellement type
les concepts produits "à droite" du signe égal (en entrée)
et on retourne son résultat
"""
if not force and hasattr(self,'typret'): return self.typret
+ # On marque les concepts CO pour verification ulterieure de leur bonne utilisation
+ self.mark_CO()
+
if type(self.definition.sd_prod) == types.FunctionType:
d=self.cree_dict_valeurs(self.mc_liste)
- try:
- # Comme sd_prod peut invoquer la méthode type_sdprod qui ajoute
- # les concepts produits dans self.sdprods, il faut le mettre à zéro
- self.sdprods=[]
- sd_prod= apply(self.definition.sd_prod,(self,),d)
- except:
- #traceback.print_exc()
- return None
+ # Comme sd_prod peut invoquer la méthode type_sdprod qui ajoute
+ # les concepts produits dans self.sdprods, il faut le mettre à zéro
+ self.sdprods=[]
+ sd_prod= apply(self.definition.sd_prod,(self,),d)
else:
sd_prod=self.definition.sd_prod
return sd_prod
if not hasattr(co,'etape'):
# Le concept vaut None probablement. On ignore l'appel
return
-
+ #
+ # On cherche a discriminer les differents cas de typage d'un concept
+ # produit par une macro qui est specifie dans un mot cle simple.
+ # On peut passer plusieurs fois par type_sdprod ce qui explique
+ # le nombre important de cas.
+ #
+ # Cas 1 : Le concept est libre. Il vient d'etre cree par CO(nom)
+ # Cas 2 : Le concept est produit par la macro. On est deja passe par type_sdprod.
+ # Cas semblable a Cas 1.
+ # Cas 3 : Le concept est produit par la macro englobante (parent). On transfere
+ # la propriete du concept de la macro parent a la macro courante (self)
+ # en verifiant que le type est valide
+ # Cas 4 : La concept est la propriete d'une etape fille. Ceci veut dire qu'on est
+ # deja passe par type_sdprod et que la propriete a ete transfere a une
+ # etape fille. Cas semblable a Cas 3.
+ # Cas 5 : Le concept est produit par une etape externe a la macro.
+ #
if co.etape == None:
- # le concept est libre
+ # Cas 1 : le concept est libre
+ # On l'attache a la macro et on change son type dans le type demande
+ # Recherche du mot cle simple associe au concept
+ mcs=self.get_mcs_with_co(co)
+ if len(mcs) != 1:
+ raise AsException("""Erreur interne.
+Il ne devrait y avoir qu'un seul mot cle porteur du concept CO (%s)""" % co)
+ mcs=mcs[0]
+ if not CO in mcs.definition.type:
+ raise AsException("""Erreur interne.
+Impossible de changer le type du concept (%s). Le mot cle associe ne supporte pas CO mais seulement (%s)""" %(co,mcs.definition.type))
co.etape=self
co.__class__ = t
self.sdprods.append(co)
+
elif co.etape== self:
- # le concept est produit par self
- co.__class__ = t
+ # Cas 2 : le concept est produit par la macro (self)
+ # On est deja passe par type_sdprod (Cas 1 ou 3).
+ # Il suffit de le mettre dans la liste des concepts produits (self.sdprods)
+ # Le type du concept doit etre coherent avec le type demande (seulement derive)
+ if not isinstance(co,t):
+ raise AsException("""Erreur interne.
+Le type demande (%s) et le type du concept (%s) devraient etre derives""" %(t,co.__class__))
self.sdprods.append(co)
+
elif co.etape== self.parent:
- # le concept est produit par la macro superieure
- # on transfere la propriete
- # On verifie que le type du concept existant co.__class__ est un sur type de celui attendu
+ # Cas 3 : le concept est produit par la macro parente (self.parent)
+ # on transfere la propriete du concept a la macro fille
+ # et on change le type du concept comme demande
+ # Au prealable, on verifie que le concept existant (co) est une instance
+ # possible du type demande (t)
# Cette règle est normalement cohérente avec les règles de vérification des mots-clés
- if not issubclass(t,co.__class__):
- raise AsException("Le type du concept produit %s devrait etre une sur classe de %s" %(co.__class__,t))
+ if not isinstance(co,t):
+ raise AsException("""
+Impossible de changer le type du concept produit (%s) en (%s).
+Le type actuel (%s) devrait etre une classe derivee du nouveau type (%s)""" % (co,t,co.__class__,t))
+ mcs=self.get_mcs_with_co(co)
+ if len(mcs) != 1:
+ raise AsException("""Erreur interne.
+Il ne devrait y avoir qu'un seul mot cle porteur du concept CO (%s)""" % co)
+ mcs=mcs[0]
+ if not CO in mcs.definition.type:
+ raise AsException("""Erreur interne.
+Impossible de changer le type du concept (%s). Le mot cle associe ne supporte pas CO mais seulement (%s)""" %(co,mcs.definition.type))
co.etape=self
- co.__class__ = t
+ # On ne change pas le type car il respecte la condition isinstance(co,t)
+ #co.__class__ = t
self.sdprods.append(co)
+
elif self.issubstep(co.etape):
- # Le concept est propriété d'une sous etape de self. Il doit etre considere
- # comme produit par la macro => ajout dans self.sdprods
+ # Cas 4 : Le concept est propriété d'une sous etape de la macro (self).
+ # On est deja passe par type_sdprod (Cas 3 ou 1).
+ # Il suffit de le mettre dans la liste des concepts produits (self.sdprods)
+ # Le type du concept et t doivent etre derives.
+ # Il n'y a aucune raison pour que la condition ne soit pas verifiee.
+ if not isinstance(co,t):
+ raise AsException("""Erreur interne.
+Le type demande (%s) et le type du concept (%s) devraient etre derives""" %(t,co.__class__))
self.sdprods.append(co)
+
else:
- # le concept est produit par une autre étape
+ # Cas 5 : le concept est produit par une autre étape
+ # On ne fait rien
return
def issubstep(self,etape):
# Il s'agit d'un concept de sortie de la macro. Il ne faut pas le créer
# Il faut quand meme appeler la fonction sd_prod si elle existe.
# get_type_produit le fait et donne le type attendu par la commande pour verification ultérieure.
- sdprod=etape.get_type_produit()
+ sdprod=etape.get_type_produit_brut()
sd=self.Outputs[nomsd]
# On verifie que le type du concept existant sd.__class__ est un sur type de celui attendu
# Cette règle est normalement cohérente avec les règles de vérification des mots-clés
-#@ MODIF N_MCCOMPO Noyau DATE 20/10/2004 AUTEUR DURAND C.DURAND
+#@ MODIF N_MCCOMPO Noyau DATE 21/03/2005 AUTEUR DURAND C.DURAND
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# On construit les sous entites presentes ou obligatoires
# 1- les entites présentes dans les arguments et dans la définition
# 2- les entités non présentes dans les arguments, présentes dans la définition avec un défaut
+ # Phase 1.1 : on traite d'abord les SIMP pour enregistrer les mots cles globaux
for k,v in self.definition.entites.items():
+ if v.label != 'SIMP':continue
if args.has_key(k) or v.statut=='o' :
#
# Creation par appel de la methode __call__ de la definition de la sous entite k de self
if args.has_key(k):
del args[k]
+ # Phase 1.2 : on traite les autres entites que SIMP
+ for k,v in self.definition.entites.items():
+ if v.label == 'SIMP':continue
+ if args.has_key(k) or v.statut=='o' :
+ #
+ # Creation par appel de la methode __call__ de la definition de la sous entite k de self
+ # si une valeur existe dans args ou est obligatoire (generique si toutes les
+ # entites ont l attribut statut )
+ #
+ objet=self.definition.entites[k](val=args.get(k,None),nom=k,parent=self)
+ mc_liste.append(objet)
+ if args.has_key(k):
+ del args[k]
+
# Phase 2:
# On construit les objets (en général, blocs) conditionnés par les mots-clés précédemment créés.
# A ce stade, mc_liste ne contient que les fils de l'objet courant
for cle in daux.keys():
dico[cle] = daux[cle]
return dico
+
+ def get_mcs_with_co(self,co):
+ """
+ Cette methode retourne l'objet MCSIMP fils de self
+ qui a le concept co comme valeur.
+ En principe, elle ne doit etre utilisee que pour les concepts
+ instances de la classe CO
+ """
+ l=[]
+ for child in self.mc_liste:
+ l.extend(child.get_mcs_with_co(co))
+ return l
+
+ def get_all_co(self):
+ """
+ Cette methode retourne tous les concepts instances de CO
+ """
+ l=[]
+ for child in self.mc_liste:
+ l.extend(child.get_all_co())
+ return l
-#@ MODIF N_MCLIST Noyau DATE 14/09/2004 AUTEUR MCOURTOI M.COURTOIS
+#@ MODIF N_MCLIST Noyau DATE 22/02/2005 AUTEUR DURAND C.DURAND
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
dico[cle] = daux[cle]
return dico
+ def get_mcs_with_co(self,co):
+ """
+ Cette methode retourne l'objet MCSIMP fils de self
+ qui a le concept co comme valeur.
+ En principe, elle ne doit etre utilisee que pour les concepts
+ instances de la classe CO
+ """
+ l=[]
+ for child in self.data:
+ l.extend(child.get_mcs_with_co(co))
+ return l
+
+ def get_all_co(self):
+ """
+ Cette methode retourne tous les concepts instances de CO
+ """
+ l=[]
+ for child in self.data:
+ l.extend(child.get_all_co())
+ return l
+
def copy(self):
"""
Réalise la copie d'une MCList
-#@ MODIF N_MCSIMP Noyau DATE 14/09/2004 AUTEUR MCOURTOI M.COURTOIS
+#@ MODIF N_MCSIMP Noyau DATE 22/02/2005 AUTEUR DURAND C.DURAND
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
from copy import copy
from Noyau.N_ASSD import ASSD,assd
+from Noyau.N_CO import CO
import N_OBJECT
class MCSIMP(N_OBJECT.OBJECT):
if len(l) > 0 :
dico[self.nom] = l
return dico
+
+ def get_mcs_with_co(self,co):
+ """
+ Cette methode retourne l'objet MCSIMP self s'il a le concept co
+ comme valeur.
+ """
+ lval=self.valeur
+ if type(self.valeur) not in (types.TupleType,types.ListType):
+ lval=(self.valeur,)
+ if co in lval:return [self,]
+ return []
+
+ def get_all_co(self):
+ """
+ Cette methode retourne la liste de tous les concepts co
+ associés au mot cle simple
+ """
+ lval=self.valeur
+ if type(self.valeur) not in (types.TupleType,types.ListType):
+ lval=(self.valeur,)
+ l=[]
+ for c in lval:
+ if isinstance(c,CO) or hasattr(c,"_etape"):l.append(c)
+ return l
#
#
# ======================================================================
-version = "7.4.0"
-date = "22/11/2004"
+version = "6.2.24"
+date = "15/03/2002"
-#@ MODIF V_MACRO_ETAPE Validation DATE 14/09/2004 AUTEUR MCOURTOI M.COURTOIS
+#@ MODIF V_MACRO_ETAPE Validation DATE 22/02/2005 AUTEUR DURAND C.DURAND
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
if self.state == 'unchanged' :
return self.valid
else:
- valid=self.valid_child()
+ valid=1
+ # On marque les concepts CO pour verification ulterieure de leur bonne utilisation
+ l=self.mark_CO()
+ # On verifie que les concepts CO sont bien passes par type_sdprod
+ for c in l:
+ if c.etape is self.parent:
+ # le concept est propriete de l'etape parent
+ # Il n'a pas ete transforme par type_sdprod
+ # Cette situation est interdite
+ # Pb: La macro-commande a passe le concept a une commande (macro ?) mal definie
+ if cr =='oui':
+ self.cr.fatal("Macro-commande mal definie : manque probablement appel a type_sdprod pour %s" % c.nom)
+ valid=0
+
+ valid=valid * self.valid_child()
valid=valid * self.valid_regles(cr)
if self.reste_val != {}:
-#@ MODIF V_MCSIMP Validation DATE 20/09/2004 AUTEUR DURAND C.DURAND
+#@ MODIF V_MCSIMP Validation DATE 22/02/2005 AUTEUR DURAND C.DURAND
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
if self.definition.val_min == '**' and self.definition.val_max == '**':
# L'intervalle est infini, on ne fait pas de test
return 1
- #if type(self.valeur) in (types.ListType,types.TupleType) :
if type(self.valeur) == types.TupleType and not self.valeur[0] in ('RI','MP') or type(self.valeur) == types.ListType:
# Cas d'une liste de valeurs
test = 1
return 1
else :
# on est dans le cas d'un ensemble discret de valeurs possibles (into)
- #if type(self.valeur) in (types.ListType,types.TupleType) :
if type(self.valeur) == types.TupleType and not self.valeur[0] in ('RI','MP') or type(self.valeur) == types.ListType:
# Cas d'une liste de valeur
for e in self.valeur:
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
+ Retourne 1 si objet est une instance de la classe classe, 0 sinon
"""
if type(objet) != types.InstanceType :
- return 0
- if not objet.__class__ == classe and not issubclass(objet.__class__,classe):
return 0
- else:
+
+ if isinstance(objet,classe) :
+ # On accepte les instances de la classe et des classes derivees
return 1
+ return 0
+
def compare_type(self,valeur,type_permis):
"""
Fonction booléenne qui retourne 1 si valeur est du type type_permis, 0 sinon
