From 5fa1c251be4fa1de792538c76fee9e58d36f9ca0 Mon Sep 17 00:00:00 2001 From: eficas <> Date: Wed, 13 Apr 2005 15:00:52 +0000 Subject: [PATCH] ajout session.py --- Editeur/session.py | 275 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 275 insertions(+) create mode 100644 Editeur/session.py diff --git a/Editeur/session.py b/Editeur/session.py new file mode 100644 index 00000000..8a804547 --- /dev/null +++ b/Editeur/session.py @@ -0,0 +1,275 @@ +# -*- coding: iso-8859-15 -*- +""" +Ce module centralise les informations issues de la ligne de commande. + +La ligne de commande est parsee avec l'aide du module python optparse. +Les options possibles sont : -c, -j, -p, -d, -i, -f comme definies ci-dessous. + +Un exemple typique d'utilisation est : +>>> ./appli.py -c V7.3 -d 1 -j aa -i 11 iii -p ppp -i 22 ii -j bb -f ff + +qui demande a l'application d'ouvrir trois jeux de commandes. + +Le premier (aa) a un include (11,iii) et est la suite du fichier poursuite ppp +qui a lui meme un include (22,ii). + +Le deuxieme bb est un jeu de commandes simple. + +Le troisieme est decrit dans le fichier ff de type .ini +qui est parse par le module ConfigParser. +Chaque section du fichier decrit un jeu de commandes. +Un include est specifie par: numero logique=nom du fichier +Une poursuite est specifiee par: poursuite=reference a un jeu de commande +Cette reference correspond a un nom de section decrivant le jeu de commandes. +Le jeu de commandes maitre est donne par l'entree globale jdc dans la section jdc. + +Exemple: +[jdc] +jdc=a +[a] +comm=aa +poursuite=pours +11=iii +[pours] +comm=ppp +22=ii + +La session utilisera le catalogue V7.3 en mode debug. +""" + +import optparse +from optparse import OptionValueError +import traceback +import ConfigParser, os + +# Les valeurs decodees par optparse sont mises dans un objet dictionnaire-like. +# On l'utilise comme environnement de session. +d_env={} +# +# L'attribut "studies" de d_env est une liste dans laquelle on range les etudes de niveau global. +# Une étude est stockée dans un dictionnaire. +# La clé "comm" du dictionnaire donne le nom du fichier de commandes principal +# La clé (optionnelle) "pours" du dictionnaire donne les informations pour une poursuite +# La valeur associée à la clé est un dictionnaire qui contient les informations sur +# le nom du fichier de commandes de la poursuite (clé "comm"), une éventuelle poursuite +# (clé "pours") et les includes (clés entières associées à des noms de fichier). +# +# +# +# Les informations (dictionnaire) associées au fichier de commandes en cours de traitement +# sont stockées dans parser.values.current +# En general, il faut utiliser current et pas parser.values.studies car les informations +# sont stockées hiérarchiquement +# + +def check_comm(option, opt_str, value, parser): + if not hasattr(parser.values,"studies"): + parser.values.studies=[] + parser.values.comm=[] + if not os.path.isfile(value): + raise OptionValueError("le fichier de commandes %s n'existe pas" % value) + parser.values.comm.append(value) + d_study={"comm":value} + parser.values.current=d_study + parser.values.studies.append(d_study) + +def check_poursuite(option, opt_str, value, parser): + if parser.values.comm is None: + raise OptionValueError("un fichier de commandes doit etre defini avant une poursuite %s" % value) + if not os.path.isfile(value): + raise OptionValueError("le fichier poursuite %s n'existe pas" % value) + #current : fichier de commandes en cours de traitement (dictionnaire des infos) + comm=parser.values.current + d_study={"comm":value} + comm["pours"]=d_study + parser.values.current=d_study + +def check_include(option, opt_str, value, parser): + try: + args=[int(parser.rargs[0]),parser.rargs[1]] + except: + raise OptionValueError("include mal defini %s" % parser.rargs[0:2]) + + del parser.rargs[0] + del parser.rargs[0] + + if parser.values.comm is None: + raise OptionValueError("un fichier de commandes doit etre defini avant un include %s" % args) + if not os.path.isfile(args[1]): + raise OptionValueError("le fichier include %s n'existe pas" % args[1]) + + comm=parser.values.current + comm[args[0]]=args[1] + + +def check_jdc(config,jdc,parser,fich): + """ + Fonction : analyse une section de fichier .ini pour en extraire + les informations sur les fichiers poursuite et includes + définis dans cette section + + parser : objet analyseur de la ligne de commande + fich : nom du fichier .ini en cours d'analyse + config : objet de la classe ConfigParser permettant de parser le fichier fich + jdc : nom de la section du fichier fich à analyser + """ + d_study={} + + for o in config.options(jdc): + if o == "poursuite": + p=config.get(jdc,"poursuite") + + if not config.has_option(p,"comm"): + raise OptionValueError("jdc %s manque fichier comm dans section %s" % (fich,p)) + comm=config.get(p,"comm") + if not os.path.isfile(comm): + raise OptionValueError("jdc %s, le fichier de commandes %s n'existe pas" % (fich,comm)) + + pours=check_jdc(config,p,parser,fich) + pours["comm"]=comm + d_study["pours"]=pours + continue + + try: + unit=int(o) + # si le parametre est un entier, il s'agit d'un include + inc=config.get(jdc,o) + except: + continue + if not os.path.isfile(inc): + raise OptionValueError("jdc %s fichier include %s, %s n'existe pas" % (fich,unit,inc)) + d_study[unit]=inc + + return d_study + +def check_fich(option, opt_str, fich, parser): + """ + Fonction : parse le fichier fich (format .ini) + + option : option en cours de traitement + opt_str : chaine de caracteres utilisee par l'utilisateur + fich : nom du fichier .ini donné par l'utilisateur + parser : objet parseur des options de la ligne de commande + """ + if not os.path.isfile(fich): + raise OptionValueError("le fichier jdc %s n'existe pas" % fich) + if parser.values.fich is None: + parser.values.fich=[] + parser.values.fich.append(fich) + if not hasattr(parser.values,"studies"): + parser.values.studies=[] + parser.values.comm=[] + config = ConfigParser.ConfigParser() + config.read([fich]) + if not config.has_option("jdc","jdc"): + raise OptionValueError("jdc %s manque option jdc dans section jdc") + jdc=config.get("jdc","jdc") + + if not config.has_option(jdc,"comm"): + raise OptionValueError("jdc %s manque fichier comm dans section %s" % (fich,jdc)) + comm=config.get(jdc,"comm") + if not os.path.isfile(comm): + raise OptionValueError("jdc %s, le fichier de commandes %s n'existe pas" % (fich,comm)) + parser.values.comm.append(comm) + + d_study=check_jdc(config,jdc,parser,fich) + d_study["comm"]=comm + parser.values.studies.append(d_study) + +def print_pours(d_pours,dec=''): + # Les fichiers includes d'abord + for k,v in d_pours.items(): + if k in ("pours","comm"):continue + print dec+" include",k," :",v + + if d_pours.has_key("pours"): + # Description de la poursuite + print dec+" fichier poursuite:",d_pours["pours"]["comm"] + print_pours(d_pours["pours"],dec=dec+"++") + +def print_d_env(): + #print d_env + if d_env.studies is None:return + for study in d_env.studies: + print "nom etude:",study["comm"] + print_pours(study,dec="++") + print + +def create_parser(): + # creation du parser des options de la ligne de commande + parser=optparse.OptionParser(usage="usage: %prog [options]",version="%prog 1.8") + + parser.add_option("-j","--jdc",dest="comm",type='string', + action="callback",callback=check_comm, + help="nom du fichier de commandes") + parser.add_option("-p","--poursuite", type="string",dest="pours", + action="callback", callback=check_poursuite, + help="nom du fichier poursuite") + parser.add_option("-i","--include", + action="callback", callback=check_include, + nargs=2, help="numero d'unite suivi du nom du fichier include") + + parser.add_option("-f","--fich", type="string",dest="fich", + action="callback", callback=check_fich, + help="fichier decrivant une etude") + + parser.add_option("-c","--cata", action="store", type="string",dest="cata", + help="version de catalogue a utiliser") + + parser.add_option("-d","--debug", action="store", type="int",dest="debug", + help="niveau de debug") + + return parser + +def parse(args): + parser=create_parser() + (options,args)=parser.parse_args(args) + if not hasattr(options,"studies"): + options.studies=[] + options.comm=[] + try: + del parser.values.current + except: + pass + + if len(args) > 1: + for file in args[1:]: + if os.path.isfile(file): + options.comm.append(file) + options.studies.append({"comm":file}) + else: + parser.error("incorrect number of arguments") + + global d_env + d_env=options + #print_d_env() + return options + +def get_unit(d_study,appli): + """ + Fonction : construit et retourne un dictionnaire contenant les informations + sur les fichiers poursuite et includes sous la forme adaptée + pour EFICAS + [None : nom_fichier, texte_source, unites_associees, # poursuite + numero_include : nom_fichier, texte_source, unites_associees, # include + ...] + d_study : dictionnaire de l'etude + appli : objet application EFICAS (permet d'acceder aux services comme get_source) + """ + return get_dunit(d_study,appli) + +def get_dunit(d_unit,appli): + d={} + if d_unit.has_key("pours"): + # on a une poursuite + comm=d_unit["pours"]["comm"] + g=get_dunit(d_unit["pours"],appli) + text=appli.get_source(comm) + d[None]=comm,text,g + + for k,v in d_unit.items(): + if k in ("pours","comm"): continue + text=appli.get_source(v) + d[k]=v,text,d + + return d -- 2.39.2