From 9b4a3f9e1b186a5e94945ba5df2c9689505cb1fc Mon Sep 17 00:00:00 2001 From: eficas <> Date: Wed, 20 Apr 2005 09:40:18 +0000 Subject: [PATCH] mise a jour Noyau+Validation v8.0.16 --- Noyau/N_ASSD.py | 4 +- Noyau/N_CO.py | 14 +++- Noyau/N_ETAPE.py | 41 +++--------- Noyau/N_MACRO_ETAPE.py | 128 +++++++++++++++++++++++++++++------- Noyau/N_MCCOMPO.py | 39 ++++++++++- Noyau/N_MCLIST.py | 23 ++++++- Noyau/N_MCSIMP.py | 27 +++++++- Noyau/properties.py | 4 +- Validation/V_MACRO_ETAPE.py | 18 ++++- Validation/V_MCSIMP.py | 15 ++--- 10 files changed, 238 insertions(+), 75 deletions(-) diff --git a/Noyau/N_ASSD.py b/Noyau/N_ASSD.py index 8950e8d9..cae723c5 100644 --- a/Noyau/N_ASSD.py +++ b/Noyau/N_ASSD.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -107,6 +107,8 @@ class ASSD: 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): diff --git a/Noyau/N_CO.py b/Noyau/N_CO.py index 134df574..3f7a3ac7 100644 --- a/Noyau/N_CO.py +++ b/Noyau/N_CO.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -40,3 +40,15 @@ class CO(ASSD): 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 + diff --git a/Noyau/N_ETAPE.py b/Noyau/N_ETAPE.py index 731d31f2..377ce752 100644 --- a/Noyau/N_ETAPE.py +++ b/Noyau/N_ETAPE.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -194,6 +194,12 @@ class ETAPE(N_MCCOMPO.MCCOMPO): 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 : @@ -206,11 +212,7 @@ class ETAPE(N_MCCOMPO.MCCOMPO): """ 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 @@ -345,33 +347,6 @@ class ETAPE(N_MCCOMPO.MCCOMPO): 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': [ , - ], - 'MODELE': [] } - """ - 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 diff --git a/Noyau/N_MACRO_ETAPE.py b/Noyau/N_MACRO_ETAPE.py index 57a4b8ef..1c680209 100644 --- a/Noyau/N_MACRO_ETAPE.py +++ b/Noyau/N_MACRO_ETAPE.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -36,6 +36,7 @@ import N_ETAPE from N_Exception import AsException import N_utils from N_utils import AsType +from N_CO import CO class MACRO_ETAPE(N_ETAPE.ETAPE): """ @@ -92,10 +93,12 @@ 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): """ @@ -131,7 +134,7 @@ class MACRO_ETAPE(N_ETAPE.ETAPE): 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 @@ -145,6 +148,17 @@ class MACRO_ETAPE(N_ETAPE.ETAPE): 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 @@ -163,6 +177,9 @@ class MACRO_ETAPE(N_ETAPE.ETAPE): """ 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: @@ -171,7 +188,7 @@ class MACRO_ETAPE(N_ETAPE.ETAPE): # 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() @@ -194,6 +211,13 @@ class MACRO_ETAPE(N_ETAPE.ETAPE): 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) @@ -206,16 +230,15 @@ class MACRO_ETAPE(N_ETAPE.ETAPE): 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 @@ -278,32 +301,87 @@ class MACRO_ETAPE(N_ETAPE.ETAPE): 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): @@ -353,7 +431,7 @@ class MACRO_ETAPE(N_ETAPE.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 diff --git a/Noyau/N_MCCOMPO.py b/Noyau/N_MCCOMPO.py index a587e0d7..51ad7960 100644 --- a/Noyau/N_MCCOMPO.py +++ b/Noyau/N_MCCOMPO.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -57,7 +57,9 @@ class MCCOMPO(N_OBJECT.OBJECT): # 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 @@ -75,6 +77,20 @@ class MCCOMPO(N_OBJECT.OBJECT): 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 @@ -378,3 +394,24 @@ class MCCOMPO(N_OBJECT.OBJECT): 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 diff --git a/Noyau/N_MCLIST.py b/Noyau/N_MCLIST.py index 7199fb54..6c7ab567 100644 --- a/Noyau/N_MCLIST.py +++ b/Noyau/N_MCLIST.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -141,6 +141,27 @@ class MCList(UserList.UserList): 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 diff --git a/Noyau/N_MCSIMP.py b/Noyau/N_MCSIMP.py index 54262d9b..7f19a7da 100644 --- a/Noyau/N_MCSIMP.py +++ b/Noyau/N_MCSIMP.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -31,6 +31,7 @@ import types 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): @@ -153,3 +154,27 @@ 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 diff --git a/Noyau/properties.py b/Noyau/properties.py index 1cb28aa2..f6bb7c46 100644 --- a/Noyau/properties.py +++ b/Noyau/properties.py @@ -19,6 +19,6 @@ # # # ====================================================================== -version = "7.4.0" -date = "22/11/2004" +version = "6.2.24" +date = "15/03/2002" diff --git a/Validation/V_MACRO_ETAPE.py b/Validation/V_MACRO_ETAPE.py index f5811f60..5c218615 100644 --- a/Validation/V_MACRO_ETAPE.py +++ b/Validation/V_MACRO_ETAPE.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -64,7 +64,21 @@ class MACRO_ETAPE(V_ETAPE.ETAPE): 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 != {}: diff --git a/Validation/V_MCSIMP.py b/Validation/V_MCSIMP.py index 97353645..4fd7e8f9 100644 --- a/Validation/V_MCSIMP.py +++ b/Validation/V_MCSIMP.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -189,7 +189,6 @@ class MCSIMP: 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 @@ -206,7 +205,6 @@ class MCSIMP: 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: @@ -302,16 +300,17 @@ class MCSIMP: 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 -- 2.39.2