--- /dev/null
+tiny:
+ env PYTHONPATH=`pwd`:`pwd`/..:`pwd`/../Aster epydoc -n EFICASV1.5 --show-imports -o tiny_api \
+ ../Aster/prefs.py \
+ ../Noyau/*.py \
+ ../Validation/*.py \
+ ../Ihm/*.py \
+ ../Extensions/*.py \
+ ../Accas/*.py \
+ ../Editeur/*.py \
+ ../generator/*.py \
+ ../convert/*.py \
+ ../convert/Parserv5/__init__.py \
+ ../convert/Parserv5/conv.py \
+ ../AIDE/__init__.py ../AIDE/aide_gui.py ../AIDE/aide_objets.py ../AIDE/viewer.py \
+ ../Tools/*.py \
+ ../Tools/*/*.py \
+
--- /dev/null
+from Pmw import *
"""
Sauvegarde le JDC courant.
Retourne 1 si la sauvegarde s'est bien faite, 0 sinon.
- Si echo = 'oui' : interactif (l'utilisateur donne le nom sous lequel il
+ - Si echo = 'oui' : interactif (l'utilisateur donne le nom sous lequel il
veut sauver le JDC
- Si echo = 'non' : muet (sauvegarde le JDC dans JDC.procedure)
+ - Si echo = 'non' : muet (sauvegarde le JDC dans JDC.procedure)
"""
if not hasattr(self,'JDC') : return 0
format=self.appli.format_fichier.get()
def visuJDC_py(self):
"""
Méthode permettant d'afficher dans une fenêtre à part l'écho au
- format python du jdc courant
+ format python du jdc courant
"""
if not hasattr(self,'JDC') : return
jdc_fini = self.get_text_JDC('python')
def visuJDC(self):
"""
Méthode permettant d'afficher dans une fenêtre à part l'écho au
- format .comm ou .py du jdc courant
+ format .comm ou .py du jdc courant
"""
if not hasattr(self,'JDC') : return
titre = 'fichier '+ self.JDCName + ' à la syntaxe '+ self.code
"""
Cette methode a pour fonction de supprimer l'item passé en argument
des fils de l'item FACT qui est son pere
- item = item du MOCLE à supprimer du MOCLE père
- item.object = MCSIMP ou MCBLOC
+ - item = item du MOCLE à supprimer du MOCLE père
+ - item.object = MCSIMP ou MCBLOC
"""
if item.object.isoblig() :
self.appli.affiche_infos('Impossible de supprimer un mot-clé obligatoire ')
#
__version__="$Name: $"
-__Id__="$Id: componuplet.py,v 1.1.1.1 2002/03/26 09:08:46 eficas Exp $"
+__Id__="$Id: componuplet.py,v 1.2 2002/05/15 15:31:58 eficas Exp $"
#
myrepr = Repr()
def record_valeur(self,val=None,obj=None,mess='Valeur du mot-cl\351 enregistr\351e'):
"""
Enregistre val comme valeur de self.node.item.object SANS faire de
- test de validit\351
+ test de validité
"""
obj.set_valeur(val,evaluation='non')
self.parent.appli.affiche_infos(mess)
def valid_valeur(self,e,obj=None,mess='Valeur du mot-cl\351 enregistr\351e'):
"""
Enregistre val comme valeur de self.node.item.object avec
- test de validit\351
+ test de validité
"""
valeur=e.widget.get()
e.widget.delete(0,Tkinter.END)
"""
Lit ce que l'utilisateur a saisi dans self.entry et cherche à
l'évaluer :
- - si la valeur est acceptable, elle est ajoutée dans la liste des valeurs
- - sinon elle est refusée
+ - si la valeur est acceptable, elle est ajoutée dans la liste des valeurs
+ - sinon elle est refusée
"""
min,max = self.node.item.GetMinMax()
if name != None :
Provides a splash screen. Usage:
Subclass and override 'CreateWidgets()'
In constructor of main window/application call
- - S = SplashScreen(main=self) (if caller is Toplevel)
- - S = SplashScreen(main=self.master) (if caller is Frame)
- - S.quit() after you are done creating your widgets etc.
+ - S = SplashScreen(main=self) (if caller is Toplevel)
+ - S = SplashScreen(main=self.master) (if caller is Frame)
+ - S.quit() after you are done creating your widgets etc.
"""
def __init__(self, master=None,**args):
Toplevel.__init__(self, master, relief='groove',
#
__version__="$Name: $"
-__Id__="$Id: treewidget.py,v 1.11 2003/03/07 16:17:12 eficas Exp $"
+__Id__="$Id: treewidget.py,v 1.12 2003/03/10 17:24:43 eficas Exp $"
#
Fonte_Standard = fontes.standard
def update(self,event=None) :
""" Classe Node :
Cette méthode est appelée pour demander l update d un noeud
- d'un jeu de commandes
- Cette demande est transmise au noeud racine (le JDC) qui update
- tout l arbre représentant le jeu de commandes
- Pendant cette mise à jour, on appelle la méthode isvalid qui
- fera l update de tous les objets déclarés modifiés lors des
- actions précédentes
- La métode isvalid est en général appelée par l intermédiaire de
- update_icone -> geticonimage -> GetIconName
+ d'un jeu de commandes
+ Cette demande est transmise au noeud racine (le JDC) qui update
+ tout l arbre représentant le jeu de commandes
+ Pendant cette mise à jour, on appelle la méthode isvalid qui
+ fera l update de tous les objets déclarés modifiés lors des
+ actions précédentes
+ La métode isvalid est en général appelée par l intermédiaire de
+ update_icone -> geticonimage -> GetIconName
"""
self.racine.update_coords()
self.racine.trace_ligne()
"""
Initialise le répertoire des catalogues développeurs (chemin d'accès donné
dans le fichier eficas.ini cad :
- - le crée s'il n'existe pas encore
- - copie dedans les 3 fichiers nécessaires :
+ - le crée s'il n'existe pas encore
+ - copie dedans les 3 fichiers nécessaires :
* __init__.py (pour que ce répertoire puisse être interprété comme un package)
* entete.py (pour réaliser les import nécessaires à l'interprétation des catalogues)
* declaration_concepts.py (idem)
- - crée le fichier cata_developpeur.py qui sera par la suite importé
+ - crée le fichier cata_developpeur.py qui sera par la suite importé
"""
try :
if not os.path.isdir(rep_goal) :
"""
Cette méthode a pour but de décommentariser l'objet courant,
cad de retourner un tuple contenant :
- - l'objet CMD associé
- - le nom de la sdprod éventuellement produite (sinon None)
+ - l'objet CMD associé
+ - le nom de la sdprod éventuellement produite (sinon None)
"""
# on récupère le contexte avant la commande commentarisée
context_ini = self.jdc.get_contexte_avant(self)
Evalue les conditions de tous les blocs fils possibles
(en fonction du catalogue donc de la définition) de self et
retourne deux listes :
- - la première contient les noms des blocs à rajouter
- - la seconde contient les noms des blocs à supprimer
+ - la première contient les noms des blocs à rajouter
+ - la seconde contient les noms des blocs à supprimer
"""
return [],[]
Evalue les conditions de tous les blocs fils possibles
(en fonction du catalogue donc de la définition) de self et
retourne deux listes :
- - la première contient les noms des blocs à rajouter
- - la seconde contient les noms des blocs à supprimer
+ - la première contient les noms des blocs à rajouter
+ - la seconde contient les noms des blocs à supprimer
"""
return [],[]
"""
Retourne 1 si self est valide, 0 sinon
Un paramètre est considéré comme valide si :
- - il a un nom
- - il a une valeur
+ - il a un nom
+ - il a une valeur
"""
if self.nom == '' :
if cr == 'oui':
Evalue les conditions de tous les blocs fils possibles
(en fonction du catalogue donc de la définition) de self et
retourne deux listes :
- - la première contient les noms des blocs à rajouter
- - la seconde contient les noms des blocs à supprimer
+ - la première contient les noms des blocs à rajouter
+ - la seconde contient les noms des blocs à supprimer
"""
return [],[]
import traceback
# import modules Eficas
-import Accas
import interpreteur_formule
from Noyau.N_CR import CR
import parametre
class PARAMETRE_EVAL(parametre.PARAMETRE) :
"""
Cette classe permet de créer des objets de type PARAMETRE_EVAL
- cad des affectations directes évaluées dans le jeu de commandes
- (ex: a=EVAL('''10.*SQRT(25)'''))
+ cad des affectations directes évaluées dans le jeu de commandes (ex: a=EVAL('''10.*SQRT(25)'''))
qui sont interprétées par le parseur de fichiers Python.
Les objets ainsi créés constituent des paramètres évalués pour le jdc
"""
def __init__(self,nom,valeur=None):
# parent ne peut être qu'un objet de type JDC
+ import Accas
+ self.Accas_EVAL=Accas.EVAL
self.valeur = self.interprete_valeur(valeur)
self.val = valeur
self.nom = nom
d={}
val = string.strip(val)
if val[-1] == ';' : val = val[0:-1]
- d['EVAL'] = Accas.EVAL
+ d['EVAL'] = self.Accas_EVAL
try:
valeur = eval(val,{},d)
return valeur
def verif_parametre_eval(self,param=None,cr='non'):
"""
Vérifie la validité du paramètre EVAL passé en argument.
- Ce nouveau paramètre est passé sous la forme d'un tuple :
- (nom,valeur)
+ Ce nouveau paramètre est passé sous la forme d'un tuple : (nom,valeur)
Si aucun tuple passé, prend les valeurs courantes de l'objet
Retourne :
- un booléen, qui vaut 1 si EVAL licite, 0 sinon
"""
Retourne 1 si self est valide, 0 sinon
Un paramètre évalué est considéré comme valide si :
- - il a un nom
- - il a une valeur qui est interprétable par l'interpréteur de FORMULEs
+ - il a un nom
+ - il a une valeur qui est interprétable par l'interpréteur de FORMULEs
"""
resu,erreur= self.verif_parametre_eval(cr=cr)
return resu
"""
Cette méthode a pour fonction de donner un nom (nom) au concept
produit par l'étape (self).
- - si le concept n'existe pas, on essaye de le créer (à condition que l'étape soit valide ET non réentrante)
- - si il existe déjà, on le renomme et on répercute les changements dans les autres étapes
+ - si le concept n'existe pas, on essaye de le créer (à condition que l'étape soit valide ET non réentrante)
+ - si il existe déjà, on le renomme et on répercute les changements dans les autres étapes
Les valeurs de retour sont :
- 0 si le nommage n'a pas pu etre mené à son terme,
- 1 dans le cas contraire
+ - 0 si le nommage n'a pas pu etre mené à son terme,
+ - 1 dans le cas contraire
"""
if len(nom) > 8 and self.jdc.definition.code == 'ASTER':
return 0,"Nom de concept trop long (maxi 8 caractères)"
def get_sdprods(self,nom_sd):
"""
Fonction : retourne le concept produit par l etape de nom nom_sd
- s il existe sinon None
+ s il existe sinon None
"""
if self.sd:
if self.sd.nom == nom_sd:return self.sd
def supprime_sdprods(self):
"""
- Fonction:
+ Fonction:
Lors d'une destruction d'etape, detruit tous les concepts produits
Un opérateur n a qu un concept produit
Une procedure n'en a aucun
def delete_concept(self,sd):
"""
Inputs :
- sd=concept detruit
+ - sd=concept detruit
Fonction :
- Mettre a jour les mots cles de l etape et eventuellement
- le concept produit si reuse
- suite à la disparition du concept sd
- Seuls les mots cles simples MCSIMP font un traitement autre
- que de transmettre aux fils
+ Mettre a jour les mots cles de l etape et eventuellement
+ le concept produit si reuse
+ suite à la disparition du concept sd
+ Seuls les mots cles simples MCSIMP font un traitement autre
+ que de transmettre aux fils
"""
if self.reuse and self.reuse == sd:
self.sd=self.reuse=None
def replace_concept(self,old_sd,sd):
"""
Inputs :
- old_sd=concept remplace
- sd = nouveau concept
+ - old_sd=concept remplace
+ - sd = nouveau concept
Fonction :
- Mettre a jour les mots cles de l etape et eventuellement
- le concept produit si reuse
- suite au remplacement du concept old_sd
+ Mettre a jour les mots cles de l etape et eventuellement
+ le concept produit si reuse
+ suite au remplacement du concept old_sd
"""
if self.reuse and self.reuse == old_sd:
self.sd=self.reuse=sd
Construit le concept produit de l'opérateur. Deux cas
peuvent se présenter :
- - le parent n'est pas défini. Dans ce cas, l'étape prend en charge la création
- et le nommage du concept.
+ - le parent n'est pas défini. Dans ce cas, l'étape prend en charge la création
+ et le nommage du concept.
- - le parent est défini. Dans ce cas, l'étape demande au parent la création et
- le nommage du concept.
+ - le parent est défini. Dans ce cas, l'étape demande au parent la création et
+ le nommage du concept.
"""
if not self.isactif():return
def verif_formule(self,formule=None):
"""
Vérifie la validité de la formule passée en argument.
- Cette nouvelle formule est passée sous la forme d'un tuple :
- (nom,type_retourne,arguments,corps)
+ Cette nouvelle formule est passée sous la forme d'un tuple : (nom,type_retourne,arguments,corps)
Si aucune formule passée, prend les valeurs courantes de la formule
Retourne :
- un booléen, qui vaut 1 si formule licite, 0 sinon
def delete_concept(self,sd):
"""
Inputs :
- sd=concept detruit
+ - sd=concept detruit
Fonction :
- Mettre a jour les mots cles de l etape et eventuellement le concept produit si reuse
- suite à la disparition du concept sd
- Seuls les mots cles simples MCSIMP font un traitement autre que de transmettre aux fils,
- sauf les objets FORM_ETAPE qui doivent vérifier que le concept détruit n'est pas
- utilisé dans le corps de la fonction
+ Mettre a jour les mots cles de l etape et eventuellement le concept produit si reuse
+ suite à la disparition du concept sd
+ Seuls les mots cles simples MCSIMP font un traitement autre que de transmettre aux fils,
+ sauf les objets FORM_ETAPE qui doivent vérifier que le concept détruit n'est pas
+ utilisé dans le corps de la fonction
"""
self.init_modif()
def replace_concept(self,old_sd,sd):
"""
Inputs :
- old_sd=concept remplace
- sd = nouveau concept
+ - old_sd=concept remplace
+ - sd = nouveau concept
Fonction :
- Les objets FORM_ETAPE devraient vérifier que le concept remplacé n'est pas
- utilisé dans le corps de la fonction
+ Les objets FORM_ETAPE devraient vérifier que le concept remplacé n'est pas
+ utilisé dans le corps de la fonction
"""
self.init_modif()
def get_sd_apres_etape_avec_detruire(self,nom_sd,sd,etape,avec='non'):
"""
Cette méthode retourne la SD sd de nom nom_sd qui est éventuellement
- définie apres etape en tenant compte des concepts detruits
+ définie apres etape en tenant compte des concepts detruits
Si avec vaut 'non' exclut etape de la recherche
"""
ietap=self.etapes.index(etape)
def get_sd_apres_etape(self,nom_sd,etape,avec='non'):
"""
Cette méthode retourne la SD de nom nom_sd qui est éventuellement
- définie apres etape
+ définie apres etape
Si avec vaut 'non' exclut etape de la recherche
"""
ietap=self.etapes.index(etape)
def get_sd_autour_etape(self,nom_sd,etape,avec='non'):
"""
Fonction: retourne la SD de nom nom_sd qui est éventuellement
- définie avant ou apres etape
+ définie avant ou apres etape
Permet de vérifier si un concept de meme nom existe dans le périmètre
d'une étape
Si avec vaut 'non' exclut etape de la recherche
Cette méthode ajoute etape dans la liste
des etapes self.etapes et retourne l identificateur d'étape
fourni par l appel a g_register
+
A quoi sert editmode ?
- - Si editmode vaut 1, on est en mode edition de JDC. On cherche
- à enregistrer une étape que l'on a créée avec eficas (en passant
- par addentite) auquel cas on ne veut récupérer que son numéro
- d'enregistrement et c'est addentité qui l'enregistre dans
- self.etapes à la bonne place...
- - Si editmode vaut 0, on est en mode relecture d'un fichier de
- commandes et on doit enregistrer l'étape à la fin de self.etapes
- (dans ce cas l'ordre des étapes est bien l'ordre chronologique
- de leur création )
+ - Si editmode vaut 1, on est en mode edition de JDC. On cherche
+ à enregistrer une étape que l'on a créée avec eficas (en passant
+ par addentite) auquel cas on ne veut récupérer que son numéro
+ d'enregistrement et c'est addentité qui l'enregistre dans
+ self.etapes à la bonne place...
+ - Si editmode vaut 0, on est en mode relecture d'un fichier de
+ commandes et on doit enregistrer l'étape à la fin de self.etapes
+ (dans ce cas l'ordre des étapes est bien l'ordre chronologique
+ de leur création )
"""
if not self.editmode:
self.etapes.append(etape)
def delete_concept(self,sd):
"""
Inputs :
- sd=concept detruit
+ - sd=concept detruit
Fonction :
- Mettre a jour les etapes du JDC suite à la disparition du
- concept sd
- Seuls les mots cles simples MCSIMP font un traitement autre
- que de transmettre aux fils
+ Mettre a jour les etapes du JDC suite à la disparition du
+ concept sd
+ Seuls les mots cles simples MCSIMP font un traitement autre
+ que de transmettre aux fils
"""
for etape in self.etapes :
etape.delete_concept(sd)
def get_sdprods(self,nom_sd):
"""
Fonction : retourne le concept produit par l etape de nom nom_sd
- s il existe sinon None
+ s il existe sinon None
"""
if self.sd and self.sd.nom == nom_sd :return self.sd
for co in self.sdprods:
def supprime_sdprods(self):
"""
Fonction:
- Lors d'une destruction d'etape, detruit tous les concepts produits
- Un opérateur n a qu un concept produit
- Une procedure n'en a aucun
- Une macro en a en général plus d'un
+ Lors d'une destruction d'etape, detruit tous les concepts produits
+ Un opérateur n a qu un concept produit
+ Une procedure n'en a aucun
+ Une macro en a en général plus d'un
"""
if not self.is_reentrant() :
# l'étape n'est pas réentrante
Construit le concept produit de l'opérateur. Deux cas
peuvent se présenter :
- - le parent n'est pas défini. Dans ce cas, l'étape prend en charge
- la création et le nommage du concept.
+ - le parent n'est pas défini. Dans ce cas, l'étape prend en charge
+ la création et le nommage du concept.
- - le parent est défini. Dans ce cas, l'étape demande au parent la
- création et le nommage du concept.
+ - le parent est défini. Dans ce cas, l'étape demande au parent la
+ création et le nommage du concept.
"""
if not self.isactif():return
def delete_concept(self,sd):
"""
Inputs :
- sd=concept detruit
+ - sd=concept detruit
Fonction :
- Mettre a jour les fils de l objet suite à la disparition du
- concept sd
- Seuls les mots cles simples MCSIMP font un traitement autre que
- de transmettre aux fils
+ Mettre a jour les fils de l objet suite à la disparition du
+ concept sd
+ Seuls les mots cles simples MCSIMP font un traitement autre que
+ de transmettre aux fils
"""
for child in self.mc_liste :
child.delete_concept(sd)
def replace_concept(self,old_sd,sd):
"""
Inputs :
- old_sd=concept remplace
- sd = nouveau concept
+ - old_sd=concept remplace
+ - sd = nouveau concept
Fonction :
- Mettre a jour les fils de l objet suite au remplacement du
- concept old_sd
+ Mettre a jour les fils de l objet suite au remplacement du
+ concept old_sd
"""
for child in self.mc_liste :
child.replace_concept(old_sd,sd)
Evalue les conditions de tous les blocs fils possibles
(en fonction du catalogue donc de la définition) de self
et retourne deux listes :
- - la première contient les noms des blocs à rajouter
- - la seconde contient les noms des blocs à supprimer
+ - la première contient les noms des blocs à rajouter
+ - la seconde contient les noms des blocs à supprimer
"""
liste_ajouts = []
liste_retraits = []
def delete_concept(self,sd):
"""
Inputs :
- sd=concept detruit
- Fonction :
- Mettre a jour les fils de l objet suite à la disparition
- du concept sd
- Seuls les mots cles simples MCSIMP font un traitement autre
- que de transmettre aux fils
+ - sd=concept detruit
+ Fonction : Mettre a jour les fils de l objet suite à la disparition
+ du concept sd
+ Seuls les mots cles simples MCSIMP font un traitement autre
+ que de transmettre aux fils
"""
for child in self.data :
child.delete_concept(sd)
def replace_concept(self,old_sd,sd):
"""
Inputs :
- old_sd=concept remplacé
- sd=nouveau concept
- Fonction :
- Mettre a jour les fils de l objet suite au remplacement
- du concept old_sd
+ - old_sd=concept remplacé
+ - sd=nouveau concept
+ Fonction : Mettre a jour les fils de l objet suite au remplacement
+ du concept old_sd
"""
for child in self.data :
child.replace_concept(old_sd,sd)
Evalue les conditions de tous les blocs fils possibles
(en fonction du catalogue donc de la définition) de self et
retourne deux listes :
- - la première contient les noms des blocs à rajouter
- - la seconde contient les noms des blocs à supprimer
+ - la première contient les noms des blocs à rajouter
+ - la seconde contient les noms des blocs à supprimer
"""
# Sans objet pour une liste de mots clés facteurs
return [],[]
def wait_assd_or_geom(self):
"""
Retourne 1 si le mot-clé simple attend un objet de type
- assd, ASSD, geom ou GEOM
+ assd, ASSD, geom ou GEOM
Retourne 0 dans le cas contraire
"""
for typ in self.definition.type:
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)
+ ou un EVAL: Retourne la valeur évaluée (ou None) et le test de réussite (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)
def delete_concept(self,sd):
"""
Inputs :
- sd=concept detruit
+ - sd=concept detruit
Fonction :
- Met a jour la valeur du mot cle simple suite à la disparition
- du concept sd
+ Met a jour la valeur du mot cle simple suite à la disparition
+ du concept sd
"""
if type(self.valeur) == types.TupleType :
if sd in self.valeur:
def replace_concept(self,old_sd,sd):
"""
Inputs :
- old_sd=concept remplacé
- sd=nouveau concept
+ - old_sd=concept remplacé
+ - sd=nouveau concept
Fonction :
- Met a jour la valeur du mot cle simple suite au remplacement
- du concept old_sd
+ Met a jour la valeur du mot cle simple suite au remplacement
+ du concept old_sd
"""
if type(self.valeur) == types.TupleType :
if old_sd in self.valeur:
def isMCList(self):
"""
- Retourne 1 si self est une MCList (liste de mots-clés),
- 0 sinon (défaut)
+ Retourne 1 si self est une MCList (liste de mots-clés), 0 sinon (défaut)
"""
return 0
Evalue les conditions de tous les blocs fils possibles
(en fonction du catalogue donc de la définition) de self et
retourne deux listes :
- - la première contient les noms des blocs à rajouter
- - la seconde contient les noms des blocs à supprimer
+ - la première contient les noms des blocs à rajouter
+ - la seconde contient les noms des blocs à supprimer
"""
return [],[]
def get_sdprods(self,nom_sd):
"""
Fonction : retourne le concept produit par l etape de nom nom_sd
- s il existe sinon None
+ s il existe sinon None
Une PROC ne produit aucun concept
"""
return None
def delete_concept(self,sd):
"""
Inputs :
- sd=concept detruit
+ - sd=concept detruit
Fonction :
- Mettre a jour les mots cles de l etape
- suite à la disparition du concept sd
- Seuls les mots cles simples MCSIMP font un traitement autre
- que de transmettre aux fils
+ Mettre a jour les mots cles de l etape
+ suite à la disparition du concept sd
+ Seuls les mots cles simples MCSIMP font un traitement autre
+ que de transmettre aux fils
"""
for child in self.mc_liste :
child.delete_concept(sd)
def replace_concept(self,old_sd,sd):
"""
Inputs :
- old_sd=concept remplacé
- sd=nouveau concept
+ - old_sd=concept remplacé
+ - sd=nouveau concept
Fonction :
- Mettre a jour les mots cles de l etape
- suite au remplacement du concept old_sd
+ Mettre a jour les mots cles de l etape
+ suite au remplacement du concept old_sd
"""
for child in self.mc_liste :
child.replace_concept(old_sd,sd)
Cette classe a deux attributs de classe :
- - class_instance qui indique la classe qui devra etre utilisée
+ - class_instance qui indique la classe qui devra etre utilisée
pour créer l'objet qui servira à controler la conformité d'un
bloc de mots-clés avec sa définition
- - label qui indique la nature de l'objet de définition (ici, BLOC)
+ - label qui indique la nature de l'objet de définition (ici, BLOC)
"""
class_instance = N_MCBLOC.MCBLOC
"""
Un bloc est caractérisé par les attributs suivants :
- - fr : chaine de caractere commentaire pour aide en ligne (en francais)
-
- - ang : chaine de caractere commentaire pour aide en ligne (en anglais)
-
- - regles : liste d'objets de type REGLE pour vérifier la cohérence des sous-objets
-
- - statut : obligatoire ('o') ou facultatif ('f')
-
- - condition : chaine de caractère evaluable par l'interpreteur Python
-
- - entites : dictionnaire contenant les sous-objets de self (mots-clés). La clé du dictionnaire
+ - fr : chaine de caractere commentaire pour aide en ligne (en francais)
+ - ang : chaine de caractere commentaire pour aide en ligne (en anglais)
+ - regles : liste d'objets de type REGLE pour vérifier la cohérence des sous-objets
+ - statut : obligatoire ('o') ou facultatif ('f')
+ - condition : chaine de caractère evaluable par l'interpreteur Python
+ - entites : dictionnaire contenant les sous-objets de self (mots-clés). La clé du dictionnaire
est le nom du mot-clé et la valeur l'objet de définition correspondant. Cet attribut
est initialisé avec l'argument args de la méthode __init__
def estvide(self):
"""
Retourne 1 si self ne contient aucun message grave (fatal ou exception) et
- aucun CR qui en contienne,
- 0 sinon
+ aucun CR qui en contienne, 0 sinon
"""
if self.crexception : return 0
if self.crfatal : return 0
Construit le concept produit de l'opérateur. Deux cas
peuvent se présenter :
- - le parent n'est pas défini. Dans ce cas, l'étape prend en charge la création
- et le nommage du concept.
+ - le parent n'est pas défini. Dans ce cas, l'étape prend en charge la création
+ et le nommage du concept.
- - le parent est défini. Dans ce cas, l'étape demande au parent la création et
- le nommage du concept.
+ - le parent est défini. Dans ce cas, l'étape demande au parent la création et
+ le nommage du concept.
"""
if not self.isactif():return
"""
Retourne le concept résultat de l'étape
Deux cas :
- cas 1 : sd_prod de oper n'est pas une fonction
+ - sd_prod de oper n'est pas une fonction
il s'agit d'une sous classe de ASSD
on construit le sd à partir de cette classe
et on le retourne
- cas 2 : il s'agit d'une fonction
+ - il s'agit d'une fonction
on l'évalue avec les mots-clés de l'étape (mc_liste)
on construit le sd à partir de la classe obtenue
et on le retourne
"""
Retourne le type du concept résultat de l'étape
Deux cas :
- cas 1 : sd_prod de oper n'est pas une fonction
+ - sd_prod de oper n'est pas une fonction
il s'agit d'une sous classe de ASSD
on retourne le nom de la classe
- cas 2 : il s'agit d'une fonction
- on l'évalue avec les mots-clés de l'étape (mc_liste)
+ - il s'agit d'une fonction
+ on l'évalue avec les mots-clés de l'étape (mc_liste)
et on retourne son résultat
"""
if type(self.definition.sd_prod) == types.FunctionType:
def reset_current_step(self):
"""
Methode utilisee par l'etape self qui remet son etape parent comme
- etape courante
+ etape courante
"""
#print "reset_current_step ",self.nom
#traceback.print_stack(limit=3,file=sys.stdout)
Cette classe a trois attributs de classe
- - class_instance qui indique la classe qui devra etre utilisée
- pour créer l'objet qui servira à controler la conformité d'un
- mot-clé facteur avec sa définition
-
- - list_instance
-
- - label qui indique la nature de l'objet de définition (ici, FACT)
+ - class_instance qui indique la classe qui devra etre utilisée
+ pour créer l'objet qui servira à controler la conformité d'un
+ mot-clé facteur avec sa définition
+ - list_instance
+ - label qui indique la nature de l'objet de définition (ici, FACT)
"""
class_instance = N_MCFACT.MCFACT
list_instance = N_MCLIST.MCList
"""
Un mot-clé facteur est caractérisé par les attributs suivants :
- - fr :
-
- - ang :
-
- - statut :
-
- - defaut :
-
- - regles
-
- - min
-
- - max
-
- - position
-
- - docu
+ - fr :
+ - ang :
+ - statut :
+ - defaut :
+ - regles
+ - min
+ - max
+ - position
+ - docu
"""
N_ENTITE.ENTITE.__init__(self,validators)
# Initialisation des attributs
MCFACT soit une liste de type MCLIST.
La creation d un mot cle facteur depend de son statut
- Si statut ='o' il est obligatoire
- Si statut == 'd' il est facultatif mais ses sous mots cles avec
+ - Si statut ='o' il est obligatoire
+ - Si statut == 'd' il est facultatif mais ses sous mots cles avec
defaut sont visibles
- Si statut == 'f' il est facultatif et ses sous mots avec defaut ne
+ - Si statut == 'f' il est facultatif et ses sous mots avec defaut ne
sont pas visibles
- Si statut == 'c' il est cache ???
- Si defaut != None, on utilise cette valeur pour calculer la valeur
- par defaut du mot cle facteur
+ - Si statut == 'c' il est cache ???
+ - Si defaut != None, on utilise cette valeur pour calculer la valeur
+ par defaut du mot cle facteur
"""
if val == None:
if self.defaut == None:
def create_sdprod(self,etape,nomsd):
"""
- Intention : Cette methode doit fabriquer le concept produit retourne
+ Intention : Cette methode doit fabriquer le concept produit retourne
par l'etape etape et le nommer.
Elle est appelée à l'initiative de l'etape
pendant le processus de construction de cette etape :
- methode __call__ de la classe CMD (OPER ou MACRO)
+ - methode __call__ de la classe CMD (OPER ou MACRO)
Ce travail est réalisé par le contexte supérieur
(etape.parent) car dans certains cas, le concept ne doit
pas etre fabriqué mais l'etape doit simplement utiliser
un concept préexistant.
- Cas 1 : etape.reuse != None : le concept est réutilisé
- Cas 2 : l'étape appartient à une macro qui a déclaré un
+ 1. etape.reuse != None : le concept est réutilisé
+ 2. l'étape appartient à une macro qui a déclaré un
concept de sortie qui doit etre produit par cette
etape.
Dans le cas du JDC, le deuxième cas ne peut pas se produire.
Attributs de classe :
- - class_instance qui indique la classe qui devra etre utilisée
+ - class_instance qui indique la classe qui devra etre utilisée
pour créer l'objet qui servira à controler la conformité
du jeu de commandes avec sa définition
- - label qui indique la nature de l'objet de définition (ici, JDC)
+ - label qui indique la nature de l'objet de définition (ici, JDC)
"""
class_instance = N_JDC.JDC
Cette classe a trois attributs de classe
- - class_instance qui indique la classe qui devra etre utilisée
+ - class_instance qui indique la classe qui devra etre utilisée
pour créer l'objet qui servira à controler la conformité d'un
macro-commande avec sa définition
- - label qui indique la nature de l'objet de définition (ici, MACRO)
+ - label qui indique la nature de l'objet de définition (ici, MACRO)
- - nommage qui est un module Python qui fournit la fonctionnalité de nommage
+ - nommage qui est un module Python qui fournit la fonctionnalité de nommage
et les attributs d'instance suivants :
- - nom : son nom
+ - nom : son nom
- - op : le numéro d'opérateur
+ - op : le numéro d'opérateur
- - sd_prod : le type de concept produit. C'est une classe ou une fonction qui retourne
+ - sd_prod : le type de concept produit. C'est une classe ou une fonction qui retourne
une classe
- - reentrant : vaut 'n' ou 'o'. Indique si l'opérateur est réentrant ou pas. Un opérateur
+ - reentrant : vaut 'n' ou 'o'. Indique si l'opérateur est réentrant ou pas. Un opérateur
réentrant peut modifier un concept d'entrée et le produire comme concept de sortie
- - repetable : vaut 'n' ou 'o'. Indique si l'opérateur est répetable ou pas. Un opérateur
+ - repetable : vaut 'n' ou 'o'. Indique si l'opérateur est répetable ou pas. Un opérateur
non répétable ne doit apparaitre qu'une fois dans une exécution. C'est du ressort
de l'objet gérant le contexte d'exécution de vérifier cette contrainte.
- - fr : commentaire associé en francais
+ - fr : commentaire associé en francais
- - ang : commentaire associé en anglais
+ - ang : commentaire associé en anglais
- - docu : clé de documentation associée
+ - docu : clé de documentation associée
- - regles : liste des règles associées
+ - regles : liste des règles associées
- - op_init : cet attribut vaut None ou une fonction. Si cet attribut ne vaut pas None, cette
+ - op_init : cet attribut vaut None ou une fonction. Si cet attribut ne vaut pas None, cette
fonction est exécutée lors des phases d'initialisation de l'étape associée.
- - niveau : indique le niveau dans lequel est rangé l'opérateur. Les opérateurs peuvent etre
+ - niveau : indique le niveau dans lequel est rangé l'opérateur. Les opérateurs peuvent etre
rangés par niveau. Ils apparaissent alors exclusivement dans leur niveau de rangement.
Si niveau vaut None, l'opérateur est rangé au niveau global.
- - entites : dictionnaire dans lequel sont stockés les sous entités de l'opérateur. Il s'agit
+ - entites : dictionnaire dans lequel sont stockés les sous entités de l'opérateur. Il s'agit
des entités de définition pour les mots-clés : FACT, BLOC, SIMP. Cet attribut
est initialisé avec args, c'est à dire les arguments d'appel restants.
- definition : objet portant les attributs de définition d'une étape
de type macro-commande. Il est initialisé par
- l'argument oper.
+ l'argument oper.
- reuse : indique le concept d'entrée réutilisé. Il se trouvera donc
en sortie si les conditions d'exécution de l'opérateur
Construit le concept produit de l'opérateur. Deux cas
peuvent se présenter :
- - le parent n'est pas défini. Dans ce cas, l'étape prend en charge
- la création et le nommage du concept.
+ - le parent n'est pas défini. Dans ce cas, l'étape prend en charge
+ la création et le nommage du concept.
- - le parent est défini. Dans ce cas, l'étape demande au parent la
- création et le nommage du concept.
+ - le parent est défini. Dans ce cas, l'étape demande au parent la
+ création et le nommage du concept.
"""
if not self.isactif():return
"""
Retourne le concept résultat d'une macro étape
La difference avec une etape ou une proc-etape tient a ce que
- le concept produit peut exister ou pas
+ le concept produit peut exister ou pas
Si sd_prod == None le concept produit n existe pas on retourne None
Deux cas :
- cas 1 : sd_prod n'est pas une fonction
+ - sd_prod n'est pas une fonction
il s'agit d'une sous classe de ASSD
on construit le sd à partir de cette classe
et on le retourne
- cas 2 : sd_prod est une fonction
- on l'évalue avec les mots-clés de l'étape (mc_liste)
+ - sd_prod est une fonction
+ on l'évalue avec les mots-clés de l'étape (mc_liste)
on construit le sd à partir de la classe obtenue
et on le retourne
"""
def get_type_produit(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)
+ les concepts produits "à droite" du signe égal (en entrée)
Deux cas :
- cas 1 : sd_prod de oper n'est pas une fonction
+ - sd_prod de oper n'est pas une fonction
il s'agit d'une sous classe de ASSD
on retourne le nom de la classe
- cas 2 : il s'agit d'une fonction
+ - il s'agit d'une fonction
on l'évalue avec les mots-clés de l'étape (mc_liste)
et on retourne son résultat
"""
def type_sdprod(self,co,t):
"""
Cette methode a pour fonction de typer le concept co avec le type t
- dans les conditions suivantes
- 1- co est un concept produit de self
- 2- co est un concept libre : on le type et on l attribue à self
+ dans les conditions suivantes
+ 1. co est un concept produit de self
+ 2. co est un concept libre : on le type et on l attribue à self
+
Elle enregistre egalement les concepts produits (on fait l hypothese
- que la liste sdprods a été correctement initialisee, vide probablement)
+ que la liste sdprods a été correctement initialisee, vide probablement)
"""
if not hasattr(co,'etape'):
# Le concept vaut None probablement. On ignore l'appel
def create_sdprod(self,etape,nomsd):
"""
- Intention : Cette methode doit fabriquer le concept produit retourne
+ Intention : Cette methode doit fabriquer le concept produit retourne
par l'etape etape et le nommer.
Elle est appelée à l'initiative de l'etape
pendant le processus de construction de cette etape : methode __call__
Ce travail est réalisé par le contexte supérieur (etape.parent)
car dans certains cas, le concept ne doit pas etre fabriqué mais
l'etape doit simplement utiliser un concept préexistant.
- Cas 1 : etape.reuse != None : le concept est réutilisé
- Cas 2 : l'étape appartient à une macro qui a déclaré un concept
- de sortie qui doit etre produit par cette etape.
+ - Cas 1 : etape.reuse != None : le concept est réutilisé
+ - Cas 2 : l'étape appartient à une macro qui a déclaré un concept
+ de sortie qui doit etre produit par cette etape.
"""
if self.Outputs.has_key(nomsd):
# Il s'agit d'un concept de sortie de la macro. Il ne faut pas le créer
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 non présents avec la valeur None
+ - ajouter tous les mots-clés globaux (attribut position = 'global'
+ et 'global_jdc')
- - ajouter tous les mots-clés globaux (attribut position = 'global'
- et 'global_jdc')
-
- ATTENTION : -- on ne remonte pas (semble en contradiction avec la
- programmation de la méthode get_valeur du bloc) les
- mots-clé fils d'un bloc au niveau du
- contexte car celà peut générer des erreurs.
+ ATTENTION : on ne remonte pas (semble en contradiction avec la
+ programmation de la méthode get_valeur du bloc) les
+ mots-clé fils d'un bloc au niveau du
+ contexte car celà peut générer des erreurs.
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.
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)
+ avec defaut. (Ce dernier cas n'est utilisé que dans le catalogue)
"""
for v in self.mc_liste:
if v.nom == name : return v
Elle ne peut etre instanciée.
Une sous classe doit obligatoirement implémenter les méthodes :
- - __init__
+ - __init__
"""
Cette classe a trois attributs de classe
- - class_instance qui indique la classe qui devra etre utilisée
+ - class_instance qui indique la classe qui devra etre utilisée
pour créer l'objet qui servira à controler la conformité d'un
opérateur avec sa définition
- - label qui indique la nature de l'objet de définition (ici, OPER)
+ - label qui indique la nature de l'objet de définition (ici, OPER)
- - nommage qui est un module Python qui fournit la fonctionnalité de nommage
+ - nommage qui est un module Python qui fournit la fonctionnalité de nommage
et les attributs d'instance suivants :
- - nom : son nom
+ - nom : son nom
- - op : le numéro d'opérateur
+ - op : le numéro d'opérateur
- - sd_prod : le type de concept produit. C'est une classe ou une fonction qui retourne
+ - sd_prod : le type de concept produit. C'est une classe ou une fonction qui retourne
une classe
- - reentrant : vaut 'n' ou 'o'. Indique si l'opérateur est réentrant ou pas. Un opérateur
+ - reentrant : vaut 'n' ou 'o'. Indique si l'opérateur est réentrant ou pas. Un opérateur
réentrant peut modifier un concept d'entrée et le produire comme concept de sortie
- - repetable : vaut 'n' ou 'o'. Indique si l'opérateur est répetable ou pas. Un opérateur
+ - repetable : vaut 'n' ou 'o'. Indique si l'opérateur est répetable ou pas. Un opérateur
non répétable ne doit apparaitre qu'une fois dans une exécution. C'est du ressort
de l'objet gérant le contexte d'exécution de vérifier cette contrainte.
- - fr : commentaire associé en francais
+ - fr : commentaire associé en francais
- - ang : commentaire associé en anglais
+ - ang : commentaire associé en anglais
- - docu : clé de documentation associée
+ - docu : clé de documentation associée
- - regles : liste des règles associées
+ - regles : liste des règles associées
- - op_init : cet attribut vaut None ou une fonction. Si cet attribut ne vaut pas None, cette
+ - op_init : cet attribut vaut None ou une fonction. Si cet attribut ne vaut pas None, cette
fonction est exécutée lors des phases d'initialisation de l'étape associée.
- - niveau : indique le niveau dans lequel est rangé l'opérateur. Les opérateurs peuvent etre
+ - niveau : indique le niveau dans lequel est rangé l'opérateur. Les opérateurs peuvent etre
rangés par niveau. Ils apparaissent alors exclusivement dans leur niveau de rangement.
Si niveau vaut None, l'opérateur est rangé au niveau global.
- - entites : dictionnaire dans lequel sont stockés les sous entités de l'opérateur. Il s'agit
+ - entites : dictionnaire dans lequel sont stockés les sous entités de l'opérateur. Il s'agit
des entités de définition pour les mots-clés : FACT, BLOC, SIMP. Cet attribut
est initialisé avec args, c'est à dire les arguments d'appel restants.
def make_objet(self,mc_list='oui'):
"""
Cette méthode crée l'objet ETAPE dont la définition est self sans
- l'enregistrer ni créer sa sdprod.
+ l'enregistrer ni créer sa sdprod.
Si l'argument mc_list vaut 'oui', elle déclenche en plus la construction
des objets MCxxx.
"""
Cette classe a deux attributs de classe
- - class_instance qui indique la classe qui devra etre utilisée
+ - class_instance qui indique la classe qui devra etre utilisée
pour créer l'objet qui servira à controler la conformité d'un
opérateur avec sa définition
- - label qui indique la nature de l'objet de définition (ici, PROC)
+ - label qui indique la nature de l'objet de définition (ici, PROC)
et les attributs d'instance suivants :
- - nom : son nom
+ - nom : son nom
- - op : le numéro d'opérateur
+ - op : le numéro d'opérateur
- - reentrant : vaut 'n' ou 'o'. Indique si l'opérateur est réentrant ou pas. Un opérateur
+ - reentrant : vaut 'n' ou 'o'. Indique si l'opérateur est réentrant ou pas. Un opérateur
réentrant peut modifier un concept d'entrée et le produire comme concept de sortie
- - repetable : vaut 'n' ou 'o'. Indique si l'opérateur est répetable ou pas. Un opérateur
+ - repetable : vaut 'n' ou 'o'. Indique si l'opérateur est répetable ou pas. Un opérateur
non répétable ne doit apparaitre qu'une fois dans une exécution. C'est du ressort
de l'objet gérant le contexte d'exécution de vérifier cette contrainte.
- - fr : commentaire associé en francais
+ - fr : commentaire associé en francais
- - ang : commentaire associé en anglais
+ - ang : commentaire associé en anglais
- - docu : clé de documentation associée
+ - docu : clé de documentation associée
- - regles : liste des règles associées
+ - regles : liste des règles associées
- - op_init : cet attribut vaut None ou une fonction. Si cet attribut ne vaut pas None, cette
+ - op_init : cet attribut vaut None ou une fonction. Si cet attribut ne vaut pas None, cette
fonction est exécutée lors des phases d'initialisation de l'étape associée.
- - niveau : indique le niveau dans lequel est rangé l'opérateur. Les opérateurs peuvent etre
+ - niveau : indique le niveau dans lequel est rangé l'opérateur. Les opérateurs peuvent etre
rangés par niveau. Ils apparaissent alors exclusivement dans leur niveau de rangement.
Si niveau vaut None, l'opérateur est rangé au niveau global.
- - entites : dictionnaire dans lequel sont stockés les sous entités de l'opérateur. Il s'agit
+ - entites : dictionnaire dans lequel sont stockés les sous entités de l'opérateur. Il s'agit
des entités de définition pour les mots-clés : FACT, BLOC, SIMP. Cet attribut
est initialisé avec args, c'est à dire les arguments d'appel restants.
def make_objet(self,mc_list='oui'):
"""
Cette méthode crée l'objet PROC_ETAPE dont la définition est self sans
- l'enregistrer ni créer sa sdprod.
+ l'enregistrer ni créer sa sdprod.
Si l'argument mc_list vaut 'oui', elle déclenche en plus la construction
des objets MCxxx.
"""
A la creation de l'objet regle on lui passe la liste des noms de mots cles concernes
- Exemple ::
+ Exemple::
- # Création de l'objet règle UNPARMI
- r=UNPARMI("INFO","AFFE")
- # Vérification de la règle r sur le dictionnaire passé en argument
- r.verif({"INFO":v1,"AFFE":v2)
+ # Création de l'objet règle UNPARMI
+ r=UNPARMI("INFO","AFFE")
+ # Vérification de la règle r sur le dictionnaire passé en argument
+ r.verif({"INFO":v1,"AFFE":v2)
"""
import types
et le deuxième un entier.
L'entier peut valoir 0 ou 1. -- s'il vaut 1, la règle est vérifiée
- s'il vaut 0, la règle n'est pas vérifiée et le texte joint contient
+ s'il vaut 0, la règle n'est pas vérifiée et le texte joint contient
un commentaire de la non validité.
"""
raise "NotImplemented : class REGLE should be derived"
Cette classe a deux attributs de classe
- - class_instance qui indique la classe qui devra etre utilisée
+ - class_instance qui indique la classe qui devra etre utilisée
pour créer l'objet qui servira à controler la conformité d'un
mot-clé simple avec sa définition
- - label qui indique la nature de l'objet de définition (ici, SIMP)
+ - label qui indique la nature de l'objet de définition (ici, SIMP)
"""
class_instance = N_MCSIMP.MCSIMP
"""
Un mot-clé simple est caractérisé par les attributs suivants :
- - type : cet attribut est obligatoire et indique le type de valeur attendue
+ - type : cet attribut est obligatoire et indique le type de valeur attendue
- - fr :
+ - fr :
- - ang :
+ - ang :
- - statut :
+ - statut :
- - into :
+ - into :
- - defaut :
+ - defaut :
- - min
+ - min
- - max
+ - max
- - homo
+ - homo
- - position
+ - position
- - val_min
+ - val_min
- - val_max
+ - val_max
- - docu
+ - docu
"""
N_ENTITE.ENTITE.__init__(self,validators)
# Initialisation des attributs
"""
Retourne un nom pour le concept resultat identifie par text
Pour obtenir ce nom il y a plusieurs possibilites :
- 1-text est un identificateur python c est le nom du concept
- 2-text est un element d une liste on construit le nom en
- evaluant la partie indice dans le contexte de l appelant d
+ 1. text est un identificateur python c est le nom du concept
+ 2. text est un element d une liste on construit le nom en
+ evaluant la partie indice dans le contexte de l appelant d
"""
l=re.split('([\[\]]+)',text)
#print l
class ENSEMBLE:
"""
La règle vérifie que si un mot-clé de self.mcs est present
- parmi les elements de args tous les autres doivent etre presents.
+ parmi les elements de args tous les autres doivent etre presents.
Ces arguments sont transmis à la règle pour validation sous la forme
d'une liste de noms de mots-clés ou d'un dictionnaire dont
"""
Cette méthode met à jour le concept produit en fonction des conditions initiales :
- 1- Il n'y a pas de concept retourné (self.definition.sd_prod == None)
+ - Il n'y a pas de concept retourné (self.definition.sd_prod == None)
- 2- Le concept retourné n existait pas (self.sd == None)
+ - Le concept retourné n existait pas (self.sd == None)
- 3- Le concept retourné existait. On change alors son type ou on le supprime
+ - Le concept retourné existait. On change alors son type ou on le supprime
En cas d'erreur (exception) on retourne un indicateur de validité de 0 sinon de 1
"""
class EXCLUS:
"""
La règle vérifie qu'un seul mot-clé de self.mcs est present
- parmi les elements de args.
+ parmi les elements de args.
Ces arguments sont transmis à la règle pour validation sous la forme
d'une liste de noms de mots-clés ou d'un dictionnaire dont
"""
Cette méthode met à jour le concept produit en fonction des conditions initiales :
- 1- Il n'y a pas de concept retourné (self.definition.sd_prod == None)
+ - Il n'y a pas de concept retourné (self.definition.sd_prod == None)
- 2- Le concept retourné n existait pas (self.sd == None)
+ - Le concept retourné n existait pas (self.sd == None)
- 3- Le concept retourné existait. On change alors son type ou on le supprime
+ - Le concept retourné existait. On change alors son type ou on le supprime
En cas d'erreur (exception) on retourne un indicateur de validité de 0 sinon de 1
"""
class MCBLOC(V_MCCOMPO.MCCOMPO):
"""
Cette classe a un attribut de classe :
-
- - txt_nat qui sert pour les comptes-rendus liés à cette classe
+ - txt_nat qui sert pour les comptes-rendus liés à cette classe
"""
txt_nat="Bloc :"
class MCFACT(V_MCCOMPO.MCCOMPO):
"""
Cette classe a un attribut de classe :
-
- - txt_nat qui sert pour les comptes-rendus liés à cette classe
+ - txt_nat qui sert pour les comptes-rendus liés à cette classe
"""
txt_nat="Mot cle Facteur :"
class MCList:
"""
Cette classe a deux attributs de classe :
-
- - CR qui sert à construire l'objet compte-rendu
-
- - txt_nat qui sert pour les comptes-rendus liés à cette classe
+ - CR qui sert à construire l'objet compte-rendu
+ - txt_nat qui sert pour les comptes-rendus liés à cette classe
"""
CR=N_CR.CR
class MCSIMP:
"""
COMMENTAIRE CCAR
- Cette classe est quasiment identique à la classe originale d'EFICAS
- a part quelques changements cosmétiques et des chagements pour la
- faire fonctionner de facon plus autonome par rapport à l'environnement
- EFICAS
+ Cette classe est quasiment identique à la classe originale d'EFICAS
+ a part quelques changements cosmétiques et des chagements pour la
+ faire fonctionner de facon plus autonome par rapport à l'environnement
+ EFICAS
- A mon avis, il faudrait aller plus loin et réduire les dépendances
- amont au strict nécessaire.
+ A mon avis, il faudrait aller plus loin et réduire les dépendances
+ amont au strict nécessaire.
- Est il indispensable de faire l'évaluation de la valeur dans le contexte
du jdc dans cette classe.
Cette méthode retourne un indicateur de validité de l'objet
de type MCSIMP
- - 0 si l'objet est invalide
-
- - 1 si l'objet est valide
+ - 0 si l'objet est invalide
+ - 1 si l'objet est valide
Le pramètre cr permet de paramétrer le traitement. Si cr == 'oui'
la méthode construit également un comte-rendu de validation
def verif_card(self,cr='non'):
"""
un mot-clé simple ne peut etre répété :
- la cardinalité ici s'entend par la vérification que le nombre d'arguments de self.valeur
- est bien compris entre self.min et self.max dans le cas où il s'agit d'une liste
+ la cardinalité ici s'entend par la vérification que le nombre d'arguments de self.valeur
+ est bien compris entre self.min et self.max dans le cas où il s'agit d'une liste
"""
card = 1
min=self.definition.min
def verif_type(self,val=None,cr='non'):
"""
- FONCTION :
+ FONCTION :
Cette methode verifie que le type de l'argument val est en conformite avec celui
qui est declare dans la definition du mot cle simple.
Elle a plusieurs modes de fonctionnement liés à la valeur de cr.
Si cr vaut 'oui' : elle remplit le compte-rendu self.cr sinon elle ne le remplit pas.
- PARAMETRE DE RETOUR :
+
+ PARAMETRE DE RETOUR :
Cette méthode retourne une valeur booléenne qui vaut 1 si le type de val est correct ou 0 sinon
"""
class PRESENT_ABSENT:
"""
La règle vérifie que si le premier mot-clé de self.mcs est present
- parmi les elements de args les autres mots clés de self.mcs
- doivent etre absents
+ parmi les elements de args les autres mots clés de self.mcs
+ doivent etre absents
Ces arguments sont transmis à la règle pour validation sous la forme
d'une liste de noms de mots-clés ou d'un dictionnaire dont
class PRESENT_PRESENT:
"""
La règle vérifie que si le premier mot-clé de self.mcs est present
- parmi les elements de args les autres doivent l'etre aussi
+ parmi les elements de args les autres doivent l'etre aussi
Ces arguments sont transmis à la règle pour validation sous la forme
d'une liste de noms de mots-clés ou d'un dictionnaire dont
La méthode readfile a pour fonction de lire un fichier dont le
nom est passé en argument de la fonction.
- convertisseur.readfile(nom_fichier)
+ - convertisseur.readfile(nom_fichier)
La méthode convert a pour fonction de convertir le fichier
préalablement lu dans un objet du format passé en argument.
- objet=convertisseur.convert(outformat)
+ - objet=convertisseur.convert(outformat)
Ce convertisseur supporte uniquement le format de sortie exec
Ses caractéristiques principales sont exposées dans 2 attributs
de classe :
-
- - extensions : qui donne une liste d'extensions de fichier préconisées
-
- - formats : qui donne une liste de formats de sortie supportés
+ - extensions : qui donne une liste d'extensions de fichier préconisées
+ - formats : qui donne une liste de formats de sortie supportés
"""
# Les extensions de fichier préconisées
extensions=('.ini','.conf')
La méthode readfile a pour fonction de lire un fichier dont le
nom est passé en argument de la fonction.
- convertisseur.readfile(nom_fichier)
+ - convertisseur.readfile(nom_fichier)
La méthode convert a pour fonction de convertir le fichier
préalablement lu dans un objet du format passé en argument.
- objet=convertisseur.convert(outformat)
+ - objet=convertisseur.convert(outformat)
Ce convertisseur supporte le format de sortie dict
Ses caractéristiques principales sont exposées dans 2 attributs
de classe :
-
- - extensions : qui donne une liste d'extensions de fichier préconisées
-
- - formats : qui donne une liste de formats de sortie supportés
+ - extensions : qui donne une liste d'extensions de fichier préconisées
+ - formats : qui donne une liste de formats de sortie supportés
"""
# Les extensions de fichier préconisées
extensions=('.pyth',)
La méthode readfile a pour fonction de lire un fichier dont le
nom est passé en argument de la fonction.
- convertisseur.readfile(nom_fichier)
+ - convertisseur.readfile(nom_fichier)
La méthode convert a pour fonction de convertir le fichier
préalablement lu dans un objet du format passé en argument.
- objet=convertisseur.convert(outformat)
+ - objet=convertisseur.convert(outformat)
Ce convertisseur supporte le format de sortie exec
Ses caractéristiques principales sont exposées dans 2 attributs
de classe :
-
- - extensions : qui donne une liste d'extensions de fichier préconisées
-
- - formats : qui donne une liste de formats de sortie supportés
+ - extensions : qui donne une liste d'extensions de fichier préconisées
+ - formats : qui donne une liste de formats de sortie supportés
"""
# Les extensions de fichier préconisées
extensions=('.py',)
"""
Cette classe sert à générer un objet PARSEUR_PYTHON qui réalise l'analyse d'un texte
représentant un JDC Python en distinguant :
- - les commentaires inter commandes
- - les affectations
- - les commandes
+ - les commentaires inter commandes
+ - les affectations
+ - les commandes
"""
pattern_commande = re.compile(r'^([A-Z][A-Z0-9_]+)([ \t\r\f\v]*)\(([\w\W]*)')
pattern_eval = re.compile(r'^(EVAL)([ \t\r\f\v]*)\(([\w\W]*)')
Ses caractéristiques principales sont exposées dans des attributs
de classe :
-
- - extensions : qui donne une liste d'extensions de fichier préconisées
+ - extensions : qui donne une liste d'extensions de fichier préconisées
"""
# Les extensions de fichier préconisées
def gener(self,obj,format='brut'):
"""
- Retourne une représentation du JDC obj sous une
- forme qui est paramétrée par format.
- Si format vaut 'brut', 'standard' ou 'beautifie', retourne le texte issu
- de generator
+ Retourne une représentation du JDC obj sous une forme qui est paramétrée par format.
+ Si format vaut 'brut', 'standard' ou 'beautifie', retourne le texte issu de generator
"""
liste= self.generator(obj)
if format == 'brut':
Ses caractéristiques principales sont exposées dans des attributs
de classe :
-
- - extensions : qui donne une liste d'extensions de fichier préconisées
+ - extensions : qui donne une liste d'extensions de fichier préconisées
"""
# Les extensions de fichier préconisées
Ses caractéristiques principales sont exposées dans des attributs
de classe :
-
- - extensions : qui donne une liste d'extensions de fichier préconisées
+ - extensions : qui donne une liste d'extensions de fichier préconisées
"""
# Les extensions de fichier préconisées
Ses caractéristiques principales sont exposées dans des attributs
de classe :
-
- - extensions : qui donne une liste d'extensions de fichier préconisées
+ - extensions : qui donne une liste d'extensions de fichier préconisées
"""
# Les extensions de fichier préconisées
Ses caractéristiques principales sont exposées dans des attributs
de classe :
-
- - extensions : qui donne une liste d'extensions de fichier préconisées
+ - extensions : qui donne une liste d'extensions de fichier préconisées
"""
# Les extensions de fichier préconisées
