-# -*- coding: iso-8859-15 -*-
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2017 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
"""
Ce module centralise les informations issues de la ligne de commande.
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.
+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
La session utilisera le catalogue V7.3 en mode debug.
"""
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import str
+except :
+ pass
try:
import optparse
from optparse import OptionValueError
from Tools.optparse import OptionValueError
import os,traceback
-import ConfigParser
-import prefs
+import six.moves.configparser
+import re
+
+from Extensions.i18n import tr
# 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).
+# Une etude est stockee dans un dictionnaire.
+# La cle "comm" du dictionnaire donne le nom du fichier de commandes principal
+# La cle (optionnelle) "pours" du dictionnaire donne les informations pour une poursuite
+# La valeur associee a la cle est un dictionnaire qui contient les informations sur
+# le nom du fichier de commandes de la poursuite (cle "comm"), une eventuelle poursuite
+# (cle "pours") et les includes (cles entieres associees a des noms de fichier).
#
#
#
-# Les informations (dictionnaire) associées au fichier de commandes en cours de traitement
-# sont stockées dans parser.values.current
+# Les informations (dictionnaire) associees au fichier de commandes en cours de traitement
+# sont stockees dans parser.values.current
# En general, il faut utiliser current et pas parser.values.studies car les informations
-# sont stockées hiérarchiquement
+# sont stockees hierarchiquement
#
-def check_comm(option, opt_str, value, parser):
+def checkComm(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)
+ raise OptionValueError(tr("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):
+def checkPoursuite(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)
+ raise OptionValueError(tr("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)
+ raise OptionValueError(tr("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):
+def checkInclude(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])
+ raise OptionValueError(tr("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)
+ raise OptionValueError(tr("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])
+ raise OptionValueError(tr("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):
+def checkJdc(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
+ les informations sur les fichiers poursuite et includes
+ definis 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
+ config : objet de la classe Configparser permettant de parser le fichier fich
+ jdc : nom de la section du fichier fich a analyser
"""
d_study={}
p=config.get(jdc,"poursuite")
if not config.has_option(p,"comm"):
- raise OptionValueError("jdc %s manque fichier comm dans section %s" % (fich,p))
+ raise OptionValueError(tr(" jdc %(v_1)s manque \
+ fichier comm dans section %(v_2)s", \
+ {'v_1': fich, 'v_2': 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))
+ raise OptionValueError(tr("jdc %(v_1)s, le fichier\
+ de commandes %(v_2)s n'existe pas", \
+ {'v_1': fich, 'v_2': comm}))
- pours=check_jdc(config,p,parser,fich)
+ pours=checkJdc(config,p,parser,fich)
pours["comm"]=comm
d_study["pours"]=pours
continue
unit=int(o)
# si le parametre est un entier, il s'agit d'un include
inc=config.get(jdc,o)
- except:
+ except EficasException:
continue
if not os.path.isfile(inc):
- raise OptionValueError("jdc %s fichier include %s, %s n'existe pas" % (fich,unit,inc))
+ raise OptionValueError(tr(" jdc %(v_1)s \
+ fichier include %(v_2)s, %(v_3)s \
+ n'existe pas", \
+ {'v_1': fich, 'v_2': unit, 'v_3': inc}))
d_study[unit]=inc
return d_study
-def check_fich(option, opt_str, fich, parser):
+def checkFich(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
+ fich : nom du fichier .ini donne 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)
+ raise OptionValueError(tr(" le fichier jdc %s n'existe pas", str(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 = six.moves.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(u"jdc","jdc"):
+ raise OptionValueError(tr(" jdc %s manque option jdc dans section jdc", str(fich)))
+ jdc=config.get(u"jdc","jdc")
if not config.has_option(jdc,"comm"):
- raise OptionValueError("jdc %s manque fichier comm dans section %s" % (fich,jdc))
+ raise OptionValueError(tr(" jdc %(v_1)s manque fichier comm \
+ dans section %(v_2)s", {'v_1': fich, 'v_2': 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))
+ raise OptionValueError(tr("jdc %(v_1)s, le fichier de commandes \
+ %(v_2)s n'existe pas", {'v_1': fich, 'v_2': comm}))
parser.values.comm.append(comm)
- d_study=check_jdc(config,jdc,parser,fich)
+ d_study=checkJdc(config,jdc,parser,fich)
d_study["comm"]=comm
parser.values.studies.append(d_study)
-def print_pours(d_pours,dec=''):
+def printPours(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
+ for k,v in list(d_pours.items()):
+ if k in (u"pours","comm"):continue
+ print(( tr("%(v_1)s include %(v_2)s : %(v_3)s", {'v_1': str(dec), 'v_2': str(k), 'v_3': str(v)})))
- if d_pours.has_key("pours"):
+ if "pours" in d_pours:
# Description de la poursuite
- print dec+" fichier poursuite:",d_pours["pours"]["comm"]
- print_pours(d_pours["pours"],dec=dec+"++")
+ print((tr("%(v_1)s fichier poursuite: %(v_2)s", {'v_1': dec, 'v_2': d_pours["pours"]["comm"]})))
+ printPours(d_pours["pours"],dec=dec+"++")
-def print_d_env():
- #print d_env
+def printDEnv():
if d_env.studies is None:return
for study in d_env.studies:
- print "nom etude:",study["comm"]
- print_pours(study,dec="++")
- print
+ print((tr("nom etude : %s", study["comm"])))
+ printPours(study,dec="++")
-def create_parser():
+def createparser():
# creation du parser des options de la ligne de commande
- parser=optparse.OptionParser(usage="usage: %prog [options]",version="%prog 1.8")
+ #import prefs
+ parser=optparse.OptionParser(usage=tr("utilisation : %prog [options]"), version="%prog 1.13")
+
+ parser.add_option(u"-j","--jdc",dest="comm",type='string',
+ action="callback",callback=checkComm,
+ help=tr("nom du fichier de commandes"))
+
+ parser.add_option(u"-p","--poursuite", type="string",dest="pours",
+ action="callback", callback=checkPoursuite,
+ help=tr("nom du fichier poursuite"))
- parser.add_option("-j","--jdc",dest="comm",type='string',
- action="callback",callback=check_comm,
- help="nom du fichier de commandes")
+ parser.add_option(u"-i","--include",
+ action="callback", callback=checkInclude,
+ nargs=2, help=tr("numero d'unite suivi du nom du fichier include"))
- parser.add_option("-p","--poursuite", type="string",dest="pours",
- action="callback", callback=check_poursuite,
- help="nom du fichier poursuite")
+ parser.add_option(u"-f","--fich", type="string",dest="fich",
+ action="callback", callback=checkFich,
+ help=tr("fichier decrivant une etude"))
- 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(u"-c","--cata", action="store", type="string",dest="cata",
+ help=tr("version de catalogue a utiliser"))
- parser.add_option("-f","--fich", type="string",dest="fich",
- action="callback", callback=check_fich,
- help="fichier decrivant une etude")
+ parser.add_option(u"-v","--version_cata", action="store", type="string",dest="version_cata",
+ help=tr("version de catalogue a utiliser"))
- parser.add_option("-c","--cata", action="store", type="string",dest="cata",
- help="version de catalogue a utiliser")
- parser.add_option("-k","--kode", action="store", type="string",dest="code",
- help="nom du code a utiliser",default=prefs.code)
+ parser.add_option(u"-k","--kode", action="store", type="string",dest="code",
+ help=tr("nom du code a utiliser"))
+
+ parser.add_option(u"-d","--debug", action="store", type="int",dest="debug",
+ help=tr("niveau de debug"))
+
+ parser.add_option(u"-s","--schema", action="store", type="string",dest="ssCode",
+ help=tr("schema"))
+ # To handle locale information
+ parser.add_option("-l", "--locale", action="store", type="string", dest="locale",
+ help=tr("localisation de l'application, pour la traduction"))
- parser.add_option("-d","--debug", action="store", type="int",dest="debug",
- help="niveau de debug")
return parser
def parse(args):
- parser=create_parser()
+ parser=createparser()
(options,args)=parser.parse_args(args[1:])
if not hasattr(options,"studies"):
options.studies=[]
del parser.values.current
except:
pass
-
for file in args:
if os.path.isfile(file):
options.comm.append(file)
options.studies.append({"comm":file})
+ #print options.studies
+ elif len(args)==1 and (re.search('.comm',file) or re.search('.map',file) or re.search('.cas',file)):
+ try :
+ f=open(file,'w')
+ f.close()
+ except :
+ parser.error(tr("Nombre incorrect d'arguments"))
+ options.comm.append(file)
+ options.studies.append({"comm":file})
+ elif len(args) == 1 and options.locale:
+ print((tr("Localisation specifiee pour l'application.")))
else:
- parser.error("incorrect number of arguments")
+ parser.error(tr("Nombre incorrect d'arguments"))
global d_env
d_env=options
- #print_d_env()
+ #printDEnv()
return options
-def get_unit(d_study,appli):
+def getUnit(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
+ sur les fichiers poursuite et includes sous la forme adaptee
+ 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)
+ appli : objet application EFICAS (permet d'acceder aux services comme getSource)
"""
- return get_dunit(d_study,appli)
+ return getDunit(d_study,appli)
-def get_dunit(d_unit,appli):
+def getDunit(d_unit,appli):
d={}
- if d_unit.has_key("pours"):
+ if 'pours' in d_unit:
# on a une poursuite
comm=d_unit["pours"]["comm"]
- g=get_dunit(d_unit["pours"],appli)
- text=appli.get_source(comm)
+ g=getDunit(d_unit["pours"],appli)
+ text=appli.getSource(comm)
d[None]=comm,text,g
- for k,v in d_unit.items():
- if k in ("pours","comm"): continue
- text=appli.get_source(v)
+ for k,v in list(d_unit.items()):
+ if k in (u"pours","comm"): continue
+ text=appli.getSource(v)
d[k]=v,text,d
return d
