1 # -*- coding: iso-8859-15 -*-
3 Ce module centralise les informations issues de la ligne de commande.
5 La ligne de commande est parsee avec l'aide du module python optparse.
6 Les options possibles sont : -c, -j, -p, -d, -i, -f comme definies ci-dessous.
8 Un exemple typique d'utilisation est :
9 >>> ./appli.py -c V7.3 -d 1 -j aa -i 11 iii -p ppp -i 22 ii -j bb -f ff
11 qui demande a l'application d'ouvrir trois jeux de commandes.
13 Le premier (aa) a un include (11,iii) et est la suite du fichier poursuite ppp
14 qui a lui meme un include (22,ii).
16 Le deuxieme bb est un jeu de commandes simple.
18 Le troisieme est decrit dans le fichier ff de type .ini
19 qui est parse par le module ConfigParser.
20 Chaque section du fichier decrit un jeu de commandes.
21 Un include est specifie par: numero logique=nom du fichier
22 Une poursuite est specifiee par: poursuite=reference a un jeu de commande
23 Cette reference correspond a un nom de section decrivant le jeu de commandes.
24 Le jeu de commandes maitre est donne par l'entree globale jdc dans la section jdc.
37 La session utilisera le catalogue V7.3 en mode debug.
42 from optparse import OptionValueError
44 from Tools import optparse
45 from Tools.optparse import OptionValueError
52 # Les valeurs decodees par optparse sont mises dans un objet dictionnaire-like.
53 # On l'utilise comme environnement de session.
56 # L'attribut "studies" de d_env est une liste dans laquelle on range les etudes de niveau global.
57 # Une étude est stockée dans un dictionnaire.
58 # La clé "comm" du dictionnaire donne le nom du fichier de commandes principal
59 # La clé (optionnelle) "pours" du dictionnaire donne les informations pour une poursuite
60 # La valeur associée à la clé est un dictionnaire qui contient les informations sur
61 # le nom du fichier de commandes de la poursuite (clé "comm"), une éventuelle poursuite
62 # (clé "pours") et les includes (clés entières associées à des noms de fichier).
66 # Les informations (dictionnaire) associées au fichier de commandes en cours de traitement
67 # sont stockées dans parser.values.current
68 # En general, il faut utiliser current et pas parser.values.studies car les informations
69 # sont stockées hiérarchiquement
72 def check_comm(option, opt_str, value, parser):
73 if not hasattr(parser.values,"studies"):
74 parser.values.studies=[]
76 if not os.path.isfile(value):
77 raise OptionValueError("le fichier de commandes %s n'existe pas" % value)
78 parser.values.comm.append(value)
79 d_study={"comm":value}
80 parser.values.current=d_study
81 parser.values.studies.append(d_study)
83 def check_poursuite(option, opt_str, value, parser):
84 if parser.values.comm is None:
85 raise OptionValueError("un fichier de commandes doit etre defini avant une poursuite %s" % value)
86 if not os.path.isfile(value):
87 raise OptionValueError("le fichier poursuite %s n'existe pas" % value)
88 #current : fichier de commandes en cours de traitement (dictionnaire des infos)
89 comm=parser.values.current
90 d_study={"comm":value}
92 parser.values.current=d_study
94 def check_include(option, opt_str, value, parser):
96 args=[int(parser.rargs[0]),parser.rargs[1]]
98 raise OptionValueError("include mal defini %s" % parser.rargs[0:2])
103 if parser.values.comm is None:
104 raise OptionValueError("un fichier de commandes doit etre defini avant un include %s" % args)
105 if not os.path.isfile(args[1]):
106 raise OptionValueError("le fichier include %s n'existe pas" % args[1])
108 comm=parser.values.current
109 comm[args[0]]=args[1]
112 def check_jdc(config,jdc,parser,fich):
114 Fonction : analyse une section de fichier .ini pour en extraire
115 les informations sur les fichiers poursuite et includes
116 définis dans cette section
118 parser : objet analyseur de la ligne de commande
119 fich : nom du fichier .ini en cours d'analyse
120 config : objet de la classe ConfigParser permettant de parser le fichier fich
121 jdc : nom de la section du fichier fich à analyser
125 for o in config.options(jdc):
127 p=config.get(jdc,"poursuite")
129 if not config.has_option(p,"comm"):
130 raise OptionValueError("jdc %s manque fichier comm dans section %s" % (fich,p))
131 comm=config.get(p,"comm")
132 if not os.path.isfile(comm):
133 raise OptionValueError("jdc %s, le fichier de commandes %s n'existe pas" % (fich,comm))
135 pours=check_jdc(config,p,parser,fich)
137 d_study["pours"]=pours
142 # si le parametre est un entier, il s'agit d'un include
143 inc=config.get(jdc,o)
146 if not os.path.isfile(inc):
147 raise OptionValueError("jdc %s fichier include %s, %s n'existe pas" % (fich,unit,inc))
152 def check_fich(option, opt_str, fich, parser):
154 Fonction : parse le fichier fich (format .ini)
156 option : option en cours de traitement
157 opt_str : chaine de caracteres utilisee par l'utilisateur
158 fich : nom du fichier .ini donné par l'utilisateur
159 parser : objet parseur des options de la ligne de commande
161 if not os.path.isfile(fich):
162 raise OptionValueError("le fichier jdc %s n'existe pas" % fich)
163 if parser.values.fich is None:
164 parser.values.fich=[]
165 parser.values.fich.append(fich)
166 if not hasattr(parser.values,"studies"):
167 parser.values.studies=[]
168 parser.values.comm=[]
169 config = ConfigParser.ConfigParser()
171 if not config.has_option("jdc","jdc"):
172 raise OptionValueError("jdc %s manque option jdc dans section jdc")
173 jdc=config.get("jdc","jdc")
175 if not config.has_option(jdc,"comm"):
176 raise OptionValueError("jdc %s manque fichier comm dans section %s" % (fich,jdc))
177 comm=config.get(jdc,"comm")
178 if not os.path.isfile(comm):
179 raise OptionValueError("jdc %s, le fichier de commandes %s n'existe pas" % (fich,comm))
180 parser.values.comm.append(comm)
182 d_study=check_jdc(config,jdc,parser,fich)
184 parser.values.studies.append(d_study)
186 def print_pours(d_pours,dec=''):
187 # Les fichiers includes d'abord
188 for k,v in d_pours.items():
189 if k in ("pours","comm"):continue
190 print dec+" include",k," :",v
192 if d_pours.has_key("pours"):
193 # Description de la poursuite
194 print dec+" fichier poursuite:",d_pours["pours"]["comm"]
195 print_pours(d_pours["pours"],dec=dec+"++")
199 if d_env.studies is None:return
200 for study in d_env.studies:
201 print "nom etude:",study["comm"]
202 print_pours(study,dec="++")
206 # creation du parser des options de la ligne de commande
207 parser=optparse.OptionParser(usage="usage: %prog [options]",version="%prog 1.9")
209 parser.add_option("-j","--jdc",dest="comm",type='string',
210 action="callback",callback=check_comm,
211 help="nom du fichier de commandes")
213 parser.add_option("-p","--poursuite", type="string",dest="pours",
214 action="callback", callback=check_poursuite,
215 help="nom du fichier poursuite")
217 parser.add_option("-i","--include",
218 action="callback", callback=check_include,
219 nargs=2, help="numero d'unite suivi du nom du fichier include")
221 parser.add_option("-f","--fich", type="string",dest="fich",
222 action="callback", callback=check_fich,
223 help="fichier decrivant une etude")
225 parser.add_option("-c","--cata", action="store", type="string",dest="cata",
226 help="version de catalogue a utiliser")
228 parser.add_option("-k","--kode", action="store", type="string",dest="code",
229 help="nom du code a utiliser",default=prefs.code)
231 parser.add_option("-d","--debug", action="store", type="int",dest="debug",
232 help="niveau de debug")
237 parser=create_parser()
238 (options,args)=parser.parse_args(args[1:])
239 if not hasattr(options,"studies"):
243 del parser.values.current
248 if os.path.isfile(file):
249 options.comm.append(file)
250 options.studies.append({"comm":file})
251 elif len(args)==1 and re.search('.comm',file):
256 parser.error("incorrect number of arguments")
257 options.comm.append(file)
258 options.studies.append({"comm":file})
260 parser.error("incorrect number of arguments")
267 def get_unit(d_study,appli):
269 Fonction : construit et retourne un dictionnaire contenant les informations
270 sur les fichiers poursuite et includes sous la forme adaptée
273 [None : nom_fichier, texte_source, unites_associees, # poursuite
274 numero_include : nom_fichier, texte_source, unites_associees, # include
277 d_study : dictionnaire de l'etude
278 appli : objet application EFICAS (permet d'acceder aux services comme get_source)
280 return get_dunit(d_study,appli)
282 def get_dunit(d_unit,appli):
284 if d_unit.has_key("pours"):
286 comm=d_unit["pours"]["comm"]
287 g=get_dunit(d_unit["pours"],appli)
288 text=appli.get_source(comm)
291 for k,v in d_unit.items():
292 if k in ("pours","comm"): continue
293 text=appli.get_source(v)