- dico[v.nom]=v.get_valeur()
-
- # On rajoute tous les autres mots-clés locaux possibles avec la valeur
- # par défaut ou None
- # Pour les mots-clés facteurs, on ne traite que ceux avec statut défaut ('d')
- # et caché ('c')
- # On n'ajoute aucune information sur les blocs. Ils n'ont pas de défaut seulement
- # une condition.
- for k,v in self.definition.entites.items():
- if not dico.has_key(k):
- if v.label == 'SIMP':
- # Mot clé simple
- dico[k]=v.defaut
- elif v.label == 'FACT' :
- if v.statut in ('c','d') :
- # Mot clé facteur avec défaut ou caché provisoire
- dico[k]=v(val=None,nom=k,parent=self)
- # On demande la suppression des pointeurs arrieres
- # pour briser les eventuels cycles
- dico[k].supprime()
- else:
- dico[k]=None
- # A ce stade on a rajouté tous les mots-clés locaux possibles (fils directs) avec leur
- # valeur par défaut ou la valeur None
-
- # On rajoute les mots-clés globaux sans écraser les clés existantes
- dico_mc = self.recherche_mc_globaux()
- dico_mc.update(dico)
- dico=dico_mc
-
- return dico
-
- def cree_dict_condition(self,liste=[],condition=0):
- """
- Methode pour construire un contexte qui servira dans l'évaluation
- des conditions de présence de blocs. Si une commande a un concept
- produit réutilisé, on ajoute la clé 'reuse'
- """
- dico=self.cree_dict_valeurs(liste,condition=1)
- # On ajoute la cle "reuse" pour les MCCOMPO qui ont un attribut reuse. A destination
- # uniquement des commandes. Ne devrait pas etre dans cette classe mais dans une classe dérivée
- if not dico.has_key('reuse') and hasattr(self,'reuse'):
- dico['reuse']=self.reuse
- return dico
-
- def recherche_mc_globaux(self):
- """
- Retourne la liste des mots-clés globaux de l'étape à laquelle appartient self
- et des mots-clés globaux du jdc
- """
- etape = self.get_etape()
- if etape :
- dict_mc_globaux_fac = self.recherche_mc_globaux_facultatifs()
- dict_mc_globaux_fac.update(etape.mc_globaux)
- if self.jdc : dict_mc_globaux_fac.update(self.jdc.mc_globaux)
- return dict_mc_globaux_fac
- else :
- return {}
-
- def recherche_mc_globaux_facultatifs(self):
- """
- Cette méthode interroge la définition de self et retourne la liste des mots-clés fils
- directs de self de type 'global'
- """
- dico={}
- etape = self.get_etape()
- if not etape : return {}
- for k,v in etape.definition.entites.items():
- if v.label != 'SIMP' : continue
- if v.position != 'global' : continue
- if v.statut == 'o':continue
- obj = v(val=None,nom=k,parent=etape)
- dico[k]=obj
- return dico
-
- def supprime(self):
- """
- Méthode qui supprime toutes les références arrières afin que l'objet puisse
- etre correctement détruit par le garbage collector
- """
- N_OBJECT.OBJECT.supprime(self)
- for child in self.mc_liste :
- child.supprime()
-
- def __getitem__(self,key):
- """
- Cette méthode retourne la valeur d'un sous mot-clé (key)
- """
- return self.get_mocle(key)
-
- def get_mocle(self,key):
- """
- Retourne la valeur du sous mot-clé key
- Ce sous mot-clé peut exister, avoir une valeur par defaut ou etre
- dans un BLOC fils de self
- """
- # on cherche dans les mots cles presents, le mot cle de nom key
- # s'il est là on retourne sa valeur (méthode get_val)
- for child in self.mc_liste:
- if child.nom == key : return child.get_val()
- # Si on n a pas trouve de mot cle present on retourne le defaut
- # eventuel pour les mots cles accessibles dans la definition
- # a ce niveau
- try:
- d=self.definition.entites[key]
- if d.label == 'SIMP':
- return d.defaut
- elif d.label == 'FACT':
- # il faut construire les objets necessaires pour
- # evaluer les conditions des blocs eventuels (a faire)
- if d.statut == 'o' :return None
- if d.statut != 'c' and d.statut != 'd' :
- return None
- else :
- return d(val=None,nom=key,parent=self)
- except KeyError:
- # le mot cle n est pas defini a ce niveau
- pass
- # Si on a toujours rien trouve, on cherche dans les blocs presents
- # On suppose que tous les blocs possibles ont ete crees meme ceux
- # induits par un mot cle simple absent avec defaut (???)
- for mc in self.mc_liste :
- if not mc.isBLOC() : continue
- try:
- return mc.get_mocle(key)
- except:
- # On n a rien trouve dans ce bloc, on passe au suivant
- pass
- # On a rien trouve, le mot cle est absent.
- # On leve une exception
- raise IndexError,"Le mot cle %s n existe pas dans %s" % (key,self)
-
- def get_child(self,name,restreint = 'non'):
- """
- Retourne le fils de self de nom name ou None s'il n'existe pas
- Si restreint vaut oui : ne regarde que dans la mc_liste
- Si restreint vaut non : regarde aussi dans les entites possibles
- avec defaut
- (Ce dernier cas n'est utilisé que dans le catalogue)
- """
- for v in self.mc_liste:
- if v.nom == name : return v
- if restreint == 'non' :
+ return mc_liste
+
+ def cree_dict_valeurs(self, liste=[], condition=0):
+ """
+ Cette méthode crée un contexte (sous la forme d'un dictionnaire)
+ à partir des valeurs des mots clés contenus dans l'argument liste.
+ L'opération consiste à parcourir la liste (d'OBJECT) et à la
+ transformer en un dictionnaire dont les clés sont les noms des
+ mots clés et les valeurs dépendent du type d'OBJECT.
+ Ce dictionnaire servira de liste d'arguments d'appel pour les
+ fonctions sd_prod de commandes et ops de macros ou de contexte
+ d'évaluation des conditions de présence de BLOC.
+
+ Si l'argument condition de la méthode vaut 1, on ne
+ remonte pas les valeurs des mots clés contenus dans des blocs
+ pour eviter les bouclages.
+
+ Cette méthode réalise les opérations suivantes en plus de transformer
+ la liste en dictionnaire :
+
+ - ajouter tous les mots-clés non présents avec la valeur None
+ - ajouter tous les mots-clés globaux (attribut position = 'global'
+ et 'global_jdc')
+
+ L'argument liste est, en général, une mc_liste en cours de
+ construction, contenant les mots-clés locaux et les blocs déjà créés.
+
+ """
+ dico = {}
+ for v in liste:
+ if v.isBLOC():
+ # Si v est un BLOC, on inclut ses items dans le dictionnaire
+ # représentatif du contexte. Les blocs sont retournés par get_valeur
+ # sous la forme d'un dictionnaire : les mots-clés fils de blocs sont
+ # donc remontés au niveau du contexte.
+ if not condition:
+ dadd = v.get_valeur()
+ assert intersection_vide(dico, dadd)
+ dico.update(dadd)
+ else:
+ assert not v.nom in dico, "deja vu : %s" % v.nom
+ dico[v.nom] = v.get_valeur()
+
+ # On rajoute tous les autres mots-clés locaux possibles avec la valeur
+ # par défaut ou None
+ # Pour les mots-clés facteurs, on ne traite que ceux avec statut défaut ('d')
+ # et caché ('c')
+ # On n'ajoute aucune information sur les blocs. Ils n'ont pas de défaut seulement
+ # une condition.
+ # XXX remplacer le not has_key par un dico différent et faire dico2.update(dico)
+ # ce n'est qu'un pb de perf
+ for k, v in list(self.definition.entites.items()):
+ if not k in dico :
+ if v.label == 'SIMP':
+ # Mot clé simple
+ dico[k] = v.defaut
+ elif v.label == 'FACT':
+ if v.statut in ('c', 'd'):
+ # Mot clé facteur avec défaut ou caché provisoire
+ dico[k] = v(val=None, nom=k, parent=self)
+ # On demande la suppression des pointeurs arrieres
+ # pour briser les eventuels cycles
+ dico[k].supprime()
+ else:
+ dico[k] = None
+ # A ce stade on a rajouté tous les mots-clés locaux possibles (fils directs) avec leur
+ # valeur par défaut ou la valeur None
+
+ # On rajoute les mots-clés globaux sans écraser les clés existantes
+ dico_mc = self.recherche_mc_globaux()
+ dico_mc.update(dico)
+ dico = dico_mc
+
+ return dico
+
+ def cree_dict_toutes_valeurs(self):
+ """Semblable à `cree_dict_valeurs(liste=self.mc_liste)` en supprimant les
+ valeurs None."""
+ dico = self.cree_dict_valeurs(self.mc_liste, condition=0)
+ dico = dict([(k, v) for k, v in list(dico.items()) if v is not None])
+ return dico
+
+ def cree_dict_condition(self, liste=[], condition=0):
+ """
+ Methode pour construire un contexte qui servira dans l'évaluation
+ des conditions de présence de blocs. Si une commande a un concept
+ produit réutilisé, on ajoute la clé 'reuse'
+ """
+ dico = self.cree_dict_valeurs(liste, condition=1)
+ # On ajoute la cle "reuse" pour les MCCOMPO qui ont un attribut reuse. A destination
+ # uniquement des commandes. Ne devrait pas etre dans cette classe mais
+ # dans une classe dérivée
+ if not 'reuse' in dico and hasattr(self, 'reuse'):
+ dico['reuse'] = self.reuse
+ return dico
+
+ def recherche_mc_globaux(self):
+ """
+ Retourne la liste des mots-clés globaux de l'étape à laquelle appartient self
+ et des mots-clés globaux du jdc
+ """
+ etape = self.get_etape()
+ if etape:
+ dict_mc_globaux_fac = self.recherche_mc_globaux_facultatifs()
+ for k, v in list(etape.mc_globaux.items()):
+ dict_mc_globaux_fac[k] = v.get_valeur()
+ if self.jdc:
+ for k, v in list(self.jdc.mc_globaux.items()):
+ dict_mc_globaux_fac[k] = v.get_valeur()
+ return dict_mc_globaux_fac
+ else:
+ return {}
+
+ def recherche_mc_globaux_facultatifs(self):
+ """
+ Cette méthode interroge la définition de self et retourne la liste des mots-clés fils
+ directs de self de type 'global'.
+ position='global' n'est donc possible (et n'a de sens) qu'au plus haut niveau.
+ """
+ dico = {}
+ etape = self.get_etape()
+ if not etape:
+ return {}
+ for k, v in list(etape.definition.entites.items()):
+ if v.label != 'SIMP':
+ continue
+ if v.position != 'global':
+ continue
+ if v.statut == 'o':
+ continue
+ obj = v(val=None, nom=k, parent=etape)
+ dico[k] = obj.get_valeur()
+ return dico
+
+ def supprime(self):
+ """
+ Méthode qui supprime toutes les références arrières afin que l'objet puisse
+ etre correctement détruit par le garbage collector
+ """
+ N_OBJECT.OBJECT.supprime(self)
+ for child in self.mc_liste:
+ child.supprime()
+
+ def __getitem__(self, key):
+ """
+ Cette méthode retourne la valeur d'un sous mot-clé (key)
+ """
+ return self.get_mocle(key)
+
+ def get_mocle(self, key):
+ """
+ Retourne la valeur du sous mot-clé key
+ Ce sous mot-clé peut exister, avoir une valeur par defaut ou etre
+ dans un BLOC fils de self
+ """
+ # on cherche dans les mots cles presents, le mot cle de nom key
+ # s'il est là on retourne sa valeur (méthode get_val)
+ for child in self.mc_liste:
+ if child.nom == key:
+ return child.get_valeur()
+ # Si on n a pas trouve de mot cle present on retourne le defaut
+ # eventuel pour les mots cles accessibles dans la definition
+ # a ce niveau