# -*- coding: utf-8 -*-
# Copyright (C) 2008-2018 CEA/DEN
-#
+#
# 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, or (at your option) any later version.
-#
+#
# 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
import glob
import fnmatch
-import pprint as PP #pretty print
+import pprint as PP # pretty print
import src
debug = False
# get path to origin sources
-defaultdir = os.path.dirname(os.path.realpath(__file__))
+defaultdir = os.path.dirname(os.path.realpath(__file__))
# get path to salomeTools sources
satdir = defaultdir
-srcdir = os.path.join(satdir, 'src')
-cmdsdir = os.path.join(satdir, 'commands')
+srcdir = os.path.join(satdir, "src")
+cmdsdir = os.path.join(satdir, "commands")
# Make the src & commands package accessible from all code
sys.path.insert(0, satdir)
-sys.path.insert(0, srcdir) # TODO remove that
-sys.path.insert(0, cmdsdir) # TODO remove that
+sys.path.insert(0, srcdir) # TODO remove that
+sys.path.insert(0, cmdsdir) # TODO remove that
_user = src.architecture.get_user()
# wambeke is christian at home
-_developers = ["christian", "wambeke",] # ...who wants
+_developers = [
+ "christian",
+ "wambeke",
+] # ...who wants
+
def errPrint(aStr):
- """stderr to avoid write in html or xml file log message"""
- sys.stderr.write(aStr + '\n')
+ """stderr to avoid write in html or xml file log message"""
+ sys.stderr.write(aStr + "\n")
+
try:
- import unittestpy.HTMLTestRunner as HTST
+ import unittestpy.HTMLTestRunner as HTST
except:
- HTST = None
- errPrint("""
+ HTST = None
+ errPrint(
+ """
WARNING: no HTML output available.
try find 'test/unittestpy/HTMLTestRunner.py'.
-""")
+"""
+ )
try:
- import xmlrunner as XTST
+ import xmlrunner as XTST
except:
- XTST = None
- errPrint("""
+ XTST = None
+ errPrint(
+ """
WARNING: no XML output available for unittest.
try 'pip install unittest-xml-reporting'.
-""")
+"""
+ )
###################################################################
def locate(pattern, root=os.curdir):
- """
- Locate all files matching supplied filename pattern in and below
- supplied root directory.
- """
- result = []
- for path, dirs, files in os.walk(os.path.abspath(root)):
- for filename in fnmatch.filter(files, pattern):
- result.append( os.path.join(path, filename) )
- return result
+ """
+ Locate all files matching supplied filename pattern in and below
+ supplied root directory.
+ """
+ result = []
+ for path, dirs, files in os.walk(os.path.abspath(root)):
+ for filename in fnmatch.filter(files, pattern):
+ result.append(os.path.join(path, filename))
+ return result
+
def printEnv(search=""):
- """
- list all environment variables which name contains search string
- example:
- import AllTestLauncher as ATL
- ATL.printEnv("ROOT_")
- """
- env=os.environ
- for i in sorted(env):
- if search in i:
- print(i)
+ """
+ list all environment variables which name contains search string
+ example:
+ import AllTestLauncher as ATL
+ ATL.printEnv("ROOT_")
+ """
+ env = os.environ
+ for i in sorted(env):
+ if search in i:
+ print(i)
+
def grepInEnv(search=""):
- """
- list all environment variables which contains search string
- example:
- import AllTestLauncher as ATL
- ATL.grepInEnv("XDATA")
- """
- env=os.environ
- for i in sorted(env):
- done=False
- for j in env[i].split(":"):
- if search in j:
- if not done:
- print(i+" contains ")
- done=True
- print(" "+j)
-
+ """
+ list all environment variables which contains search string
+ example:
+ import AllTestLauncher as ATL
+ ATL.grepInEnv("XDATA")
+ """
+ env = os.environ
+ for i in sorted(env):
+ done = False
+ for j in env[i].split(":"):
+ if search in j:
+ if not done:
+ print(i + " contains ")
+ done = True
+ print(" " + j)
+
+
def format_exception(msg, limit=None, trace=None):
"""
Format a stack trace and the exception information.
"""
etype, value, tb = sys.exc_info()
if _user in _developers:
- res = "\n" + msg
- if tb:
- res += "\nTraceback (most recent call last):\n"
- res += "".join(traceback.format_tb(tb, limit)) #[:-1])
- res += "\n<"
- res += "\n".join(traceback.format_exception_only(etype, value))
- return res
+ res = "\n" + msg
+ if tb:
+ res += "\nTraceback (most recent call last):\n"
+ res += "".join(traceback.format_tb(tb, limit)) # [:-1])
+ res += "\n<"
+ res += "\n".join(traceback.format_exception_only(etype, value))
+ return res
else:
- res = "\n" + msg
- if tb:
- res += "\nTraceback:\n"
- res += "".join(traceback.format_tb(tb, limit)[-1:]) #[:-1])
- res += "\n<"
- res += "".join(traceback.format_exception_only(etype, value))
- return res
+ res = "\n" + msg
+ if tb:
+ res += "\nTraceback:\n"
+ res += "".join(traceback.format_tb(tb, limit)[-1:]) # [:-1])
+ res += "\n<"
+ res += "".join(traceback.format_exception_only(etype, value))
+ return res
+
###################################################################
def runOnArgs(args):
- """
- launch tests on args.pattern files
- """
- fromFileOrPath = args.rootPath
- fileTestPattern = args.pattern
- if fromFileOrPath == None:
- directory, name = os.path.split( os.path.realpath( __file__ ) )
- else:
- if os.path.isdir(fromFileOrPath):
- directory, name = (fromFileOrPath, None)
- fileTestPatternCurrent = fileTestPattern
- elif os.path.isfile(fromFileOrPath):
- directory, name = os.path.split( os.path.realpath( fromFileOrPath ) )
- fileTestPatternCurrent = name
- else:
- mess = "Cannot get file or directory '%s'" % fromFileOrPath
- errPrint("ERROR: " + mess)
- return None
- #raise Exception("Cannot get file or directory '%s'" % fromFileOrPath)
-
- #files = glob.glob(os.path.join(directory, "*Test.py"))
- files = sorted(locate(fileTestPatternCurrent, directory))
-
- filesForTest={}
-
- for aFile in files:
- aDir, aName = os.path.split(aFile)
- aImport, ext = os.path.splitext(aName)
-
- try:
- if aFile in list(filesForTest.keys()):
- print("WARNING: imported yet: "+aFile)
- else:
- sys.path.insert(0, aDir)
- done = True
- if verboseImport: errPrint("try import '%s'" % aImport)
- aModule = __import__(aImport, globals(), locals(), [])
- del sys.path[0]
- done = False
- filesForTest[aFile] = (aImport, aModule)
- except Exception as e:
- if done:
- del sys.path[0] #attention of sys.path appends
- done = False
- msg = "ERROR: AllTestLauncher: import '%s':" % aFile
- err = format_exception(msg)
- errPrint(err)
- continue
-
- listfilesForTest = sorted(filesForTest.keys())
- result = None
-
- errPrint("AllTestLauncher test files:\n %s" % PP.pformat(listfilesForTest))
-
- if len(listfilesForTest) == 0:
- if debug: errPrint("WARNING: AllTestLauncher: empty list of test files")
- return None
-
- loader = unittest.TestLoader()
- suite = None
-
- for i,k in enumerate(listfilesForTest):
- if debug: errPrint("Test: %s %s" % (i, k))
- if i == 0:
- suite = loader.loadTestsFromModule( filesForTest[k][1] )
- pass
+ """
+ launch tests on args.pattern files
+ """
+ fromFileOrPath = args.rootPath
+ fileTestPattern = args.pattern
+ if fromFileOrPath == None:
+ directory, name = os.path.split(os.path.realpath(__file__))
else:
- suite.addTests( loader.loadTestsFromModule( filesForTest[k][1] ) )
- pass
-
- if args.type == "std":
- runner = unittest.TextTestRunner(verbosity=args.verbosity)
- elif args.type == "html":
- runner = HTST.HTMLTestRunner(verbosity=args.verbosity, )
- elif args.type == "xml":
- if args.name == 'stdout':
- #all-in-one xml output at 'sys.stdout' for pipe redirection
- runner = XTST.XMLTestRunner(verbosity=args.verbosity, output=sys.stdout)
+ if os.path.isdir(fromFileOrPath):
+ directory, name = (fromFileOrPath, None)
+ fileTestPatternCurrent = fileTestPattern
+ elif os.path.isfile(fromFileOrPath):
+ directory, name = os.path.split(os.path.realpath(fromFileOrPath))
+ fileTestPatternCurrent = name
+ else:
+ mess = "Cannot get file or directory '%s'" % fromFileOrPath
+ errPrint("ERROR: " + mess)
+ return None
+ # raise Exception("Cannot get file or directory '%s'" % fromFileOrPath)
+
+ # files = glob.glob(os.path.join(directory, "*Test.py"))
+ files = sorted(locate(fileTestPatternCurrent, directory))
+
+ filesForTest = {}
+
+ for aFile in files:
+ aDir, aName = os.path.split(aFile)
+ aImport, ext = os.path.splitext(aName)
+
+ try:
+ if aFile in list(filesForTest.keys()):
+ print("WARNING: imported yet: " + aFile)
+ else:
+ sys.path.insert(0, aDir)
+ done = True
+ if verboseImport:
+ errPrint("try import '%s'" % aImport)
+ aModule = __import__(aImport, globals(), locals(), [])
+ del sys.path[0]
+ done = False
+ filesForTest[aFile] = (aImport, aModule)
+ except Exception as e:
+ if done:
+ del sys.path[0] # attention of sys.path appends
+ done = False
+ msg = "ERROR: AllTestLauncher: import '%s':" % aFile
+ err = format_exception(msg)
+ errPrint(err)
+ continue
+
+ listfilesForTest = sorted(filesForTest.keys())
+ result = None
+
+ errPrint("AllTestLauncher test files:\n %s" % PP.pformat(listfilesForTest))
+
+ if len(listfilesForTest) == 0:
+ if debug:
+ errPrint("WARNING: AllTestLauncher: empty list of test files")
+ return None
+
+ loader = unittest.TestLoader()
+ suite = None
+
+ for i, k in enumerate(listfilesForTest):
+ if debug:
+ errPrint("Test: %s %s" % (i, k))
+ if i == 0:
+ suite = loader.loadTestsFromModule(filesForTest[k][1])
+ pass
+ else:
+ suite.addTests(loader.loadTestsFromModule(filesForTest[k][1]))
+ pass
+
+ if args.type == "std":
+ runner = unittest.TextTestRunner(verbosity=args.verbosity)
+ elif args.type == "html":
+ runner = HTST.HTMLTestRunner(
+ verbosity=args.verbosity,
+ )
+ elif args.type == "xml":
+ if args.name == "stdout":
+ # all-in-one xml output at 'sys.stdout' for pipe redirection
+ runner = XTST.XMLTestRunner(verbosity=args.verbosity, output=sys.stdout)
+ else:
+ # one file xml per test in suite in args.name directory
+ runner = XTST.XMLTestRunner(verbosity=args.verbosity, output=args.name)
else:
- #one file xml per test in suite in args.name directory
- runner = XTST.XMLTestRunner(verbosity=args.verbosity, output=args.name)
- else:
- errPrint("ERROR: unknown type of output: '%s'" % args.type)
- return None
-
- if suite != None: result = runner.run(suite)
- return result
+ errPrint("ERROR: unknown type of output: '%s'" % args.type)
+ return None
+
+ if suite != None:
+ result = runner.run(suite)
+ return result
+
###################################################################
def runFromEnvVar(envVar, fileTestPattern="*Test.py"):
- """
- example:
- import AllTestLauncher as ATL
- ATL.runFromEnvVar("MICROGEN_ROOT_DIR")
- ATL.runFromEnvVar("MICROGEN_ROOT_DIR", "aggregate_*GJKTest.py")
- """
- env=os.environ
- res = []
- for i in sorted(env):
- if envVar in i:
- res.append(i)
- if len(res) > 1:
- mess = "multiple environment variable for '%s': %s" % (envVar, str(res))
- errPrint("ERROR: " + mess)
- return None
- if len(res) < 1:
- mess = "no environment variable for '%s'" % (envVar)
- errPrint("ERROR: " + mess)
- return None
- res = res[0]
- tmp = env[res].split(":")
- if len(tmp) > 1:
- mess = "need only one path in environment variable '%s'" % (res)
- errPrint("ERROR: " + mess)
- return None
- run(fromFileOrPath=env[res], fileTestPattern=fileTestPattern)
+ """
+ example:
+ import AllTestLauncher as ATL
+ ATL.runFromEnvVar("MICROGEN_ROOT_DIR")
+ ATL.runFromEnvVar("MICROGEN_ROOT_DIR", "aggregate_*GJKTest.py")
+ """
+ env = os.environ
+ res = []
+ for i in sorted(env):
+ if envVar in i:
+ res.append(i)
+ if len(res) > 1:
+ mess = "multiple environment variable for '%s': %s" % (envVar, str(res))
+ errPrint("ERROR: " + mess)
+ return None
+ if len(res) < 1:
+ mess = "no environment variable for '%s'" % (envVar)
+ errPrint("ERROR: " + mess)
+ return None
+ res = res[0]
+ tmp = env[res].split(":")
+ if len(tmp) > 1:
+ mess = "need only one path in environment variable '%s'" % (res)
+ errPrint("ERROR: " + mess)
+ return None
+ run(fromFileOrPath=env[res], fileTestPattern=fileTestPattern)
###################################################################
def getParser():
- parser = AP.ArgumentParser(description='launch All salomeTools python tests', argument_default=None)
-
- parser.add_argument(
- '-d', '--debug',
- help='set debug mode, more verbose',
- action='store_true',
- )
- parser.add_argument(
- '-v', '--verbosity',
- help='set verbosity of unittests [0|1|2...]',
- default=2,
- metavar='int'
- )
- parser.add_argument(
- '-r', '--rootPath',
- help="""\
+ parser = AP.ArgumentParser(
+ description="launch All salomeTools python tests", argument_default=None
+ )
+
+ parser.add_argument(
+ "-d",
+ "--debug",
+ help="set debug mode, more verbose",
+ action="store_true",
+ )
+ parser.add_argument(
+ "-v",
+ "--verbosity",
+ help="set verbosity of unittests [0|1|2...]",
+ default=2,
+ metavar="int",
+ )
+ parser.add_argument(
+ "-r",
+ "--rootPath",
+ help="""\
dir name with absolute or relative path stand for root directory
of recursive searching unittest python files
""",
- default=defaultdir,
- metavar='dirPath'
- )
- parser.add_argument(
- '-p', '--pattern',
- help="file pattern for unittest files ['test_*.py'|'*Test.py'...]",
- default="test_???_*.py", # as alphabetical ordered test site
- metavar='filePattern'
- )
- parser.add_argument(
- '-t', '--type',
- help="type of output: ['std'(standart ascii)|'xml'|'html']",
- default="std",
- choices=['std', 'xml', 'html'],
- metavar='outputType'
- )
- parser.add_argument(
- '-n', '--name',
- help="""\
+ default=defaultdir,
+ metavar="dirPath",
+ )
+ parser.add_argument(
+ "-p",
+ "--pattern",
+ help="file pattern for unittest files ['test_*.py'|'*Test.py'...]",
+ default="test_???_*.py", # as alphabetical ordered test site
+ metavar="filePattern",
+ )
+ parser.add_argument(
+ "-t",
+ "--type",
+ help="type of output: ['std'(standart ascii)|'xml'|'html']",
+ default="std",
+ choices=["std", "xml", "html"],
+ metavar="outputType",
+ )
+ parser.add_argument(
+ "-n",
+ "--name",
+ help="""\
(only for type xml)
name of directory output: ['test_reports'|...].
If name = 'stdout' then all-in-one xml output at 'sys.stdout'. For pipe redirection:
'>> AllTestLauncher.py -t xml -n stdout > tmp.xml'
""",
- default="test_reports",
- metavar='dirName'
- )
- return parser
+ default="test_reports",
+ metavar="dirName",
+ )
+ return parser
-#export PATH=defaultdir:${PATH}
-
-###################################################################
-if __name__ == '__main__':
- # Make the src & command package accessible from all code
- # as export PYTHONPATH=defaultdir:${PYTHONPATH}
- # https://docs.python.org/2/library/os.html
- # On some platforms, including FreeBSD and Mac OS X,
- # setting environ may cause memory leak
- # so use sys.path
- # errPrint("INFO : AllTestLauncher sys.path:\n'%s'" % PP.pformat(sys.path)
- if defaultdir not in sys.path[0]:
- sys.path.insert(0, defaultdir)
- errPrint("WARNING : sys.path prepend '%s'\n" % defaultdir)
-
- args = getParser().parse_args(sys.argv[1:])
- debug = args.debug
- directory = os.path.realpath(args.rootPath)
- if debug: print("INFO: args:\n %s" % PP.pformat(args))
- sys.path.insert(0, directory) #supposed to be root of a package
-
- runOnArgs(args)
+# export PATH=defaultdir:${PATH}
+###################################################################
+if __name__ == "__main__":
+ # Make the src & command package accessible from all code
+ # as export PYTHONPATH=defaultdir:${PYTHONPATH}
+ # https://docs.python.org/2/library/os.html
+ # On some platforms, including FreeBSD and Mac OS X,
+ # setting environ may cause memory leak
+ # so use sys.path
+ # errPrint("INFO : AllTestLauncher sys.path:\n'%s'" % PP.pformat(sys.path)
+ if defaultdir not in sys.path[0]:
+ sys.path.insert(0, defaultdir)
+ errPrint("WARNING : sys.path prepend '%s'\n" % defaultdir)
+
+ args = getParser().parse_args(sys.argv[1:])
+ debug = args.debug
+ directory = os.path.realpath(args.rootPath)
+ if debug:
+ print("INFO: args:\n %s" % PP.pformat(args))
+ sys.path.insert(0, directory) # supposed to be root of a package
+
+ runOnArgs(args)
-__all__ = ['src', 'commands', "test", "unittestpy", ]
\ No newline at end of file
+__all__ = [
+ "src",
+ "commands",
+ "test",
+ "unittestpy",
+]
-
"""
import os
import gettext
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2013 CEA/DEN
#
# This library is free software; you can redistribute it and/or
from src import ElementTree as etree
import src
-from src.versionMinorMajorPatch import MinorMajorPatch as MMP
+from src.versionMinorMajorPatch import MinorMajorPatch as MMP
parser = src.options.Options()
-parser.add_option('n', 'name', 'string', 'name',
- _('Optional: The name of the application (default is APPLICATION.virtual_app.name or '
- 'runAppli)'))
-parser.add_option('c', 'catalog', 'string', 'catalog',
- _('Optional: The resources catalog to use'))
-parser.add_option('t', 'target', 'string', 'target',
- _('Optional: The directory where to create the application (default is '
- 'APPLICATION.workdir)'))
-parser.add_option('', 'gencat', 'string', 'gencat',
- _("Optional: Create a resources catalog for the specified machines "
- "(separated with ',')\n\tNOTICE: this command will ssh to retrieve "
- "information to each machine in the list"))
-parser.add_option('m', 'module', 'list2', 'modules',
- _("Optional: the restricted list of module(s) to include in the "
- "application"))
-parser.add_option('', 'use_mesa', 'boolean', 'use_mesa',
- _("Optional: Create a launcher that will use mesa products\n\t"
- "It can be usefull whan salome is used on a remote machine through ssh"))
+parser.add_option(
+ "n",
+ "name",
+ "string",
+ "name",
+ _(
+ "Optional: The name of the application (default is APPLICATION.virtual_app.name or "
+ "runAppli)"
+ ),
+)
+parser.add_option(
+ "c", "catalog", "string", "catalog", _("Optional: The resources catalog to use")
+)
+parser.add_option(
+ "t",
+ "target",
+ "string",
+ "target",
+ _(
+ "Optional: The directory where to create the application (default is "
+ "APPLICATION.workdir)"
+ ),
+)
+parser.add_option(
+ "",
+ "gencat",
+ "string",
+ "gencat",
+ _(
+ "Optional: Create a resources catalog for the specified machines "
+ "(separated with ',')\n\tNOTICE: this command will ssh to retrieve "
+ "information to each machine in the list"
+ ),
+)
+parser.add_option(
+ "m",
+ "module",
+ "list2",
+ "modules",
+ _("Optional: the restricted list of module(s) to include in the " "application"),
+)
+parser.add_option(
+ "",
+ "use_mesa",
+ "boolean",
+ "use_mesa",
+ _(
+ "Optional: Create a launcher that will use mesa products\n\t"
+ "It can be usefull whan salome is used on a remote machine through ssh"
+ ),
+)
##
# Creates an alias for runAppli.
assert len(alias_path) > 0, "Bad name for alias"
if os.path.exists(alias_path) and not force:
raise src.SatException(_("Cannot create the alias '%s'\n") % alias_path)
- else: # find relative path
+ else: # find relative path
os.symlink(appli_path, alias_path)
+
##
# add the definition of a module to out stream.
def add_module_to_appli(out, module, has_gui, module_path, logger, flagline):
if not flagline:
logger.write("\n", 3, False)
flagline = True
- logger.write(" " + src.printcolors.printcWarning(_(
- "WARNING: module %s not installed") % module) + "\n", 3)
-
- out.write(' <module name="%s" gui="%s" path="%s"/>\n' % (module,
- has_gui,
- module_path))
+ logger.write(
+ " "
+ + src.printcolors.printcWarning(
+ _("WARNING: module %s not installed") % module
+ )
+ + "\n",
+ 3,
+ )
+
+ out.write(
+ ' <module name="%s" gui="%s" path="%s"/>\n' % (module, has_gui, module_path)
+ )
return flagline
+
##
# Creates the config file to create an application with the list of modules.
def create_config_file(config, modules, env_files, logger):
samples = ""
- if 'SAMPLES' in config.APPLICATION.products:
- samples = src.product.get_product_config(config, 'SAMPLES').source_dir
+ if "SAMPLES" in config.APPLICATION.products:
+ samples = src.product.get_product_config(config, "SAMPLES").source_dir
config_file = src.get_tmp_filename(config, "appli_config.xml")
f = open(config_file, "w")
- f.write('<application>\n')
+ f.write("<application>\n")
for env_file in env_files:
if env_file.endswith("cfg"):
f.write('<context path="%s"/>\n' % env_file)
f.write('<prerequisites path="%s"/>\n' % env_file)
f.write('<resources path="CatalogResources.xml"/>\n')
- f.write('<modules>\n')
+ f.write("<modules>\n")
flagline = False
for m in modules:
# do not include products that do not compile
if not src.product.product_compiles(mm):
continue
- #obsolete?
+ # obsolete?
if src.product.product_is_smesh_plugin(mm):
continue
- if 'install_dir' in mm and bool(mm.install_dir):
+ if "install_dir" in mm and bool(mm.install_dir):
if src.product.product_is_cpp(mm):
# cpp module
for aa in src.product.get_product_components(mm):
- install_dir=os.path.join(config.APPLICATION.workdir,
- config.INTERNAL.config.install_dir)
+ install_dir = os.path.join(
+ config.APPLICATION.workdir, config.INTERNAL.config.install_dir
+ )
mp = os.path.join(install_dir, aa)
- flagline = add_module_to_appli(f,
- aa,
- "yes",
- mp,
- logger,
- flagline)
+ flagline = add_module_to_appli(f, aa, "yes", mp, logger, flagline)
else:
# regular module
mp = mm.install_dir
gui = src.get_cfg_param(mm, "has_gui", "yes")
flagline = add_module_to_appli(f, m, gui, mp, logger, flagline)
- f.write('</modules>\n')
+ f.write("</modules>\n")
f.write('<samples path="%s"/>\n' % samples)
- f.write('</application>\n')
+ f.write("</application>\n")
f.close()
return config_file
+
##
# Customizes the application by editing SalomeApp.xml.
def customize_app(config, appli_dir, logger):
- if 'configure' not in config.APPLICATION.virtual_app \
- or len(config.APPLICATION.virtual_app.configure) == 0:
+ if (
+ "configure" not in config.APPLICATION.virtual_app
+ or len(config.APPLICATION.virtual_app.configure) == 0
+ ):
return
# shortcut to get an element (section or parameter) from parent.
def get_element(parent, name, strtype):
for c in parent.getchildren():
- if c.attrib['name'] == name:
+ if c.attrib["name"] == name:
return c
# element not found create it
elt = add_simple_node(parent, strtype)
- elt.attrib['name'] = name
+ elt.attrib["name"] = name
return elt
# shortcut method to create a node
logger.write("\n", 4)
for section_name in config.APPLICATION.virtual_app.configure:
for parameter_name in config.APPLICATION.virtual_app.configure[section_name]:
- parameter_value = config.APPLICATION.virtual_app.configure[section_name][parameter_name]
- logger.write(" configure: %s/%s = %s\n" % (section_name,
- parameter_name,
- parameter_value), 4)
+ parameter_value = config.APPLICATION.virtual_app.configure[section_name][
+ parameter_name
+ ]
+ logger.write(
+ " configure: %s/%s = %s\n"
+ % (section_name, parameter_name, parameter_value),
+ 4,
+ )
section = get_element(document, section_name, "section")
parameter = get_element(section, parameter_name, "parameter")
- parameter.attrib['value'] = parameter_value
+ parameter.attrib["value"] = parameter_value
# write the file
f = open(app_file, "w")
f.write("<?xml version='1.0' encoding='utf-8'?>\n")
- f.write(etree.tostring(document, encoding='utf-8'))
+ f.write(etree.tostring(document, encoding="utf-8"))
f.close()
+
##
# Generates the application with the config_file.
def generate_application(config, appli_dir, config_file, logger):
target_dir = os.path.dirname(appli_dir)
- install_KERNEL_dir = src.product.get_product_config(config,
- 'KERNEL').install_dir
+ install_KERNEL_dir = src.product.get_product_config(config, "KERNEL").install_dir
script = os.path.join(install_KERNEL_dir, "bin", "salome", "appli_gen.py")
if not os.path.exists(script):
raise src.SatException(_("KERNEL is not installed"))
# Add SALOME python in the environment in order to avoid python version
# problems at appli_gen.py call
- if 'Python' in config.APPLICATION.products:
- envi = src.environment.SalomeEnviron(config,
- src.environment.Environ(
- dict(os.environ)),
- True)
- envi.set_a_product('Python', logger)
-
- command = "python %s --prefix=%s --config=%s" % (script,
- appli_dir,
- config_file)
+ if "Python" in config.APPLICATION.products:
+ envi = src.environment.SalomeEnviron(
+ config, src.environment.Environ(dict(os.environ)), True
+ )
+ envi.set_a_product("Python", logger)
+
+ command = "python %s --prefix=%s --config=%s" % (script, appli_dir, config_file)
logger.write("\n>" + command + "\n", 5, False)
- res = subprocess.call(command,
- shell=True,
- cwd=target_dir,
- env=envi.environ.environ,
- stdout=logger.logTxtFile,
- stderr=subprocess.STDOUT)
+ res = subprocess.call(
+ command,
+ shell=True,
+ cwd=target_dir,
+ env=envi.environ.environ,
+ stdout=logger.logTxtFile,
+ stderr=subprocess.STDOUT,
+ )
if res != 0:
raise src.SatException(_("Cannot create application, code = %d\n") % res)
return res
+
##
#
def write_step(logger, message, level=3, pad=50):
- logger.write("%s %s " % (message, '.' * (pad - len(message.decode("UTF-8")))), level)
+ logger.write(
+ "%s %s " % (message, "." * (pad - len(message.decode("UTF-8")))), level
+ )
logger.flush()
+
##
# Creates a SALOME application.
def create_application(config, appli_dir, catalog, logger, display=True):
SALOME_modules = get_SALOME_modules(config)
- warn = ['KERNEL', 'GUI']
+ warn = ["KERNEL", "GUI"]
if display:
for w in warn:
if w not in SALOME_modules:
logger.write(src.printcolors.printcWarning(msg), 2)
# generate the launch file
- retcode = generate_launch_file(config,
- appli_dir,
- catalog,
- logger,
- SALOME_modules)
+ retcode = generate_launch_file(config, appli_dir, catalog, logger, SALOME_modules)
if retcode == 0:
cmd = src.printcolors.printcLabel("%s/salome" % appli_dir)
logger.write("\n", 3, False)
return retcode
+
def get_SALOME_modules(config):
l_modules = []
for product in config.APPLICATION.products:
product_info = src.product.get_product_config(config, product)
- if (src.product.product_is_salome(product_info) or
- src.product.product_is_generated(product_info)):
+ if src.product.product_is_salome(
+ product_info
+ ) or src.product.product_is_generated(product_info):
l_modules.append(product)
return l_modules
+
##
# Obsolescent way of creating the application.
# This method will use appli_gen to create the application directory.
# build the application (the name depends upon salome version
env_file = os.path.join(config.APPLICATION.workdir, "env_launch")
VersionSalome = src.get_salome_version(config)
- if VersionSalome>=MMP([8,2,0]):
+ if VersionSalome >= MMP([8, 2, 0]):
# for salome 8+ we use a salome context file for the virtual app
- app_shell=["cfg", "bash"]
- env_files=[env_file+".cfg", env_file+".sh"]
+ app_shell = ["cfg", "bash"]
+ env_files = [env_file + ".cfg", env_file + ".sh"]
else:
- app_shell=["bash"]
- env_files=[env_file+".sh"]
+ app_shell = ["bash"]
+ env_files = [env_file + ".sh"]
try:
import environ
+
# generate only shells the user wants (by default bash, csh, batch)
# the environ command will only generate file compatible
# with the current system.
- environ.write_all_source_files(config,
- logger,
- shells=app_shell,
- silent=True)
+ environ.write_all_source_files(config, logger, shells=app_shell, silent=True)
status = src.OK_STATUS
finally:
logger.write(src.printcolors.printc(status) + "\n", 2, False)
-
write_step(logger, _("Building application"), level=2)
cf = create_config_file(config, l_SALOME_modules, env_files, logger)
return retcode
-
##
# Generates the catalog from a list of machines.
def generate_catalog(machines, config, logger):
machines = map(lambda l: l.strip(), machines)
machines = filter(lambda l: len(l) > 0, machines)
- src.printcolors.print_value(logger,
- _("Generate Resources Catalog"),
- ", ".join(machines),
- 4)
+ src.printcolors.print_value(
+ logger, _("Generate Resources Catalog"), ", ".join(machines), 4
+ )
cmd = '"cat /proc/cpuinfo | grep MHz ; cat /proc/meminfo | grep MemTotal"'
user = getpass.getuser()
catfile = src.get_tmp_filename(config, "CatalogResources.xml")
- with open(catfile, 'w') as catalog:
+ with open(catfile, "w") as catalog:
catalog.write("<!DOCTYPE ResourcesCatalog>\n<resources>\n")
for k in machines:
if not src.architecture.is_windows():
- logger.write(" ssh %s " % (k + " ").ljust(20, '.'), 4)
+ logger.write(" ssh %s " % (k + " ").ljust(20, "."), 4)
logger.flush()
ssh_cmd = 'ssh -o "StrictHostKeyChecking no" %s %s' % (k, cmd)
- p = subprocess.Popen(ssh_cmd, shell=True,
- stdin=subprocess.PIPE,
- stdout=subprocess.PIPE,
- stderr=subprocess.PIPE)
+ p = subprocess.Popen(
+ ssh_cmd,
+ shell=True,
+ stdin=subprocess.PIPE,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE,
+ )
p.wait()
- machine_access = (p.returncode == 0)
+ machine_access = p.returncode == 0
if not machine_access:
logger.write(src.printcolors.printc(src.KO_STATUS) + "\n", 4)
- logger.write(" " + src.printcolors.printcWarning(p.stderr.read()),
- 2)
+ logger.write(
+ " " + src.printcolors.printcWarning(p.stderr.read()), 2
+ )
else:
logger.write(src.printcolors.printc(src.OK_STATUS) + "\n", 4)
lines = p.stdout.readlines()
- freq = lines[0][:-1].split(':')[-1].split('.')[0].strip()
- nb_proc = len(lines) -1
- memory = lines[-1].split(':')[-1].split()[0].strip()
+ freq = lines[0][:-1].split(":")[-1].split(".")[0].strip()
+ nb_proc = len(lines) - 1
+ memory = lines[-1].split(":")[-1].split()[0].strip()
memory = int(memory) / 1000
catalog.write(" <machine\n")
- catalog.write(" protocol=\"ssh\"\n")
- catalog.write(" nbOfNodes=\"1\"\n")
- catalog.write(" mode=\"interactif\"\n")
- catalog.write(" OS=\"LINUX\"\n")
+ catalog.write(' protocol="ssh"\n')
+ catalog.write(' nbOfNodes="1"\n')
+ catalog.write(' mode="interactif"\n')
+ catalog.write(' OS="LINUX"\n')
if (not src.architecture.is_windows()) and machine_access:
- catalog.write(" CPUFreqMHz=\"%s\"\n" % freq)
- catalog.write(" nbOfProcPerNode=\"%s\"\n" % nb_proc)
- catalog.write(" memInMB=\"%s\"\n" % memory)
+ catalog.write(' CPUFreqMHz="%s"\n' % freq)
+ catalog.write(' nbOfProcPerNode="%s"\n' % nb_proc)
+ catalog.write(' memInMB="%s"\n' % memory)
- catalog.write(" userName=\"%s\"\n" % user)
- catalog.write(" name=\"%s\"\n" % k)
- catalog.write(" hostname=\"%s\"\n" % k)
+ catalog.write(' userName="%s"\n' % user)
+ catalog.write(' name="%s"\n' % k)
+ catalog.write(' hostname="%s"\n' % k)
catalog.write(" >\n")
catalog.write(" </machine>\n")
catalog.write("</resources>\n")
return catfile
+
##################################################
##
# Describes the command
def description():
- '''method that is called when salomeTools is called with --help option.
+ """method that is called when salomeTools is called with --help option.
:return: The text to display for the application command description.
:rtype: str
- '''
- return _("The application command creates a SALOME application.\n"
- "WARNING: it works only for SALOME 6. Use the \"launcher\" "
- "command for newer versions of SALOME\n\nexample:\nsat application"
- " SALOME-6.6.0")
+ """
+ return _(
+ "The application command creates a SALOME application.\n"
+ 'WARNING: it works only for SALOME 6. Use the "launcher" '
+ "command for newer versions of SALOME\n\nexample:\nsat application"
+ " SALOME-6.6.0"
+ )
+
##
# Runs the command.
def run(args, runner, logger):
- '''method that is called when salomeTools is called with application
- parameter.
- '''
+ """method that is called when salomeTools is called with application
+ parameter.
+ """
(options, args) = parser.parse_args(args)
# check for product
- src.check_config_has_application( runner.cfg )
+ src.check_config_has_application(runner.cfg)
application = src.printcolors.printcLabel(runner.cfg.VARS.application)
logger.write(_("Building application for %s\n") % application, 1)
# if section APPLICATION.virtual_app does not exists create one
if "virtual_app" not in runner.cfg.APPLICATION:
- msg = _("The section APPLICATION.virtual_app is not defined in the product. Use sat launcher in state")
+ msg = _(
+ "The section APPLICATION.virtual_app is not defined in the product. Use sat launcher in state"
+ )
logger.write(src.printcolors.printcError(msg), 1)
logger.write("\n", 1)
return 1
# set list of modules
if options.modules:
- runner.cfg.APPLICATION.virtual_app['modules'] = options.modules
+ runner.cfg.APPLICATION.virtual_app["modules"] = options.modules
# activate mesa use in the generated application
if options.use_mesa:
# set name and application_name
if options.name:
- runner.cfg.APPLICATION.virtual_app['name'] = options.name
- runner.cfg.APPLICATION.virtual_app['application_name'] = options.name + "_appdir"
-
- application_name = src.get_cfg_param(runner.cfg.APPLICATION.virtual_app,
- "application_name",
- runner.cfg.APPLICATION.virtual_app.name + "_appdir")
+ runner.cfg.APPLICATION.virtual_app["name"] = options.name
+ runner.cfg.APPLICATION.virtual_app["application_name"] = (
+ options.name + "_appdir"
+ )
+
+ application_name = src.get_cfg_param(
+ runner.cfg.APPLICATION.virtual_app,
+ "application_name",
+ runner.cfg.APPLICATION.virtual_app.name + "_appdir",
+ )
appli_dir = os.path.join(target_dir, application_name)
- src.printcolors.print_value(logger,
- _("Application directory"),
- appli_dir,
- 3)
+ src.printcolors.print_value(logger, _("Application directory"), appli_dir, 3)
# get catalog
catalog, catalog_src = "", ""
elif options.gencat:
# generate catalog for given list of computers
catalog_src = options.gencat
- catalog = generate_catalog(options.gencat.split(","),
- runner.cfg,logger)
- elif 'catalog' in runner.cfg.APPLICATION.virtual_app:
+ catalog = generate_catalog(options.gencat.split(","), runner.cfg, logger)
+ elif "catalog" in runner.cfg.APPLICATION.virtual_app:
# use catalog specified in the product
if runner.cfg.APPLICATION.virtual_app.catalog.endswith(".xml"):
# catalog as a file
else:
# catalog as a list of computers
catalog_src = runner.cfg.APPLICATION.virtual_app.catalog
- mlist = filter(lambda l: len(l.strip()) > 0,
- runner.cfg.APPLICATION.virtual_app.catalog.split(","))
+ mlist = filter(
+ lambda l: len(l.strip()) > 0,
+ runner.cfg.APPLICATION.virtual_app.catalog.split(","),
+ )
if len(mlist) > 0:
- catalog = generate_catalog(runner.cfg.APPLICATION.virtual_app.catalog.split(","),
- runner.cfg, logger)
+ catalog = generate_catalog(
+ runner.cfg.APPLICATION.virtual_app.catalog.split(","),
+ runner.cfg,
+ logger,
+ )
# display which catalog is used
if len(catalog) > 0:
catalog = os.path.realpath(catalog)
if len(catalog_src) > 0:
- src.printcolors.print_value(logger,
- _("Resources Catalog"),
- catalog_src,
- 3)
+ src.printcolors.print_value(logger, _("Resources Catalog"), catalog_src, 3)
else:
- src.printcolors.print_value(logger,
- _("Resources Catalog"),
- catalog,
- 3)
+ src.printcolors.print_value(logger, _("Resources Catalog"), catalog, 3)
logger.write("\n", 3, False)
# generate the application
try:
- try: # try/except/finally not supported in all version of python
+ try: # try/except/finally not supported in all version of python
retcode = create_application(runner.cfg, appli_dir, catalog, logger)
except Exception as exc:
details.append(str(exc))
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2012 CEA/DEN
#
# This library is free software; you can redistribute it and/or
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
import os
-
import src
# Define all possible option for the check command : sat check <options>
parser = src.options.Options()
-parser.add_option('p', 'products', 'list2', 'products',
- _('Optional: products to check. This option accepts a comma separated list.'))
+parser.add_option(
+ "p",
+ "products",
+ "list2",
+ "products",
+ _("Optional: products to check. This option accepts a comma separated list."),
+)
CHECK_PROPERTY = "has_unit_tests"
logger.write("\n==== %s \n" % src.printcolors.printcInfo(step), 4)
logger.flush()
+
def log_res_step(logger, res):
if res == 0:
logger.write("%s \n" % src.printcolors.printcSuccess("OK"), 4)
logger.write("%s \n" % src.printcolors.printcError("KO"), 4)
logger.flush()
+
def check_all_products(config, products_infos, logger):
- '''Execute the proper configuration commands
+ """Execute the proper configuration commands
in each product build directory.
:param config Config: The global configuration
- :param products_info list: List of
+ :param products_info list: List of
(str, Config) => (product_name, product_info)
:param logger Logger: The logger instance to use for the display and logging
:return: the number of failing commands.
:rtype: int
- '''
+ """
res = 0
for p_name_info in products_infos:
res_prod = check_product(p_name_info, config, logger)
if res_prod != 0:
- res += 1
+ res += 1
return res
+
def check_product(p_name_info, config, logger):
- '''Execute the proper configuration command(s)
+ """Execute the proper configuration command(s)
in the product build directory.
-
+
:param p_name_info tuple: (str, Config) => (product_name, product_info)
:param config Config: The global configuration
- :param logger Logger: The logger instance to use for the display
+ :param logger Logger: The logger instance to use for the display
and logging
:return: 1 if it fails, else 0.
:rtype: int
- '''
-
+ """
+
p_name, p_info = p_name_info
-
+
# Logging
logger.write("\n", 4, False)
logger.write("################ ", 4)
# Verify if the command has to be launched or not
ignored = False
if src.product.product_is_native(p_info):
- msg = _("The product %s is defined as being native. "
- "product ignored." % p_name)
+ msg = _(
+ "The product %s is defined as being native. " "product ignored." % p_name
+ )
logger.write("%s\n" % msg, 4)
ignored = True
elif not src.get_property_in_product_cfg(p_info, CHECK_PROPERTY):
- msg = _("The product %s is defined as not having tests. "
- "product ignored." % p_name)
+ msg = _(
+ "The product %s is defined as not having tests. "
+ "product ignored." % p_name
+ )
logger.write("%s\n" % msg, 4)
ignored = True
elif not src.product.product_compiles(p_info):
- msg = _("The product %s is defined as not compiling. "
- "product ignored." % p_name)
+ msg = _(
+ "The product %s is defined as not compiling. " "product ignored." % p_name
+ )
logger.write("%s\n" % msg, 4)
ignored = True
elif "build_dir" not in p_info:
- msg = _("No build_dir key defined in "
- "the config file of %s: product ignored." % p_name)
+ msg = _(
+ "No build_dir key defined in "
+ "the config file of %s: product ignored." % p_name
+ )
logger.write("%s\n" % msg, 4)
ignored = True
-
# Get the command to execute for script products
cmd_found = True
command = ""
command = src.get_cfg_param(p_info, "test_build", "Not found")
if command == "Not found":
cmd_found = False
- msg = _('WARNING: The product %s is defined as having tests. But it'
- ' is compiled using a script and the key "test_build" is '
- 'not defined in the definition of %s' % (p_name, p_name))
+ msg = _(
+ "WARNING: The product %s is defined as having tests. But it"
+ ' is compiled using a script and the key "test_build" is '
+ "not defined in the definition of %s" % (p_name, p_name)
+ )
logger.write("%s\n" % msg, 4)
-
+
if ignored or not cmd_found:
log_step(logger, header, "ignored")
- logger.write("==== %(name)s %(IGNORED)s\n" %
- { "name" : p_name ,
- "IGNORED" : src.printcolors.printcInfo("IGNORED")},
- 4)
+ logger.write(
+ "==== %(name)s %(IGNORED)s\n"
+ % {"name": p_name, "IGNORED": src.printcolors.printcInfo("IGNORED")},
+ 4,
+ )
logger.write("\n", 3, False)
logger.flush()
if not cmd_found:
return 1
return 0
-
+
# Instantiate the class that manages all the construction commands
# like cmake, check, make install, make test, environment management, etc...
builder = src.compilation.Builder(config, logger, p_name, p_info)
-
+
# Prepare the environment
log_step(logger, header, "PREPARE ENV")
res_prepare = builder.prepare(add_env_launch=True)
log_res_step(logger, res_prepare)
-
+
len_end_line = 20
- # Launch the check
+ # Launch the check
log_step(logger, header, "CHECK")
res = builder.check(command=command)
log_res_step(logger, res)
-
+
# Log the result
if res > 0:
logger.write("\r%s%s" % (header, " " * len_end_line), 3)
logger.write("\r" + header + src.printcolors.printcError("KO"))
- logger.write("==== %(KO)s in check of %(name)s \n" %
- { "name" : p_name , "KO" : src.printcolors.printcInfo("ERROR")}, 4)
+ logger.write(
+ "==== %(KO)s in check of %(name)s \n"
+ % {"name": p_name, "KO": src.printcolors.printcInfo("ERROR")},
+ 4,
+ )
logger.flush()
else:
logger.write("\r%s%s" % (header, " " * len_end_line), 3)
logger.write("\r" + header + src.printcolors.printcSuccess("OK"))
logger.write("==== %s \n" % src.printcolors.printcInfo("OK"), 4)
- logger.write("==== Check of %(name)s %(OK)s \n" %
- { "name" : p_name , "OK" : src.printcolors.printcInfo("OK")}, 4)
+ logger.write(
+ "==== Check of %(name)s %(OK)s \n"
+ % {"name": p_name, "OK": src.printcolors.printcInfo("OK")},
+ 4,
+ )
logger.flush()
logger.write("\n", 3, False)
return res
+
def description():
- '''method that is called when salomeTools is called with --help option.
-
+ """method that is called when salomeTools is called with --help option.
+
:return: The text to display for the check command description.
:rtype: str
- '''
- return _("The check command executes the \"check\" command in"
- " the build directory of all the products of the application."
- "\nIt is possible to reduce the list of products to check by using"
- " the --products option\n\nexample\nsat check SALOME-master "
- "--products KERNEL,GUI,GEOM")
-
+ """
+ return _(
+ 'The check command executes the "check" command in'
+ " the build directory of all the products of the application."
+ "\nIt is possible to reduce the list of products to check by using"
+ " the --products option\n\nexample\nsat check SALOME-master "
+ "--products KERNEL,GUI,GEOM"
+ )
+
+
def run(args, runner, logger):
- '''method that is called when salomeTools is called with check parameter.
- '''
-
+ """method that is called when salomeTools is called with check parameter."""
+
# Parse the options
(options, args) = parser.parse_args(args)
# check that the command has been called with an application
- src.check_config_has_application( runner.cfg )
+ src.check_config_has_application(runner.cfg)
# Get the list of products to treat
products_infos = src.product.get_products_list(options, runner.cfg, logger)
-
+
# Print some informations
- logger.write(_('Executing the check command in the build '
- 'directories of the application %s\n') %
- src.printcolors.printcLabel(runner.cfg.VARS.application), 1)
-
- info = [(_("BUILD directory"),
- os.path.join(runner.cfg.APPLICATION.workdir, 'BUILD'))]
+ logger.write(
+ _(
+ "Executing the check command in the build "
+ "directories of the application %s\n"
+ )
+ % src.printcolors.printcLabel(runner.cfg.VARS.application),
+ 1,
+ )
+
+ info = [
+ (_("BUILD directory"), os.path.join(runner.cfg.APPLICATION.workdir, "BUILD"))
+ ]
src.print_info(logger, info)
-
+
# Call the function that will loop over all the products and execute
# the right command(s)
res = check_all_products(runner.cfg, products_infos, logger)
-
+
# Print the final state
nb_products = len(products_infos)
if res == 0:
final_status = "OK"
else:
final_status = "KO"
-
- logger.write(_("\nCheck: %(status)s (%(valid_result)d/%(nb_products)d)\n") % \
- { 'status': src.printcolors.printc(final_status),
- 'valid_result': nb_products - res,
- 'nb_products': nb_products }, 1)
-
- return res
+
+ logger.write(
+ _("\nCheck: %(status)s (%(valid_result)d/%(nb_products)d)\n")
+ % {
+ "status": src.printcolors.printc(final_status),
+ "valid_result": nb_products - res,
+ "nb_products": nb_products,
+ },
+ 1,
+ )
+
+ return res
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2012 CEA/DEN
#
# This library is free software; you can redistribute it and/or
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-import re
import os
-
import src
# Compatibility python 2/3 for input function
# input stays input for python 3 and input = raw_input for python 2
-try:
+try:
input = raw_input
-except NameError:
+except NameError:
pass
# Define all possible option for the clean command : sat clean <options>
parser = src.options.Options()
-parser.add_option('p', 'products', 'list2', 'products',
- _('Optional: Products to clean. This option accepts a comma separated list.'))
-parser.add_option('s', 'sources', 'boolean', 'sources',
- _("Optional: Clean the product source directories."))
-parser.add_option('b', 'build', 'boolean', 'build',
- _("Optional: Clean the product build directories."))
-parser.add_option('i', 'install', 'boolean', 'install',
- _("Optional: Clean the product install directories."))
-parser.add_option('g', 'generated', 'boolean', 'generated',
- _("Optional: Clean source, build and install directories for generated products."))
-parser.add_option('', 'package', 'boolean', 'package',
- _("Optional: Clean packages produced by sat package command."))
-parser.add_option('a', 'all', 'boolean', 'all',
- _("Optional: Clean the product source, build and install directories."))
-parser.add_option('', 'sources_without_dev', 'boolean', 'sources_without_dev',
- _("Optional: do not clean the products in development mode."))
+parser.add_option(
+ "p",
+ "products",
+ "list2",
+ "products",
+ _("Optional: Products to clean. This option accepts a comma separated list."),
+)
+parser.add_option(
+ "s",
+ "sources",
+ "boolean",
+ "sources",
+ _("Optional: Clean the product source directories."),
+)
+parser.add_option(
+ "b",
+ "build",
+ "boolean",
+ "build",
+ _("Optional: Clean the product build directories."),
+)
+parser.add_option(
+ "i",
+ "install",
+ "boolean",
+ "install",
+ _("Optional: Clean the product install directories."),
+)
+parser.add_option(
+ "g",
+ "generated",
+ "boolean",
+ "generated",
+ _("Optional: Clean source, build and install directories for generated products."),
+)
+parser.add_option(
+ "",
+ "package",
+ "boolean",
+ "package",
+ _("Optional: Clean packages produced by sat package command."),
+)
+parser.add_option(
+ "a",
+ "all",
+ "boolean",
+ "all",
+ _("Optional: Clean the product source, build and install directories."),
+)
+parser.add_option(
+ "",
+ "sources_without_dev",
+ "boolean",
+ "sources_without_dev",
+ _("Optional: do not clean the products in development mode."),
+)
def get_source_directories(config, products_infos, without_dev):
for __, product_info in products_infos:
if product_has_dir(product_info, without_dev):
# we do not clean source dirs of pip products when pip is activated
- if not ( src.appli_test_property(config,"pip", "yes") and\
- src.product.product_test_property(product_info,"pip", "yes") ) :
+ if not (
+ src.appli_test_property(config, "pip", "yes")
+ and src.product.product_test_property(product_info, "pip", "yes")
+ ):
l_dir_source.append(src.Path(product_info.source_dir))
return l_dir_source
+
def get_build_directories(products_infos):
"""\
Returns the list of directory build paths corresponding to the list of
l_dir_build.append(src.Path(product_info.build_dir))
return l_dir_build
+
def get_install_directories(config, products_infos):
"""\
Returns the list of directory install paths corresponding to the list of
for __, product_info in products_infos:
if product_has_dir(product_info):
# we do not clean pip products installed in python install dir
- if not ( src.appli_test_property(config,"pip", "yes") and\
- src.product.product_test_property(product_info, "pip", "yes") and\
- src.appli_test_property(config,"pip_install_dir", "python") ) :
+ if not (
+ src.appli_test_property(config, "pip", "yes")
+ and src.product.product_test_property(product_info, "pip", "yes")
+ and src.appli_test_property(config, "pip_install_dir", "python")
+ ):
l_dir_install.append(src.Path(product_info.install_dir))
return l_dir_install
+
def get_package_directory(config):
"""\
Returns the package directory name corresponding to the sat package command
"""
return [src.Path(os.path.join(config.APPLICATION.workdir, "PACKAGE"))]
+
def get_generated_directories(config, products_infos):
"""\
Returns the list of directories (source, build, install) corresponding to the
generate_dir = os.path.join(workdir, "GENERATED")
source_dir = os.path.join(generate_dir, compo + "_SRC")
build_dir = os.path.join(os.path.join(workdir, "BUILD"), compo)
- install_dir = os.path.join(workdir, config.INTERNAL.config.install_dir,
- compo)
+ install_dir = os.path.join(workdir, config.INTERNAL.config.install_dir, compo)
l_dir_install.append(src.Path(source_dir))
l_dir_install.append(src.Path(build_dir))
l_dir_install.append(src.Path(install_dir))
-
- return l_dir_install
+ return l_dir_install
def product_has_dir(product_info, without_dev=False):
:return: True if there is a source, build and install directory corresponding to the product described by product_info.
:rtype: boolean
"""
- if (src.product.product_is_native(product_info) or
- src.product.product_is_fixed(product_info)):
+ if src.product.product_is_native(product_info) or src.product.product_is_fixed(
+ product_info
+ ):
return False
if without_dev:
if src.product.product_is_dev(product_info):
return False
return True
-
+
+
def suppress_directories(l_paths, logger):
"""Suppress the paths given in the list in l_paths.
-
+
:param l_paths list: The list of Path to be suppressed
:param logger Logger: The logger instance to use for the display and logging
- """
+ """
for path in l_paths:
if not path.isdir():
- msg = _("Warning: the path %s does not "
- "exists (or is not a directory)\n" % path.__str__())
+ msg = _(
+ "Warning: the path %s does not "
+ "exists (or is not a directory)\n" % path.__str__()
+ )
logger.write(src.printcolors.printcWarning(msg), 1)
else:
logger.write(_("Removing %s ...") % path.__str__())
path.rm()
- logger.write('%s\n' % src.printcolors.printc(src.OK_STATUS), 3)
+ logger.write("%s\n" % src.printcolors.printc(src.OK_STATUS), 3)
+
def description():
"""method called when salomeTools is called with --help option.
-
+
:return: The text to display for the clean command description.
:rtype: str
"""
- return _("""\
+ return _(
+ """\
The clean command suppress the SOURCES, BUILD or INSTALL directories of the application products.
Use the options to define what directories you want to suppress and to set the list of products
example:
>> sat clean SALOME-xx --build --install --properties is_SALOME_module:yes
-""")
-
+"""
+ )
+
+
def run(args, runner, logger):
"""\
method called when salomeTools is called with clean parameter.
"""
-
+
# Parse the options
(options, args) = parser.parse_args(args)
# check that the command has been called with an application
- src.check_config_has_application( runner.cfg )
-
+ src.check_config_has_application(runner.cfg)
# Get the list of products to threat
products_infos = src.product.get_products_list(options, runner.cfg, logger)
# Construct the list of directories to suppress
l_dir_to_suppress = []
if options.all:
- l_dir_to_suppress += (get_source_directories(runner.cfg, products_infos,
- options.sources_without_dev) +
- get_build_directories(products_infos) +
- get_install_directories(runner.cfg, products_infos) +
- get_generated_directories(runner.cfg, products_infos) +
- get_package_directory(runner.cfg) )
+ l_dir_to_suppress += (
+ get_source_directories(
+ runner.cfg, products_infos, options.sources_without_dev
+ )
+ + get_build_directories(products_infos)
+ + get_install_directories(runner.cfg, products_infos)
+ + get_generated_directories(runner.cfg, products_infos)
+ + get_package_directory(runner.cfg)
+ )
else:
if options.install:
l_dir_to_suppress += get_install_directories(runner.cfg, products_infos)
-
+
if options.build:
l_dir_to_suppress += get_build_directories(products_infos)
-
+
if options.sources or options.sources_without_dev:
- l_dir_to_suppress += get_source_directories(runner.cfg, products_infos,
- options.sources_without_dev)
+ l_dir_to_suppress += get_source_directories(
+ runner.cfg, products_infos, options.sources_without_dev
+ )
if options.generated:
l_dir_to_suppress += get_generated_directories(runner.cfg, products_infos)
if options.package:
l_dir_to_suppress += get_package_directory(runner.cfg)
-
+
if len(l_dir_to_suppress) == 0:
logger.write(src.printcolors.printcWarning(_("Nothing to suppress\n")))
- logger.write(_("""\
+ logger.write(
+ _(
+ """\
Please specify what you want to suppress:
try 'sat --help clean' and 'sat clean ... --products ... --sources --build --install
-"""))
+"""
+ )
+ )
return
-
+
# Check with the user if he really wants to suppress the directories
if not runner.options.batch:
logger.write(_("Remove the following directories ?\n"), 1)
rep = input(_("Are you sure you want to continue? [Yes/No] "))
if rep.upper() != _("YES"):
return 0
-
+
# Suppress the list of paths
suppress_directories(l_dir_to_suppress, logger)
-
+
return 0
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2012 CEA/DEN
#
# This library is free software; you can redistribute it and/or
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
import os
-import re
import subprocess
import src
import src.debug as DBG
-# Compatibility python 2/3 for input function
-# input stays input for python 3 and input = raw_input for python 2
-try:
- input = raw_input
-except NameError:
- pass
-
-
# Define all possible option for the compile command : sat compile <options>
parser = src.options.Options()
-parser.add_option('p', 'products', 'list2', 'products',
- _('Optional: products to compile. This option accepts a comma separated list.'))
-parser.add_option('f', 'force', 'boolean', 'force',
- 'Optional: force the compilation of product, even if it is already installed. The BUILD directory is cleaned before compilation.')
-parser.add_option('u', 'update', 'boolean', 'update',
- 'Optional: update mode, compile only products which sources has changed, including the dependencies.')
-parser.add_option('', 'with_fathers', 'boolean', 'fathers',
- _("Optional: build all necessary products to the given product (KERNEL is "
- "build before building GUI)."), False)
-parser.add_option('', 'with_children', 'boolean', 'children',
- _("Optional: build all products using the given product (all SMESH plugins"
- " are build after SMESH)."), False)
-parser.add_option('', 'clean_all', 'boolean', 'clean_all',
+parser.add_option(
+ "p",
+ "products",
+ "list2",
+ "products",
+ _("Optional: products to compile. This option accepts a comma separated list."),
+)
+parser.add_option(
+ "f",
+ "force",
+ "boolean",
+ "force",
+ "Optional: force the compilation of product, even if it is already installed. The BUILD directory is cleaned before compilation.",
+)
+parser.add_option(
+ "u",
+ "update",
+ "boolean",
+ "update",
+ "Optional: update mode, compile only products which sources has changed, including the dependencies.",
+)
+parser.add_option(
+ "",
+ "with_fathers",
+ "boolean",
+ "fathers",
+ _(
+ "Optional: build all necessary products to the given product (KERNEL is "
+ "build before building GUI)."
+ ),
+ False,
+)
+parser.add_option(
+ "",
+ "with_children",
+ "boolean",
+ "children",
+ _(
+ "Optional: build all products using the given product (all SMESH plugins"
+ " are build after SMESH)."
+ ),
+ False,
+)
+parser.add_option(
+ "",
+ "clean_all",
+ "boolean",
+ "clean_all",
_("Optional: clean BUILD dir and INSTALL dir before building product."),
- False)
-parser.add_option('', 'clean_install', 'boolean', 'clean_install',
- _("Optional: clean INSTALL dir before building product."), False)
-parser.add_option('', 'make_flags', 'string', 'makeflags',
- _("Optional: add extra options to the 'make' command."))
-parser.add_option('', 'show', 'boolean', 'no_compile',
+ False,
+)
+parser.add_option(
+ "",
+ "clean_install",
+ "boolean",
+ "clean_install",
+ _("Optional: clean INSTALL dir before building product."),
+ False,
+)
+parser.add_option(
+ "",
+ "make_flags",
+ "string",
+ "makeflags",
+ _("Optional: add extra options to the 'make' command."),
+)
+parser.add_option(
+ "",
+ "show",
+ "boolean",
+ "no_compile",
_("Optional: DO NOT COMPILE just show if products are installed or not."),
- False)
-parser.add_option('', 'stop_first_fail', 'boolean', 'stop_first_fail', _(
- "Optional: Stops the command at first product compilation"
- " fail."), False)
-parser.add_option('', 'check', 'boolean', 'check', _(
- "Optional: execute the unit tests after compilation"), False)
+ False,
+)
+parser.add_option(
+ "",
+ "stop_first_fail",
+ "boolean",
+ "stop_first_fail",
+ _("Optional: Stops the command at first product compilation" " fail."),
+ False,
+)
+parser.add_option(
+ "",
+ "check",
+ "boolean",
+ "check",
+ _("Optional: execute the unit tests after compilation"),
+ False,
+)
-parser.add_option('', 'clean_build_after', 'boolean', 'clean_build_after',
- _('Optional: remove the build directory after successful compilation'), False)
+parser.add_option(
+ "",
+ "clean_build_after",
+ "boolean",
+ "clean_build_after",
+ _("Optional: remove the build directory after successful compilation"),
+ False,
+)
# from sat product infos, represent the product dependencies in a simple python graph
# keys are nodes, the list of dependencies are values
def get_dependencies_graph(p_infos, compile_time=True):
- graph={}
- for (p_name,p_info) in p_infos:
- depprod=[]
+ graph = {}
+ for (p_name, p_info) in p_infos:
+ depprod = []
for d in p_info.depend:
depprod.append(d)
if compile_time and "build_depend" in p_info:
for d in p_info.build_depend:
depprod.append(d)
- graph[p_name]=depprod
+ graph[p_name] = depprod
return graph
+
# this recursive function calculates all the dependencies of node start
def depth_search_graph(graph, start, visited=[]):
- visited= visited+ [start]
+ visited = visited + [start]
for node in graph[start]: # for all nodes in start dependencies
if node not in visited:
- visited=depth_search_graph(graph, node, visited)
+ visited = depth_search_graph(graph, node, visited)
return visited
+
# find a path from start node to end (a group of nodes)
def find_path_graph(graph, start, end, path=[]):
path = path + [start]
for node in graph[start]:
if node not in path:
newpath = find_path_graph(graph, node, end, path)
- if newpath: return newpath
+ if newpath:
+ return newpath
return None
+
# Topological sorting algo
# return in sorted_nodes the list of sorted nodes
def depth_first_topo_graph(graph, start, visited=[], sorted_nodes=[]):
if start not in graph:
# get more explicit error
where = [k for k in graph if start in graph[k]]
- raise src.SatException('Error in product dependencies : %s product is referenced in products dependencies, but is not present in the application, from %s' % (start, where))
+ raise src.SatException(
+ "Error in product dependencies : %s product is referenced in products dependencies, but is not present in the application, from %s"
+ % (start, where)
+ )
# may be in debug mode, continue loop to get all problems, (if comment raise)
# print("WARNING : %s product is referenced in products dependencies but is not present in the application, from %s" % (start, where))
# sorted_nodes = sorted_nodes + [start]
# return visited, sorted_nodes
for node in graph[start]:
if node not in visited:
- visited,sorted_nodes=depth_first_topo_graph(graph, node, visited,sorted_nodes)
+ visited, sorted_nodes = depth_first_topo_graph(
+ graph, node, visited, sorted_nodes
+ )
else:
if node not in sorted_nodes:
- raise src.SatException('Error in product dependencies : cycle detection for node %s and %s' % (start,node))
-
+ raise src.SatException(
+ "Error in product dependencies : cycle detection for node %s and %s"
+ % (start, node)
+ )
+
sorted_nodes = sorted_nodes + [start]
return visited, sorted_nodes
l_depends_not_installed = []
for prod in p_name_p_info[1]["depend_all"]:
# for each dependency, check the install
- prod_name, prod_info=all_products_dict[prod]
- if not(src.product.check_installation(config, prod_info)):
+ prod_name, prod_info = all_products_dict[prod]
+ if not (src.product.check_installation(config, prod_info)):
l_depends_not_installed.append(prod_name)
- return l_depends_not_installed # non installed deps
+ return l_depends_not_installed # non installed deps
+
def log_step(logger, header, step):
logger.write("\r%s%s" % (header, " " * 30), 3)
logger.write("\r%s%s" % (header, step), 3)
logger.flush()
+
def log_res_step(logger, res):
if res == 0:
logger.write("%s \n" % src.printcolors.printcSuccess("OK"), 4)
logger.write("%s \n" % src.printcolors.printcError("KO"), 4)
logger.flush()
-def compile_all_products(sat, config, options, products_infos, all_products_dict, all_products_graph, logger):
- '''Execute the proper configuration commands
+
+def compile_all_products(
+ sat, config, options, products_infos, all_products_dict, all_products_graph, logger
+):
+ """Execute the proper configuration commands
in each product build directory.
:param config Config: The global configuration
- :param products_info list: List of
+ :param products_info list: List of
(str, Config) => (product_name, product_info)
- :param all_products_dict: Dict of all products
- :param all_products_graph: graph of all products
+ :param all_products_dict: Dict of all products
+ :param all_products_graph: graph of all products
:param logger Logger: The logger instance to use for the display and logging
:return: the number of failing commands.
:rtype: int
- '''
- # first loop for the cleaning
- check_salome_configuration=False
- updated_products=[]
+ """
+ # first loop for the cleaning
+ check_salome_configuration = False
+ updated_products = []
for p_name_info in products_infos:
-
+
p_name, p_info = p_name_info
if src.product.product_is_salome(p_info):
- check_salome_configuration=True
-
+ check_salome_configuration = True
+
# nothing to clean for native or fixed products
- if (not src.product.product_compiles(p_info)) or\
- src.product.product_is_native(p_info) or\
- src.product.product_is_fixed(p_info):
+ if (
+ (not src.product.product_compiles(p_info))
+ or src.product.product_is_native(p_info)
+ or src.product.product_is_fixed(p_info)
+ ):
continue
- # Clean the build and the install directories
+ # Clean the build and the install directories
# if the corresponding options was called
if options.clean_all:
- sat.clean(config.VARS.application +
- " --products " + p_name +
- " --build --install",
- batch=True,
- verbose=0,
- logger_add_link = logger)
+ sat.clean(
+ config.VARS.application
+ + " --products "
+ + p_name
+ + " --build --install",
+ batch=True,
+ verbose=0,
+ logger_add_link=logger,
+ )
else:
- # Clean the the install directory
+ # Clean the the install directory
# if the corresponding option was called
if options.clean_install:
- sat.clean(config.VARS.application +
- " --products " + p_name +
- " --install",
- batch=True,
- verbose=0,
- logger_add_link = logger)
-
- # Clean the the install directory
+ sat.clean(
+ config.VARS.application + " --products " + p_name + " --install",
+ batch=True,
+ verbose=0,
+ logger_add_link=logger,
+ )
+
+ # Clean the the install directory
# if the corresponding option was called
if options.force:
- sat.clean(config.VARS.application +
- " --products " + p_name +
- " --build",
- batch=True,
- verbose=0,
- logger_add_link = logger)
+ sat.clean(
+ config.VARS.application + " --products " + p_name + " --build",
+ batch=True,
+ verbose=0,
+ logger_add_link=logger,
+ )
if options.update and src.product.product_is_vcs(p_info):
- # only VCS products are concerned by update option
- try:
- do_update=False
- if len(updated_products)>0:
- # if other products where updated, check that the current product is a child
+ # only VCS products are concerned by update option
+ try:
+ do_update = False
+ if len(updated_products) > 0:
+ # if other products where updated, check that the current product is a child
# in this case it will be also updated
- if find_path_graph(all_products_graph, p_name, updated_products):
+ if find_path_graph(
+ all_products_graph, p_name, updated_products
+ ):
logger.write("\nUpdate product %s (child)" % p_name, 5)
- do_update=True
- if (not do_update) and os.path.isdir(p_info.source_dir) \
- and os.path.isdir(p_info.install_dir):
- source_time=os.path.getmtime(p_info.source_dir)
- install_time=os.path.getmtime(p_info.install_dir)
- if install_time<source_time:
+ do_update = True
+ if (
+ (not do_update)
+ and os.path.isdir(p_info.source_dir)
+ and os.path.isdir(p_info.install_dir)
+ ):
+ source_time = os.path.getmtime(p_info.source_dir)
+ install_time = os.path.getmtime(p_info.install_dir)
+ if install_time < source_time:
logger.write("\nupdate product %s" % p_name, 5)
- do_update=True
+ do_update = True
if do_update:
- updated_products.append(p_name)
- sat.clean(config.VARS.application +
- " --products " + p_name +
- " --build --install",
- batch=True,
- verbose=0,
- logger_add_link = logger)
+ updated_products.append(p_name)
+ sat.clean(
+ config.VARS.application
+ + " --products "
+ + p_name
+ + " --build --install",
+ batch=True,
+ verbose=0,
+ logger_add_link=logger,
+ )
except:
pass
# For salome applications, we check if the sources of configuration modules are present
# configuration modules have the property "configure_dependency"
# they are implicit prerequisites of the compilation.
- res=0
+ res = 0
- # get the list of all modules in application
- all_products_infos = src.product.get_products_infos(config.APPLICATION.products,
- config)
+ # get the list of all modules in application
+ all_products_infos = src.product.get_products_infos(
+ config.APPLICATION.products, config
+ )
check_source = True
# for configuration modules, check if sources are present
for prod in all_products_dict:
if src.product.product_is_configuration(product_info):
check_source = check_source and src.product.check_source(product_info)
if not check_source:
- logger.write(_("\nERROR : SOURCES of %s not found! It is required for"
- " the configuration\n" % product_name))
- logger.write(_(" Get it with the command : sat prepare %s -p %s \n" %
- (config.APPLICATION.name, product_name)))
+ logger.write(
+ _(
+ "\nERROR : SOURCES of %s not found! It is required for"
+ " the configuration\n" % product_name
+ )
+ )
+ logger.write(
+ _(
+ " Get it with the command : sat prepare %s -p %s \n"
+ % (config.APPLICATION.name, product_name)
+ )
+ )
res += 1
- if res>0:
- return res # error configure dependency : we stop the compilation
+ if res > 0:
+ return res # error configure dependency : we stop the compilation
- # second loop to compile
+ # second loop to compile
res = 0
for p_name_info in products_infos:
-
+
p_name, p_info = p_name_info
-
+
# Logging
len_end_line = 30
header = _("Compilation of %s") % src.printcolors.printcLabel(p_name)
logger.write("\n", 3, False)
continue
-
# Recompute the product information to get the right install_dir
# (it could change if there is a clean of the install directory)
p_info = src.product.get_product_config(config, p_name)
-
+
# Check if sources was already successfully installed
check_source = src.product.check_source(p_info)
- is_pip= (src.appli_test_property(config,"pip", "yes") and src.product.product_test_property(p_info,"pip", "yes"))
- # don't check sources with option --show
+ is_pip = src.appli_test_property(
+ config, "pip", "yes"
+ ) and src.product.product_test_property(p_info, "pip", "yes")
+ # don't check sources with option --show
# or for products managed by pip (there sources are in wheels stored in LOCAL.ARCHIVE
- if not (options.no_compile or is_pip):
+ if not (options.no_compile or is_pip):
if not check_source:
- logger.write(_("Sources of product not found (try 'sat -h prepare') \n"))
- res += 1 # one more error
+ logger.write(
+ _("Sources of product not found (try 'sat -h prepare') \n")
+ )
+ res += 1 # one more error
continue
-
+
# if we don't force compilation, check if the was already successfully installed.
# we don't compile in this case.
if (not options.force) and src.product.check_installation(config, p_info):
logger.write(_(" in %s" % p_info.install_dir), 4)
logger.write(_("\n"))
continue
-
+
# If the show option was called, do not launch the compilation
if options.no_compile:
logger.write(_("Not installed in %s\n" % p_info.install_dir))
continue
-
+
# Check if the dependencies are installed
- l_depends_not_installed = check_dependencies(config, p_name_info, all_products_dict)
+ l_depends_not_installed = check_dependencies(
+ config, p_name_info, all_products_dict
+ )
if len(l_depends_not_installed) > 0:
log_step(logger, header, "")
- logger.write(src.printcolors.printcError(
- _("ERROR : the following mandatory product(s) is(are) not installed: ")))
+ logger.write(
+ src.printcolors.printcError(
+ _(
+ "ERROR : the following mandatory product(s) is(are) not installed: "
+ )
+ )
+ )
for prod_name in l_depends_not_installed:
logger.write(src.printcolors.printcError(prod_name + " "))
logger.write("\n")
continue
-
+
# Call the function to compile the product
res_prod, len_end_line, error_step = compile_product(
- sat, p_name_info, config, options, logger, header, len_end_line)
-
+ sat, p_name_info, config, options, logger, header, len_end_line
+ )
+
if res_prod != 0:
res += 1
# there was an error, we clean install dir, unless :
# - the error step is "check", or
# - the product is managed by pip and installed in python dir
- do_not_clean_install=False
- is_single_dir=(src.appli_test_property(config,"single_install_dir", "yes") and \
- src.product.product_test_property(p_info,"single_install_dir", "yes"))
-
- if (error_step == "CHECK") or (is_pip and src.appli_test_property(config,"pip_install_dir", "python")) or is_single_dir :
+ do_not_clean_install = False
+ is_single_dir = src.appli_test_property(
+ config, "single_install_dir", "yes"
+ ) and src.product.product_test_property(p_info, "single_install_dir", "yes")
+
+ if (
+ (error_step == "CHECK")
+ or (
+ is_pip
+ and src.appli_test_property(config, "pip_install_dir", "python")
+ )
+ or is_single_dir
+ ):
# cases for which we do not want to remove install dir
- # for is_single_dir and is_pip, the test to determine if the product is already
+ # for is_single_dir and is_pip, the test to determine if the product is already
# compiled is based on configuration file, not the directory
- do_not_clean_install=True
+ do_not_clean_install = True
if not do_not_clean_install:
# Clean the install directory if there is any
- logger.write(_(
- "Cleaning the install directory if there is any\n"),
- 5)
- sat.clean(config.VARS.application +
- " --products " + p_name +
- " --install",
- batch=True,
- verbose=0,
- logger_add_link = logger)
+ logger.write(_("Cleaning the install directory if there is any\n"), 5)
+ sat.clean(
+ config.VARS.application + " --products " + p_name + " --install",
+ batch=True,
+ verbose=0,
+ logger_add_link=logger,
+ )
else:
# Clean the build directory if the compilation and tests succeed
if options.clean_build_after:
log_step(logger, header, "CLEAN BUILD")
- sat.clean(config.VARS.application +
- " --products " + p_name +
- " --build",
- batch=True,
- verbose=0,
- logger_add_link = logger)
+ sat.clean(
+ config.VARS.application + " --products " + p_name + " --build",
+ batch=True,
+ verbose=0,
+ logger_add_link=logger,
+ )
# Log the result
if res_prod > 0:
logger.write("\r%s%s" % (header, " " * len_end_line), 3)
- logger.write("\r" + header + src.printcolors.printcError("KO ") + error_step)
- logger.write("\n==== %(KO)s in compile of %(name)s \n" %
- { "name" : p_name , "KO" : src.printcolors.printcInfo("ERROR")}, 4)
+ logger.write(
+ "\r" + header + src.printcolors.printcError("KO ") + error_step
+ )
+ logger.write(
+ "\n==== %(KO)s in compile of %(name)s \n"
+ % {"name": p_name, "KO": src.printcolors.printcInfo("ERROR")},
+ 4,
+ )
if error_step == "CHECK":
- logger.write(_("\nINSTALL directory = %s" %
- src.printcolors.printcInfo(p_info.install_dir)), 3)
+ logger.write(
+ _(
+ "\nINSTALL directory = %s"
+ % src.printcolors.printcInfo(p_info.install_dir)
+ ),
+ 3,
+ )
logger.flush()
else:
logger.write("\r%s%s" % (header, " " * len_end_line), 3)
logger.write("\r" + header + src.printcolors.printcSuccess("OK"))
- logger.write(_("\nINSTALL directory = %s" %
- src.printcolors.printcInfo(p_info.install_dir)), 3)
+ logger.write(
+ _(
+ "\nINSTALL directory = %s"
+ % src.printcolors.printcInfo(p_info.install_dir)
+ ),
+ 3,
+ )
logger.write("\n==== %s \n" % src.printcolors.printcInfo("OK"), 4)
- logger.write("\n==== Compilation of %(name)s %(OK)s \n" %
- { "name" : p_name , "OK" : src.printcolors.printcInfo("OK")}, 4)
+ logger.write(
+ "\n==== Compilation of %(name)s %(OK)s \n"
+ % {"name": p_name, "OK": src.printcolors.printcInfo("OK")},
+ 4,
+ )
logger.flush()
logger.write("\n", 3, False)
-
-
+
if res_prod != 0 and options.stop_first_fail:
break
-
+
return res
+
def compile_product(sat, p_name_info, config, options, logger, header, len_end):
- '''Execute the proper configuration command(s)
+ """Execute the proper configuration command(s)
in the product build directory.
-
+
:param p_name_info tuple: (str, Config) => (product_name, product_info)
:param config Config: The global configuration
- :param logger Logger: The logger instance to use for the display
+ :param logger Logger: The logger instance to use for the display
and logging
:param header Str: the header to display when logging
:param len_end Int: the lenght of the the end of line (used in display)
:return: 1 if it fails, else 0.
:rtype: int
- '''
-
+ """
+
p_name, p_info = p_name_info
-
- # Get the build procedure from the product configuration.
+
+ # Get the build procedure from the product configuration.
# It can be :
# build_sources : autotools -> build_configure, configure, make, make install
# build_sources : cmake -> cmake, make, make install
# build_sources : script -> script executions
res = 0
-
# check if pip should be used : the application and product have pip property
- if (src.appli_test_property(config,"pip", "yes") and
- src.product.product_test_property(p_info,"pip", "yes")):
- res, len_end_line, error_step = compile_product_pip(sat,
- p_name_info,
- config,
- options,
- logger,
- header,
- len_end)
+ if src.appli_test_property(
+ config, "pip", "yes"
+ ) and src.product.product_test_property(p_info, "pip", "yes"):
+ res, len_end_line, error_step = compile_product_pip(
+ sat, p_name_info, config, options, logger, header, len_end
+ )
else:
- if (src.product.product_is_autotools(p_info) or
- src.product.product_is_cmake(p_info)):
- res, len_end_line, error_step = compile_product_cmake_autotools(sat,
- p_name_info,
- config,
- options,
- logger,
- header,
- len_end)
+ if src.product.product_is_autotools(p_info) or src.product.product_is_cmake(
+ p_info
+ ):
+ res, len_end_line, error_step = compile_product_cmake_autotools(
+ sat, p_name_info, config, options, logger, header, len_end
+ )
if src.product.product_has_script(p_info):
- res, len_end_line, error_step = compile_product_script(sat,
- p_name_info,
- config,
- options,
- logger,
- header,
- len_end)
+ res, len_end_line, error_step = compile_product_script(
+ sat, p_name_info, config, options, logger, header, len_end
+ )
# Check that the install directory exists
- if res==0 and not(os.path.exists(p_info.install_dir)):
+ if res == 0 and not (os.path.exists(p_info.install_dir)):
res = 1
error_step = "NO INSTALL DIR"
- msg = _("Error: despite the fact that all the steps ended successfully,"
- " no install directory was found !")
+ msg = _(
+ "Error: despite the fact that all the steps ended successfully,"
+ " no install directory was found !"
+ )
logger.write(src.printcolors.printcError(msg), 4)
logger.write("\n", 4)
return res, len_end, error_step
-
- # Add the config file corresponding to the dependencies/versions of the
+
+ # Add the config file corresponding to the dependencies/versions of the
# product that have been successfully compiled
- if res==0:
+ if res == 0:
logger.write(_("Add the config file in installation directory\n"), 5)
# for git bases : add the description of git tag
- src_sha1=src.system.git_describe(p_info.source_dir)
+ src_sha1 = src.system.git_describe(p_info.source_dir)
if src_sha1:
- p_info.git_tag_description=src_sha1
+ p_info.git_tag_description = src_sha1
src.product.add_compile_config_file(p_info, config)
-
+
if options.check:
# Do the unit tests (call the check command)
log_step(logger, header, "CHECK")
res_check = sat.check(
- config.VARS.application + " --products " + p_name,
- verbose = 0,
- logger_add_link = logger)
+ config.VARS.application + " --products " + p_name,
+ verbose=0,
+ logger_add_link=logger,
+ )
if res_check != 0:
error_step = "CHECK"
-
+
res += res_check
-
+
return res, len_end_line, error_step
-def compile_product_pip(sat,
- p_name_info,
- config,
- options,
- logger,
- header,
- len_end):
- '''Execute the proper build procedure for pip products
+def compile_product_pip(sat, p_name_info, config, options, logger, header, len_end):
+ """Execute the proper build procedure for pip products
:param p_name_info tuple: (str, Config) => (product_name, product_info)
:param config Config: The global configuration
- :param logger Logger: The logger instance to use for the display
+ :param logger Logger: The logger instance to use for the display
and logging
:param header Str: the header to display when logging
:param len_end Int: the lenght of the the end of line (used in display)
:return: 1 if it fails, else 0.
:rtype: int
- '''
+ """
# pip needs openssl-dev. If openssl is declared in the application, we check it!
if "openssl" in config.APPLICATION.products:
openssl_cfg = src.product.get_product_config(config, "openssl")
if not src.product.check_installation(config, openssl_cfg):
- raise src.SatException(_("please install system openssl development package, it is required for products managed by pip."))
+ raise src.SatException(
+ _(
+ "please install system openssl development package, it is required for products managed by pip."
+ )
+ )
# a) initialisation
p_name, p_info = p_name_info
res = 0
error_step = ""
- pip_install_in_python=False
- pip_wheels_dir=os.path.join(config.LOCAL.archive_dir,"wheels")
- pip_install_cmd=config.INTERNAL.command.pip_install # parametrized in src/internal
+ pip_install_in_python = False
+ pip_wheels_dir = os.path.join(config.LOCAL.archive_dir, "wheels")
+ pip_install_cmd = (
+ config.INTERNAL.command.pip_install
+ ) # parametrized in src/internal
# b) get the build environment (useful to get the installed python & pip3)
- build_environ = src.environment.SalomeEnviron(config,
- src.environment.Environ(dict(os.environ)),
- True)
- environ_info = src.product.get_product_dependencies(config,
- p_name,
- p_info)
- build_environ.silent = (config.USER.output_verbose_level < 5)
+ build_environ = src.environment.SalomeEnviron(
+ config, src.environment.Environ(dict(os.environ)), True
+ )
+ environ_info = src.product.get_product_dependencies(config, p_name, p_info)
+ build_environ.silent = config.USER.output_verbose_level < 5
build_environ.set_full_environ(logger, environ_info)
# c- download : check/get pip wheel in pip_wheels_dir
- pip_download_cmd=config.INTERNAL.command.pip_download +\
- " --destination-directory %s --no-deps %s==%s " %\
- (pip_wheels_dir, p_info.name, p_info.version)
- logger.write("\n"+pip_download_cmd+"\n", 4, False)
- res_pip_dwl = (subprocess.call(pip_download_cmd,
- shell=True,
- cwd=config.LOCAL.workdir,
- env=build_environ.environ.environ,
- stdout=logger.logTxtFile,
- stderr=subprocess.STDOUT) == 0)
+ pip_download_cmd = (
+ config.INTERNAL.command.pip_download
+ + " --destination-directory %s --no-deps %s==%s "
+ % (pip_wheels_dir, p_info.name, p_info.version)
+ )
+ logger.write("\n" + pip_download_cmd + "\n", 4, False)
+ res_pip_dwl = (
+ subprocess.call(
+ pip_download_cmd,
+ shell=True,
+ cwd=config.LOCAL.workdir,
+ env=build_environ.environ.environ,
+ stdout=logger.logTxtFile,
+ stderr=subprocess.STDOUT,
+ )
+ == 0
+ )
# error is not managed at the stage. error will be handled by pip install
# here we just print a message
if not res_pip_dwl:
logger.write("Error in pip download\n", 4, False)
try:
pip_version_cmd = 'python -c "import pip;print(pip.__version__)"'
- res_pip_version = subprocess.check_output(pip_version_cmd,
- shell=True,
- cwd=config.LOCAL.workdir,
- env=build_environ.environ.environ,
- stderr=subprocess.STDOUT).strip()
- pip_build_options=res_pip_version.split('.')[0] < 21
+ res_pip_version = subprocess.check_output(
+ pip_version_cmd,
+ shell=True,
+ cwd=config.LOCAL.workdir,
+ env=build_environ.environ.environ,
+ stderr=subprocess.STDOUT,
+ ).strip()
+ pip_build_options = res_pip_version.split(".")[0] < 21
except:
- pip_build_options= True
+ pip_build_options = True
# d- install (in python or in separate product directory)
- if src.appli_test_property(config,"pip_install_dir", "python"):
+ if src.appli_test_property(config, "pip_install_dir", "python"):
# pip will install product in python directory"
if pip_build_options:
- pip_install_cmd+=" --find-links=%s --build %s %s==%s" %\
- (pip_wheels_dir, p_info.build_dir, p_info.name, p_info.version)
+ pip_install_cmd += " --find-links=%s --build %s %s==%s" % (
+ pip_wheels_dir,
+ p_info.build_dir,
+ p_info.name,
+ p_info.version,
+ )
else:
- pip_install_cmd+=" --find-links=%s --cache-dir %s %s==%s" %\
- (pip_wheels_dir, p_info.build_dir, p_info.name, p_info.version)
- pip_install_in_python=True
- else:
+ pip_install_cmd += " --find-links=%s --cache-dir %s %s==%s" % (
+ pip_wheels_dir,
+ p_info.build_dir,
+ p_info.name,
+ p_info.version,
+ )
+ pip_install_in_python = True
+ else:
# pip will install product in product install_dir
- pip_install_dir=os.path.join(p_info.install_dir, "lib", "python${PYTHON}", "site-packages")
+ pip_install_dir = os.path.join(
+ p_info.install_dir, "lib", "python${PYTHON}", "site-packages"
+ )
if pip_build_options:
- pip_install_cmd+=" --find-links=%s --build %s --target %s %s==%s" %\
- (pip_wheels_dir, p_info.build_dir, pip_install_dir, p_info.name, p_info.version)
+ pip_install_cmd += " --find-links=%s --build %s --target %s %s==%s" % (
+ pip_wheels_dir,
+ p_info.build_dir,
+ pip_install_dir,
+ p_info.name,
+ p_info.version,
+ )
else:
- pip_install_cmd+=" --find-links=%s --cache-dir %s --target %s %s==%s" %\
- (pip_wheels_dir, p_info.build_dir, pip_install_dir, p_info.name, p_info.version)
+ pip_install_cmd += " --find-links=%s --cache-dir %s --target %s %s==%s" % (
+ pip_wheels_dir,
+ p_info.build_dir,
+ pip_install_dir,
+ p_info.name,
+ p_info.version,
+ )
log_step(logger, header, "PIP")
- logger.write("\n"+pip_install_cmd+"\n", 4)
+ logger.write("\n" + pip_install_cmd + "\n", 4)
len_end_line = len_end + 3
error_step = ""
- res_pip = (subprocess.call(pip_install_cmd,
- shell=True,
- cwd=config.LOCAL.workdir,
- env=build_environ.environ.environ,
- stdout=logger.logTxtFile,
- stderr=subprocess.STDOUT) == 0)
+ res_pip = (
+ subprocess.call(
+ pip_install_cmd,
+ shell=True,
+ cwd=config.LOCAL.workdir,
+ env=build_environ.environ.environ,
+ stdout=logger.logTxtFile,
+ stderr=subprocess.STDOUT,
+ )
+ == 0
+ )
if res_pip:
- res=0
+ res = 0
else:
- #log_res_step(logger, res)
- res=1
+ # log_res_step(logger, res)
+ res = 1
error_step = "PIP"
- logger.write("\nError in pip command, please consult details with sat log command's internal traces\n", 3)
-
- return res, len_end_line, error_step
+ logger.write(
+ "\nError in pip command, please consult details with sat log command's internal traces\n",
+ 3,
+ )
+ return res, len_end_line, error_step
-def compile_product_cmake_autotools(sat,
- p_name_info,
- config,
- options,
- logger,
- header,
- len_end):
- '''Execute the proper build procedure for autotools or cmake
+def compile_product_cmake_autotools(
+ sat, p_name_info, config, options, logger, header, len_end
+):
+ """Execute the proper build procedure for autotools or cmake
in the product build directory.
-
+
:param p_name_info tuple: (str, Config) => (product_name, product_info)
:param config Config: The global configuration
- :param logger Logger: The logger instance to use for the display
+ :param logger Logger: The logger instance to use for the display
and logging
:param header Str: the header to display when logging
:param len_end Int: the lenght of the the end of line (used in display)
:return: 1 if it fails, else 0.
:rtype: int
- '''
+ """
p_name, p_info = p_name_info
-
+
# Execute "sat configure", "sat make" and "sat install"
res = 0
error_step = ""
-
+
# Logging and sat command call for configure step
len_end_line = len_end
log_step(logger, header, "CONFIGURE")
- res_c = sat.configure(config.VARS.application + " --products " + p_name,
- verbose = 0,
- logger_add_link = logger)
+ res_c = sat.configure(
+ config.VARS.application + " --products " + p_name,
+ verbose=0,
+ logger_add_link=logger,
+ )
log_res_step(logger, res_c)
res += res_c
-
+
if res_c > 0:
error_step = "CONFIGURE"
else:
# Logging and sat command call for make step
- # Logging take account of the fact that the product has a compilation
+ # Logging take account of the fact that the product has a compilation
# script or not
if src.product.product_has_script(p_info):
- # if the product has a compilation script,
+ # if the product has a compilation script,
# it is executed during make step
- scrit_path_display = src.printcolors.printcLabel(
- p_info.compil_script)
+ scrit_path_display = src.printcolors.printcLabel(p_info.compil_script)
log_step(logger, header, "SCRIPT " + scrit_path_display)
len_end_line = len(scrit_path_display)
else:
# Get the make_flags option if there is any
if options.makeflags:
make_arguments += " --option -j" + options.makeflags
- res_m = sat.make(make_arguments,
- verbose = 0,
- logger_add_link = logger)
+ res_m = sat.make(make_arguments, verbose=0, logger_add_link=logger)
log_res_step(logger, res_m)
res += res_m
-
+
if res_m > 0:
error_step = "MAKE"
- else:
+ else:
# Logging and sat command call for make install step
log_step(logger, header, "MAKE INSTALL")
- res_mi = sat.makeinstall(config.VARS.application +
- " --products " +
- p_name,
- verbose = 0,
- logger_add_link = logger)
+ res_mi = sat.makeinstall(
+ config.VARS.application + " --products " + p_name,
+ verbose=0,
+ logger_add_link=logger,
+ )
log_res_step(logger, res_mi)
res += res_mi
-
+
if res_mi > 0:
error_step = "MAKE INSTALL"
-
- return res, len_end_line, error_step
-
-def compile_product_script(sat,
- p_name_info,
- config,
- options,
- logger,
- header,
- len_end):
- '''Execute the script build procedure in the product build directory.
-
+
+ return res, len_end_line, error_step
+
+
+def compile_product_script(sat, p_name_info, config, options, logger, header, len_end):
+ """Execute the script build procedure in the product build directory.
+
:param p_name_info tuple: (str, Config) => (product_name, product_info)
:param config Config: The global configuration
- :param logger Logger: The logger instance to use for the display
+ :param logger Logger: The logger instance to use for the display
and logging
:param header Str: the header to display when logging
:param len_end Int: the lenght of the the end of line (used in display)
:return: 1 if it fails, else 0.
:rtype: int
- '''
+ """
p_name, p_info = p_name_info
-
+
# Execute "sat configure", "sat make" and "sat install"
error_step = ""
-
+
# Logging and sat command call for the script step
scrit_path_display = src.printcolors.printcLabel(p_info.compil_script)
log_step(logger, header, "SCRIPT " + scrit_path_display)
len_end_line = len_end + len(scrit_path_display)
- res = sat.script(config.VARS.application + " --products " + p_name,
- verbose = 0,
- logger_add_link = logger)
+ res = sat.script(
+ config.VARS.application + " --products " + p_name,
+ verbose=0,
+ logger_add_link=logger,
+ )
log_res_step(logger, res)
-
- return res, len_end_line, error_step
-
+ return res, len_end_line, error_step
+
+
def description():
- '''method that is called when salomeTools is called with --help option.
-
+ """method that is called when salomeTools is called with --help option.
+
:return: The text to display for the compile command description.
:rtype: str
- '''
- return _("The compile command constructs the products of the application"
- "\n\nexample:\nsat compile SALOME-master --products KERNEL,GUI,"
- "MEDCOUPLING --clean_all")
-
+ """
+ return _(
+ "The compile command constructs the products of the application"
+ "\n\nexample:\nsat compile SALOME-master --products KERNEL,GUI,"
+ "MEDCOUPLING --clean_all"
+ )
+
+
def run(args, runner, logger):
- '''method that is called when salomeTools is called with compile parameter.
- '''
+ """method that is called when salomeTools is called with compile parameter."""
# Parse the options
(options, args) = parser.parse_args(args)
- # Warn the user if he invoked the clean_all option
+ # Warn the user if he invoked the clean_all option
# without --products option
- if (options.clean_all and
- options.products is None and
- not runner.options.batch):
- rep = input(_("You used --clean_all without specifying a product"
- " are you sure you want to continue? [Yes/No] "))
+ if options.clean_all and options.products is None and not runner.options.batch:
+ rep = input(
+ _(
+ "You used --clean_all without specifying a product"
+ " are you sure you want to continue? [Yes/No] "
+ )
+ )
if rep.upper() != _("YES").upper():
return 0
-
+
if options.update and (options.clean_all or options.force or options.clean_install):
- options.update=False # update is useless in this case
+ options.update = False # update is useless in this case
# check that the command has been called with an application
- src.check_config_has_application( runner.cfg )
+ src.check_config_has_application(runner.cfg)
# write warning if platform is not declared as supported
- src.check_platform_is_supported( runner.cfg, logger )
+ src.check_platform_is_supported(runner.cfg, logger)
# Print some informations
- logger.write(_('Executing the compile commands in the build '
- 'directories of the products of '
- 'the application %s\n') %
- src.printcolors.printcLabel(runner.cfg.VARS.application), 1)
-
+ logger.write(
+ _(
+ "Executing the compile commands in the build "
+ "directories of the products of "
+ "the application %s\n"
+ )
+ % src.printcolors.printcLabel(runner.cfg.VARS.application),
+ 1,
+ )
+
info = [
- (_("SOURCE directory"),
- os.path.join(runner.cfg.APPLICATION.workdir, 'SOURCES')),
- (_("BUILD directory"),
- os.path.join(runner.cfg.APPLICATION.workdir, 'BUILD'))
- ]
+ (
+ _("SOURCE directory"),
+ os.path.join(runner.cfg.APPLICATION.workdir, "SOURCES"),
+ ),
+ (_("BUILD directory"), os.path.join(runner.cfg.APPLICATION.workdir, "BUILD")),
+ ]
src.print_info(logger, info)
# Get the list of all application products, and create its dependency graph
- all_products_infos = src.product.get_products_infos(runner.cfg.APPLICATION.products,
- runner.cfg)
- all_products_graph=get_dependencies_graph(all_products_infos)
- #logger.write("Dependency graph of all application products : %s\n" % all_products_graph, 6)
+ all_products_infos = src.product.get_products_infos(
+ runner.cfg.APPLICATION.products, runner.cfg
+ )
+ all_products_graph = get_dependencies_graph(all_products_infos)
+ # logger.write("Dependency graph of all application products : %s\n" % all_products_graph, 6)
DBG.write("Dependency graph of all application products : ", all_products_graph)
# Get the list of products we have to compile
products_infos = src.product.get_products_list(options, runner.cfg, logger)
products_list = [pi[0] for pi in products_infos]
- logger.write("Product we have to compile (as specified by user) : %s\n" % products_list, 5)
+ logger.write(
+ "Product we have to compile (as specified by user) : %s\n" % products_list, 5
+ )
if options.fathers:
# Extend the list with all recursive dependencies of the given products
- visited=[]
+ visited = []
for p_name in products_list:
- visited=depth_search_graph(all_products_graph, p_name, visited)
+ visited = depth_search_graph(all_products_graph, p_name, visited)
products_list = visited
logger.write("Product list to compile with fathers : %s\n" % products_list, 5)
if options.children:
# Extend the list with all products that depends upon the given products
- children=[]
+ children = []
for n in all_products_graph:
# for all products (that are not in products_list):
# if we we find a path from the product to the product list,
- # then we product is a child and we add it to the children list
+ # then we product is a child and we add it to the children list
if (n not in children) and (n not in products_list):
if find_path_graph(all_products_graph, n, products_list):
children = children + [n]
# Sort the list of all products (topological sort).
# the products listed first do not depend upon products listed after
- visited_nodes=[]
- sorted_nodes=[]
+ visited_nodes = []
+ sorted_nodes = []
for n in all_products_graph:
if n not in visited_nodes:
- visited_nodes,sorted_nodes=depth_first_topo_graph(all_products_graph, n, visited_nodes,sorted_nodes)
- logger.write("Complete dependency graph topological search (sorting): %s\n" % sorted_nodes, 6)
+ visited_nodes, sorted_nodes = depth_first_topo_graph(
+ all_products_graph, n, visited_nodes, sorted_nodes
+ )
+ logger.write(
+ "Complete dependency graph topological search (sorting): %s\n" % sorted_nodes, 6
+ )
# Create a dict of all products to facilitate products_infos sorting
- all_products_dict={}
- for (pname,pinfo) in all_products_infos:
- all_products_dict[pname]=(pname,pinfo)
+ all_products_dict = {}
+ for (pname, pinfo) in all_products_infos:
+ all_products_dict[pname] = (pname, pinfo)
# Use the sorted list of all products to sort the list of products we have to compile
- sorted_product_list=[]
- product_list_runtime=[]
- product_list_compiletime=[]
+ sorted_product_list = []
+ product_list_runtime = []
+ product_list_compiletime = []
# store at beginning compile time products, we need to compile them before!
for n in sorted_nodes:
if n in products_list:
sorted_product_list.append(n)
logger.write("Sorted list of products to compile : %s\n" % sorted_product_list, 5)
-
+
# from the sorted list of products to compile, build a sorted list of products infos
- products_infos=[]
+ products_infos = []
for product in sorted_product_list:
products_infos.append(all_products_dict[product])
- # for all products to compile, store in "depend_all" field the complete dependencies (recursive)
+ # for all products to compile, store in "depend_all" field the complete dependencies (recursive)
# (will be used by check_dependencies function)
for pi in products_infos:
- dep_prod=[]
- dep_prod=depth_search_graph(all_products_graph,pi[0], dep_prod)
- pi[1]["depend_all"]=dep_prod[1:]
-
+ dep_prod = []
+ dep_prod = depth_search_graph(all_products_graph, pi[0], dep_prod)
+ pi[1]["depend_all"] = dep_prod[1:]
# Call the function that will loop over all the products and execute
# the right command(s)
- res = compile_all_products(runner, runner.cfg, options, products_infos, all_products_dict, all_products_graph, logger)
-
+ res = compile_all_products(
+ runner,
+ runner.cfg,
+ options,
+ products_infos,
+ all_products_dict,
+ all_products_graph,
+ logger,
+ )
+
# Print the final state
nb_products = len(products_infos)
if res == 0:
final_status = "OK"
else:
final_status = "KO"
-
- logger.write(_("\nCompilation: %(status)s (%(valid_result)d/%(nb_products)d)\n") % \
- { 'status': src.printcolors.printc(final_status),
- 'valid_result': nb_products - res,
- 'nb_products': nb_products }, 1)
-
+
+ logger.write(
+ _("\nCompilation: %(status)s (%(valid_result)d/%(nb_products)d)\n")
+ % {
+ "status": src.printcolors.printc(final_status),
+ "valid_result": nb_products - res,
+ "nb_products": nb_products,
+ },
+ 1,
+ )
+
code = res
if code != 0:
code = 1
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2012 CEA/DEN
#
# This library is free software; you can redistribute it and/or
import datetime
import shutil
import gettext
-import pprint as PP
import src
import src.logger as LOG
logger = LOG.getDefaultLogger()
-verbose = False # True for debug
+verbose = False # True for debug
# internationalization
satdir = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
-gettext.install('salomeTools', os.path.join(satdir, 'src', 'i18n'))
+gettext.install("salomeTools", os.path.join(satdir, "src", "i18n"))
# Define all possible option for config command : sat config <options>
parser = src.options.Options()
-parser.add_option('v', 'value', 'string', 'value',
- _("Optional: print the value of CONFIG_VARIABLE."))
-parser.add_option('g', 'debug', 'string', 'debug',
- _("Optional: print the debugging mode value of CONFIG_VARIABLE."))
-parser.add_option('e', 'edit', 'boolean', 'edit',
- _("Optional: edit the product configuration file."))
-parser.add_option('i', 'info', 'list2', 'info',
- _("Optional: get information on product(s). This option accepts a comma separated list."))
-parser.add_option('p', 'products', 'list2', 'products',
- _("Optional: same as --info, for convenience."))
-parser.add_option('l', 'list', 'boolean', 'list',
- _("Optional: list all available applications."))
-parser.add_option('', 'show_patchs', 'boolean', 'show_patchs',
- _("Optional: synthetic list of all patches used in the application"))
-parser.add_option('', 'show_dependencies', 'boolean', 'show_dependencies',
- _("Optional: list of product dependencies in the application"))
-parser.add_option('', 'show_install', 'boolean', 'show_install',
- _("Optional: synthetic list of all install directories in the application"))
-parser.add_option('', 'show_properties', 'boolean', 'show_properties',
- _("Optional: synthetic list of all properties used in the application"))
-parser.add_option('', 'check_system', 'boolean', 'check_system',
- _("Optional: check if system products are installed"))
-parser.add_option('c', 'copy', 'boolean', 'copy',
- _("""Optional: copy a config file to the personal config files directory.
+parser.add_option(
+ "v", "value", "string", "value", _("Optional: print the value of CONFIG_VARIABLE.")
+)
+parser.add_option(
+ "g",
+ "debug",
+ "string",
+ "debug",
+ _("Optional: print the debugging mode value of CONFIG_VARIABLE."),
+)
+parser.add_option(
+ "e", "edit", "boolean", "edit", _("Optional: edit the product configuration file.")
+)
+parser.add_option(
+ "i",
+ "info",
+ "list2",
+ "info",
+ _(
+ "Optional: get information on product(s). This option accepts a comma separated list."
+ ),
+)
+parser.add_option(
+ "p",
+ "products",
+ "list2",
+ "products",
+ _("Optional: same as --info, for convenience."),
+)
+parser.add_option(
+ "l", "list", "boolean", "list", _("Optional: list all available applications.")
+)
+parser.add_option(
+ "",
+ "show_patchs",
+ "boolean",
+ "show_patchs",
+ _("Optional: synthetic list of all patches used in the application"),
+)
+parser.add_option(
+ "",
+ "show_dependencies",
+ "boolean",
+ "show_dependencies",
+ _("Optional: list of product dependencies in the application"),
+)
+parser.add_option(
+ "",
+ "show_install",
+ "boolean",
+ "show_install",
+ _("Optional: synthetic list of all install directories in the application"),
+)
+parser.add_option(
+ "",
+ "show_properties",
+ "boolean",
+ "show_properties",
+ _("Optional: synthetic list of all properties used in the application"),
+)
+parser.add_option(
+ "",
+ "check_system",
+ "boolean",
+ "check_system",
+ _("Optional: check if system products are installed"),
+)
+parser.add_option(
+ "c",
+ "copy",
+ "boolean",
+ "copy",
+ _(
+ """Optional: copy a config file to the personal config files directory.
WARNING: the included files are not copied.
-If a name is given the new config file takes the given name."""))
-parser.add_option('n', 'no_label', 'boolean', 'no_label',
- _("Internal use: do not print labels, Works only with --value and --list."))
-parser.add_option('', 'completion', 'boolean', 'completion',
- _("Internal use: print only keys, works only with --value."))
-parser.add_option('s', 'schema', 'boolean', 'schema',
- _("Internal use."))
+If a name is given the new config file takes the given name."""
+ ),
+)
+parser.add_option(
+ "n",
+ "no_label",
+ "boolean",
+ "no_label",
+ _("Internal use: do not print labels, Works only with --value and --list."),
+)
+parser.add_option(
+ "",
+ "completion",
+ "boolean",
+ "completion",
+ _("Internal use: print only keys, works only with --value."),
+)
+parser.add_option("s", "schema", "boolean", "schema", _("Internal use."))
+
def osJoin(*args):
- """
- shortcut wrapper to os.path.join
- plus optionaly print for debug
- """
- res = os.path.realpath(os.path.join(*args))
- if verbose:
- if True: # ".pyconf" in res:
- logger.info("osJoin %-80s in %s" % (res, CALN.caller_name(1)))
- return res
+ """
+ shortcut wrapper to os.path.join
+ plus optionaly print for debug
+ """
+ res = os.path.realpath(os.path.join(*args))
+ if verbose:
+ if True: # ".pyconf" in res:
+ logger.info("osJoin %-80s in %s" % (res, CALN.caller_name(1)))
+ return res
+
class ConfigOpener:
- '''Class that helps to find an application pyconf
- in all the possible directories (pathList)
- '''
+ """Class that helps to find an application pyconf
+ in all the possible directories (pathList)
+ """
+
def __init__(self, pathList):
- '''Initialization
-
+ """Initialization
+
:param pathList list: The list of paths where to search a pyconf.
- '''
+ """
self.pathList = pathList
if verbose:
- for path in pathList:
- if not os.path.isdir(path):
- logger.warning("ConfigOpener inexisting directory: %s" % path)
+ for path in pathList:
+ if not os.path.isdir(path):
+ logger.warning("ConfigOpener inexisting directory: %s" % path)
def __call__(self, name):
if os.path.isabs(name):
- return src.pyconf.ConfigInputStream(open(name, 'rb'))
+ return src.pyconf.ConfigInputStream(open(name, "rb"))
else:
- return src.pyconf.ConfigInputStream(open(osJoin(self.get_path(name), name), 'rb'))
+ return src.pyconf.ConfigInputStream(
+ open(osJoin(self.get_path(name), name), "rb")
+ )
raise IOError(_("Configuration file '%s' not found") % name)
- def get_path( self, name ):
- '''The method that returns the entire path of the pyconf searched
+ def get_path(self, name):
+ """The method that returns the entire path of the pyconf searched
returns first found in self.pathList directories
:param name str: The name of the searched pyconf.
- '''
+ """
for path in self.pathList:
if os.path.exists(osJoin(path, name)):
return path
raise IOError(_("Configuration file '%s' not found") % name)
+
class ConfigManager:
- '''Class that manages the read of all the configuration files of salomeTools
- '''
+ """Class that manages the read of all the configuration files of salomeTools"""
+
def __init__(self, datadir=None):
pass
def _create_vars(self, application=None, command=None, datadir=None):
- '''Create a dictionary that stores all information about machine,
+ """Create a dictionary that stores all information about machine,
user, date, repositories, etc...
-
+
:param application str: The application for which salomeTools is called.
:param command str: The command that is called.
- :param datadir str: The repository that contain external data
+ :param datadir str: The repository that contain external data
for salomeTools.
:return: The dictionary that stores all information.
:rtype: dict
- '''
- var = {}
- var['user'] = src.architecture.get_user()
- var['salometoolsway'] = os.path.dirname( os.path.dirname(os.path.abspath(__file__)))
- var['srcDir'] = osJoin(var['salometoolsway'], 'src')
- var['internal_dir'] = osJoin(var['srcDir'], 'internal_config')
- var['sep']= os.path.sep
+ """
+ var = {}
+ var["user"] = src.architecture.get_user()
+ var["salometoolsway"] = os.path.dirname(
+ os.path.dirname(os.path.abspath(__file__))
+ )
+ var["srcDir"] = osJoin(var["salometoolsway"], "src")
+ var["internal_dir"] = osJoin(var["srcDir"], "internal_config")
+ var["sep"] = os.path.sep
if src.architecture.is_windows():
- var['scriptExtension'] = '.bat'
+ var["scriptExtension"] = ".bat"
else:
- var['scriptExtension'] = '.sh'
-
+ var["scriptExtension"] = ".sh"
+
# datadir has a default location
- var['datadir'] = osJoin(var['salometoolsway'], 'data')
+ var["datadir"] = osJoin(var["salometoolsway"], "data")
if datadir is not None:
- var['datadir'] = datadir
+ var["datadir"] = datadir
- var['personalDir'] = osJoin(os.path.expanduser('~'), '.salomeTools')
- src.ensure_path_exists(var['personalDir'])
+ var["personalDir"] = osJoin(os.path.expanduser("~"), ".salomeTools")
+ src.ensure_path_exists(var["personalDir"])
- var['personal_applications_dir'] = osJoin(var['personalDir'], "Applications")
- src.ensure_path_exists(var['personal_applications_dir'])
-
- var['personal_products_dir'] = osJoin(var['personalDir'], "products")
- src.ensure_path_exists(var['personal_products_dir'])
-
- var['personal_archives_dir'] = osJoin(var['personalDir'], "Archives")
- src.ensure_path_exists(var['personal_archives_dir'])
+ var["personal_applications_dir"] = osJoin(var["personalDir"], "Applications")
+ src.ensure_path_exists(var["personal_applications_dir"])
- var['personal_jobs_dir'] = osJoin(var['personalDir'], "Jobs")
- src.ensure_path_exists(var['personal_jobs_dir'])
+ var["personal_products_dir"] = osJoin(var["personalDir"], "products")
+ src.ensure_path_exists(var["personal_products_dir"])
- var['personal_machines_dir'] = osJoin(var['personalDir'], "Machines")
- src.ensure_path_exists(var['personal_machines_dir'])
+ var["personal_archives_dir"] = osJoin(var["personalDir"], "Archives")
+ src.ensure_path_exists(var["personal_archives_dir"])
+
+ var["personal_jobs_dir"] = osJoin(var["personalDir"], "Jobs")
+ src.ensure_path_exists(var["personal_jobs_dir"])
+
+ var["personal_machines_dir"] = osJoin(var["personalDir"], "Machines")
+ src.ensure_path_exists(var["personal_machines_dir"])
# read linux distributions dictionary
- distrib_cfg = src.pyconf.Config( osJoin(var['srcDir'], 'internal_config', 'distrib.pyconf'))
-
+ distrib_cfg = src.pyconf.Config(
+ osJoin(var["srcDir"], "internal_config", "distrib.pyconf")
+ )
+
# set platform parameters
dist_name = src.architecture.get_distribution(codes=distrib_cfg.DISTRIBUTIONS)
dist_version = src.architecture.get_distrib_version(dist_name)
dist_version_full = src.architecture.get_version_XY()
dist = dist_name + dist_version
-
- var['dist_name'] = dist_name
- var['dist_version'] = dist_version
- var['dist'] = dist
- var['dist_ref'] = dist_name + dist_version_full
- var['python'] = src.architecture.get_python_version()
-
- var['nb_proc'] = src.architecture.get_nb_proc()
+
+ var["dist_name"] = dist_name
+ var["dist_version"] = dist_version
+ var["dist"] = dist
+ var["dist_ref"] = dist_name + dist_version_full
+ var["python"] = src.architecture.get_python_version()
+
+ var["nb_proc"] = src.architecture.get_nb_proc()
node_name = platform.node()
- var['node'] = node_name
- var['hostname'] = node_name
+ var["node"] = node_name
+ var["hostname"] = node_name
# set date parameters
dt = datetime.datetime.now()
- var['date'] = dt.strftime('%Y%m%d')
- var['datehour'] = dt.strftime('%Y%m%d_%H%M%S')
- var['hour'] = dt.strftime('%H%M%S')
-
- var['command'] = str(command)
- var['application'] = str(application)
-
- # Root dir for temporary files
- var['tmp_root'] = os.sep + 'tmp' + os.sep + var['user']
- # particular win case
- if src.architecture.is_windows() :
- var['tmp_root'] = os.path.expanduser('~') + os.sep + 'tmp'
-
+ var["date"] = dt.strftime("%Y%m%d")
+ var["datehour"] = dt.strftime("%Y%m%d_%H%M%S")
+ var["hour"] = dt.strftime("%H%M%S")
+
+ var["command"] = str(command)
+ var["application"] = str(application)
+
+ # Root dir for temporary files
+ var["tmp_root"] = os.sep + "tmp" + os.sep + var["user"]
+ # particular win case
+ if src.architecture.is_windows():
+ var["tmp_root"] = os.path.expanduser("~") + os.sep + "tmp"
+
return var
def get_command_line_overrides(self, options, sections):
- '''get all the overwrites that are in the command line
-
- :param options: the options from salomeTools class
+ """get all the overwrites that are in the command line
+
+ :param options: the options from salomeTools class
initialization (like -l5 or --overwrite)
:param sections str: The config section to overwrite.
:return: The list of all the overwrites to apply.
:rtype: list
- '''
- # when there are no options or not the overwrite option,
+ """
+ # when there are no options or not the overwrite option,
# return an empty list
if options is None or options.overwrite is None:
return []
-
+
over = []
for section in sections:
- # only overwrite the sections that correspond to the option
- over.extend(filter(lambda l: l.startswith(section + "."),
- options.overwrite))
+ # only overwrite the sections that correspond to the option
+ over.extend(
+ filter(lambda l: l.startswith(section + "."), options.overwrite)
+ )
return over
- def get_config(self, application=None, options=None, command=None,
- datadir=None):
- '''get the config from all the configuration files.
-
+ def get_config(self, application=None, options=None, command=None, datadir=None):
+ """get the config from all the configuration files.
+
:param application str: The application for which salomeTools is called.
:param options class Options: The general salomeToos
options (--overwrite or -l5, for example)
:param command str: The command that is called.
- :param datadir str: The repository that contain
+ :param datadir str: The repository that contain
external data for salomeTools.
:return: The final config.
:rtype: class 'src.pyconf.Config'
- '''
-
+ """
+
# create a ConfigMerger to handle merge
- merger = src.pyconf.ConfigMerger()#MergeHandler())
-
+ merger = src.pyconf.ConfigMerger() # MergeHandler())
+
# create the configuration instance
cfg = src.pyconf.Config()
-
+
# =====================================================================
# create VARS section
- var = self._create_vars(application=application, command=command, datadir=datadir)
+ var = self._create_vars(
+ application=application, command=command, datadir=datadir
+ )
# DBG.write("create_vars", var, DBG.isDeveloper())
# add VARS to config
cfg.VARS = src.pyconf.Mapping(cfg)
for variable in var:
cfg.VARS[variable] = var[variable]
-
+
# apply overwrite from command line if needed
for rule in self.get_command_line_overrides(options, ["VARS"]):
- exec('cfg.' + rule) # this cannot be factorized because of the exec
-
+ exec("cfg." + rule) # this cannot be factorized because of the exec
+
# =====================================================================
# Load INTERNAL config
# read src/internal_config/salomeTools.pyconf
- src.pyconf.streamOpener = ConfigOpener([
- osJoin(cfg.VARS.srcDir, 'internal_config')])
+ src.pyconf.streamOpener = ConfigOpener(
+ [osJoin(cfg.VARS.srcDir, "internal_config")]
+ )
try:
- if src.architecture.is_windows(): # special internal config for windows
- internal_cfg = src.pyconf.Config(open( osJoin(cfg.VARS.srcDir,
- 'internal_config', 'salomeTools_win.pyconf')))
+ if src.architecture.is_windows(): # special internal config for windows
+ internal_cfg = src.pyconf.Config(
+ open(
+ osJoin(
+ cfg.VARS.srcDir, "internal_config", "salomeTools_win.pyconf"
+ )
+ )
+ )
else:
- internal_cfg = src.pyconf.Config(open( osJoin(cfg.VARS.srcDir,
- 'internal_config', 'salomeTools.pyconf')))
+ internal_cfg = src.pyconf.Config(
+ open(
+ osJoin(cfg.VARS.srcDir, "internal_config", "salomeTools.pyconf")
+ )
+ )
except src.pyconf.ConfigError as e:
- raise src.SatException(_("Error in configuration file:"
- " salomeTools.pyconf\n %(error)s") % \
- {'error': str(e) })
-
+ raise src.SatException(
+ _("Error in configuration file:" " salomeTools.pyconf\n %(error)s")
+ % {"error": str(e)}
+ )
+
merger.merge(cfg, internal_cfg)
# apply overwrite from command line if needed
for rule in self.get_command_line_overrides(options, ["INTERNAL"]):
- exec('cfg.' + rule) # this cannot be factorized because of the exec
-
+ exec("cfg." + rule) # this cannot be factorized because of the exec
+
# =====================================================================
# Load LOCAL config file
# search only in the data directory
src.pyconf.streamOpener = ConfigOpener([cfg.VARS.datadir])
try:
- local_cfg = src.pyconf.Config(open( osJoin(cfg.VARS.datadir,
- 'local.pyconf')),
- PWD = ('LOCAL', cfg.VARS.datadir) )
+ local_cfg = src.pyconf.Config(
+ open(osJoin(cfg.VARS.datadir, "local.pyconf")),
+ PWD=("LOCAL", cfg.VARS.datadir),
+ )
except src.pyconf.ConfigError as e:
- raise src.SatException(_("Error in configuration file: "
- "local.pyconf\n %(error)s") % \
- {'error': str(e) })
+ raise src.SatException(
+ _("Error in configuration file: " "local.pyconf\n %(error)s")
+ % {"error": str(e)}
+ )
except IOError as error:
e = str(error)
- raise src.SatException( e );
+ raise src.SatException(e)
merger.merge(cfg, local_cfg)
# When the key is "default", put the default value
if cfg.LOCAL.base == "default":
- cfg.LOCAL.base = os.path.abspath(osJoin(cfg.VARS.salometoolsway, "..", "BASE"))
+ cfg.LOCAL.base = os.path.abspath(
+ osJoin(cfg.VARS.salometoolsway, "..", "BASE")
+ )
if cfg.LOCAL.workdir == "default":
cfg.LOCAL.workdir = os.path.abspath(osJoin(cfg.VARS.salometoolsway, ".."))
if cfg.LOCAL.log_dir == "default":
- cfg.LOCAL.log_dir = os.path.abspath(osJoin(cfg.VARS.salometoolsway, "..", "LOGS"))
+ cfg.LOCAL.log_dir = os.path.abspath(
+ osJoin(cfg.VARS.salometoolsway, "..", "LOGS")
+ )
if cfg.LOCAL.archive_dir == "default":
- cfg.LOCAL.archive_dir = os.path.abspath( osJoin(cfg.VARS.salometoolsway, "..", "ARCHIVES"))
+ cfg.LOCAL.archive_dir = os.path.abspath(
+ osJoin(cfg.VARS.salometoolsway, "..", "ARCHIVES")
+ )
# if the sat tag was not set permanently by user
if cfg.LOCAL.tag == "unknown":
# get the tag with git, and store it
- sat_version=src.system.git_describe(cfg.VARS.salometoolsway)
+ sat_version = src.system.git_describe(cfg.VARS.salometoolsway)
if sat_version == False:
- sat_version=cfg.INTERNAL.sat_version
- cfg.LOCAL.tag=sat_version
-
+ sat_version = cfg.INTERNAL.sat_version
+ cfg.LOCAL.tag = sat_version
# apply overwrite from command line if needed
for rule in self.get_command_line_overrides(options, ["LOCAL"]):
- exec('cfg.' + rule) # this cannot be factorized because of the exec
-
+ exec("cfg." + rule) # this cannot be factorized because of the exec
+
# =====================================================================
# Load the PROJECTS
projects_cfg = src.pyconf.Config()
- projects_cfg.addMapping("PROJECTS",
- src.pyconf.Mapping(projects_cfg),
- "The projects\n")
- projects_cfg.PROJECTS.addMapping("projects",
- src.pyconf.Mapping(cfg.PROJECTS),
- "The projects definition\n")
-
+ projects_cfg.addMapping(
+ "PROJECTS", src.pyconf.Mapping(projects_cfg), "The projects\n"
+ )
+ projects_cfg.PROJECTS.addMapping(
+ "projects", src.pyconf.Mapping(cfg.PROJECTS), "The projects definition\n"
+ )
+
for project_pyconf_path in cfg.PROJECTS.project_file_paths:
if not os.path.isabs(project_pyconf_path):
# for a relative path (archive case) we complete with sat path
- project_pyconf_path = os.path.join(cfg.VARS.salometoolsway,
- project_pyconf_path)
+ project_pyconf_path = os.path.join(
+ cfg.VARS.salometoolsway, project_pyconf_path
+ )
if not os.path.exists(project_pyconf_path):
- msg = _("WARNING: The project file %s cannot be found. "
- "It will be ignored\n" % project_pyconf_path)
+ msg = _(
+ "WARNING: The project file %s cannot be found. "
+ "It will be ignored\n" % project_pyconf_path
+ )
sys.stdout.write(msg)
continue
- project_name = os.path.basename(
- project_pyconf_path)[:-len(".pyconf")]
+ project_name = os.path.basename(project_pyconf_path)[: -len(".pyconf")]
try:
project_pyconf_dir = os.path.dirname(project_pyconf_path)
- project_cfg = src.pyconf.Config(open(project_pyconf_path),
- PWD=("", project_pyconf_dir))
+ project_cfg = src.pyconf.Config(
+ open(project_pyconf_path), PWD=("", project_pyconf_dir)
+ )
except Exception as e:
- msg = _("ERROR: Error in configuration file: "
- "%(file_path)s\n %(error)s\n") % \
- {'file_path' : project_pyconf_path, 'error': str(e) }
+ msg = _(
+ "ERROR: Error in configuration file: "
+ "%(file_path)s\n %(error)s\n"
+ ) % {"file_path": project_pyconf_path, "error": str(e)}
sys.stdout.write(msg)
continue
- projects_cfg.PROJECTS.projects.addMapping(project_name,
- src.pyconf.Mapping(projects_cfg.PROJECTS.projects),
- "The %s project\n" % project_name)
- projects_cfg.PROJECTS.projects[project_name]=project_cfg
- projects_cfg.PROJECTS.projects[project_name]["file_path"] = \
- project_pyconf_path
+ projects_cfg.PROJECTS.projects.addMapping(
+ project_name,
+ src.pyconf.Mapping(projects_cfg.PROJECTS.projects),
+ "The %s project\n" % project_name,
+ )
+ projects_cfg.PROJECTS.projects[project_name] = project_cfg
+ projects_cfg.PROJECTS.projects[project_name][
+ "file_path"
+ ] = project_pyconf_path
# store the project tag if any
- product_project_git_tag = src.system.git_describe(os.path.dirname(project_pyconf_path))
+ product_project_git_tag = src.system.git_describe(
+ os.path.dirname(project_pyconf_path)
+ )
if product_project_git_tag:
- projects_cfg.PROJECTS.projects[project_name]["git_tag"] = product_project_git_tag
+ projects_cfg.PROJECTS.projects[project_name][
+ "git_tag"
+ ] = product_project_git_tag
else:
projects_cfg.PROJECTS.projects[project_name]["git_tag"] = "unknown"
-
+
merger.merge(cfg, projects_cfg)
# apply overwrite from command line if needed
for rule in self.get_command_line_overrides(options, ["PROJECTS"]):
- exec('cfg.' + rule) # this cannot be factorized because of the exec
-
+ exec("cfg." + rule) # this cannot be factorized because of the exec
+
# =====================================================================
- # Create the paths where to search the application configurations,
- # the product configurations, the products archives,
+ # Create the paths where to search the application configurations,
+ # the product configurations, the products archives,
# the jobs configurations and the machines configurations
cfg.addMapping("PATHS", src.pyconf.Mapping(cfg), "The paths\n")
cfg.PATHS["APPLICATIONPATH"] = src.pyconf.Sequence(cfg.PATHS)
cfg.PATHS.APPLICATIONPATH.append(cfg.VARS.personal_applications_dir, "")
-
cfg.PATHS["PRODUCTPATH"] = src.pyconf.Sequence(cfg.PATHS)
cfg.PATHS.PRODUCTPATH.append(cfg.VARS.personal_products_dir, "")
cfg.PATHS["ARCHIVEPATH"] = src.pyconf.Sequence(cfg.PATHS)
# Loop over the projects in order to complete the PATHS variables
# as /data/tmpsalome/salome/prerequis/archives for example ARCHIVEPATH
for project in cfg.PROJECTS.projects:
- for PATH in ["APPLICATIONPATH",
- "PRODUCTPATH",
- "ARCHIVEPATH", #comment this for default archive #8646
- "ARCHIVEFTP",
- "JOBPATH",
- "MACHINEPATH",
- "LICENCEPATH"]:
+ for PATH in [
+ "APPLICATIONPATH",
+ "PRODUCTPATH",
+ "ARCHIVEPATH", # comment this for default archive #8646
+ "ARCHIVEFTP",
+ "JOBPATH",
+ "MACHINEPATH",
+ "LICENCEPATH",
+ ]:
if PATH not in cfg.PROJECTS.projects[project]:
continue
- pathlist=cfg.PROJECTS.projects[project][PATH].split(":")
+ pathlist = cfg.PROJECTS.projects[project][PATH].split(":")
for path in pathlist:
cfg.PATHS[PATH].append(path, "")
-
+
# apply overwrite from command line if needed
for rule in self.get_command_line_overrides(options, ["PATHS"]):
- exec('cfg.' + rule) # this cannot be factorized because of the exec
+ exec("cfg." + rule) # this cannot be factorized because of the exec
# AT END append APPLI_TEST directory in APPLICATIONPATH, for unittest
- appli_test_dir = osJoin(satdir, "test", "APPLI_TEST")
+ appli_test_dir = osJoin(satdir, "test", "APPLI_TEST")
if appli_test_dir not in cfg.PATHS.APPLICATIONPATH:
- cfg.PATHS.APPLICATIONPATH.append(appli_test_dir, "unittest APPLI_TEST path")
+ cfg.PATHS.APPLICATIONPATH.append(appli_test_dir, "unittest APPLI_TEST path")
# =====================================================================
# Load APPLICATION config file
src.pyconf.streamOpener = ConfigOpener(cp)
do_merge = True
try:
- application_cfg = src.pyconf.Config(application + '.pyconf')
+ application_cfg = src.pyconf.Config(application + ".pyconf")
except IOError as e:
raise src.SatException(
- _("%s, use 'config --list' to get the list of available applications.") % e)
+ _(
+ "%s, use 'config --list' to get the list of available applications."
+ )
+ % e
+ )
except src.pyconf.ConfigError as e:
- if (not ('-e' in parser.parse_args()[1])
- or ('--edit' in parser.parse_args()[1])
- and command == 'config'):
- raise src.SatException(_("Error in configuration file: "
- "%(application)s.pyconf\n "
- " %(error)s") % \
- { 'application': application, 'error': str(e) } )
+ if (
+ not ("-e" in parser.parse_args()[1])
+ or ("--edit" in parser.parse_args()[1])
+ and command == "config"
+ ):
+ raise src.SatException(
+ _(
+ "Error in configuration file: "
+ "%(application)s.pyconf\n "
+ " %(error)s"
+ )
+ % {"application": application, "error": str(e)}
+ )
else:
- sys.stdout.write(src.printcolors.printcWarning(
- "There is an error in the file"
- " %s.pyconf.\n" % cfg.VARS.application))
+ sys.stdout.write(
+ src.printcolors.printcWarning(
+ "There is an error in the file"
+ " %s.pyconf.\n" % cfg.VARS.application
+ )
+ )
do_merge = False
except Exception as e:
- if (not ('-e' in parser.parse_args()[1])
- or ('--edit' in parser.parse_args()[1])
- and command == 'config'):
+ if (
+ not ("-e" in parser.parse_args()[1])
+ or ("--edit" in parser.parse_args()[1])
+ and command == "config"
+ ):
sys.stdout.write(src.printcolors.printcWarning("%s\n" % str(e)))
- raise src.SatException(_("Error in configuration file:"
- " %(application)s.pyconf\n") % \
- { 'application': application} )
+ raise src.SatException(
+ _("Error in configuration file:" " %(application)s.pyconf\n")
+ % {"application": application}
+ )
else:
- sys.stdout.write(src.printcolors.printcWarning(
- "There is an error in the file"
- " %s.pyconf. Opening the file with the"
- " default viewer\n" % cfg.VARS.application))
- sys.stdout.write("The error:"
- " %s\n" % src.printcolors.printcWarning(
- str(e)))
+ sys.stdout.write(
+ src.printcolors.printcWarning(
+ "There is an error in the file"
+ " %s.pyconf. Opening the file with the"
+ " default viewer\n" % cfg.VARS.application
+ )
+ )
+ sys.stdout.write(
+ "The error:" " %s\n" % src.printcolors.printcWarning(str(e))
+ )
do_merge = False
-
+
else:
- cfg['open_application'] = 'yes'
+ cfg["open_application"] = "yes"
# =====================================================================
# Load product config files in PRODUCTS section
products_cfg = src.pyconf.Config()
- products_cfg.addMapping("PRODUCTS",
- src.pyconf.Mapping(products_cfg),
- "The products\n")
+ products_cfg.addMapping(
+ "PRODUCTS", src.pyconf.Mapping(products_cfg), "The products\n"
+ )
if application is not None:
src.pyconf.streamOpener = ConfigOpener(cfg.PATHS.PRODUCTPATH)
for product_name in application_cfg.APPLICATION.products.keys():
# Loop on all files that are in softsDir directory
# and read their config
product_file_name = product_name + ".pyconf"
- product_file_path = src.find_file_in_lpath(product_file_name, cfg.PATHS.PRODUCTPATH)
+ product_file_path = src.find_file_in_lpath(
+ product_file_name, cfg.PATHS.PRODUCTPATH
+ )
if product_file_path:
products_dir = os.path.dirname(product_file_path)
# for a relative path (archive case) we complete with sat path
if not os.path.isabs(products_dir):
- products_dir = os.path.join(cfg.VARS.salometoolsway,
- products_dir)
+ products_dir = os.path.join(
+ cfg.VARS.salometoolsway, products_dir
+ )
try:
- prod_cfg = src.pyconf.Config(open(product_file_path),
- PWD=("", products_dir))
+ prod_cfg = src.pyconf.Config(
+ open(product_file_path), PWD=("", products_dir)
+ )
prod_cfg.from_file = product_file_path
products_cfg.PRODUCTS[product_name] = prod_cfg
except Exception as e:
msg = _(
"WARNING: Error in configuration file"
- ": %(prod)s\n %(error)s" % \
- {'prod' : product_name, 'error': str(e) })
+ ": %(prod)s\n %(error)s"
+ % {"prod": product_name, "error": str(e)}
+ )
sys.stdout.write(msg)
-
+
merger.merge(cfg, products_cfg)
-
+
# apply overwrite from command line if needed
for rule in self.get_command_line_overrides(options, ["PRODUCTS"]):
- exec('cfg.' + rule) # this cannot be factorized because of the exec
-
+ exec("cfg." + rule) # this cannot be factorized because of the exec
+
if do_merge:
merger.merge(cfg, application_cfg)
# default launcher name ('salome')
- if ('profile' in cfg.APPLICATION and
- 'launcher_name' not in cfg.APPLICATION.profile):
- cfg.APPLICATION.profile.launcher_name = 'salome'
+ if (
+ "profile" in cfg.APPLICATION
+ and "launcher_name" not in cfg.APPLICATION.profile
+ ):
+ cfg.APPLICATION.profile.launcher_name = "salome"
# apply overwrite from command line if needed
- for rule in self.get_command_line_overrides(options,
- ["APPLICATION"]):
+ for rule in self.get_command_line_overrides(options, ["APPLICATION"]):
# this cannot be factorized because of the exec
- exec('cfg.' + rule)
-
+ exec("cfg." + rule)
+
# =====================================================================
# load USER config
self.set_user_config_file(cfg)
# apply overwrite from command line if needed
for rule in self.get_command_line_overrides(options, ["USER"]):
- exec('cfg.' + rule) # this cannot be factorize because of the exec
-
+ exec("cfg." + rule) # this cannot be factorize because of the exec
+
# remove application products "blacklisted" in rm_products field
if "APPLICATION" in cfg and "rm_products" in cfg.APPLICATION:
for prod_to_remove in cfg.APPLICATION.rm_products:
return cfg
def set_user_config_file(self, config):
- '''Set the user config file name and path.
+ """Set the user config file name and path.
If necessary, build it from another one or create it from scratch.
-
- :param config class 'src.pyconf.Config': The global config
+
+ :param config class 'src.pyconf.Config': The global config
(containing all pyconf).
- '''
+ """
# get the expected name and path of the file
- self.config_file_name = 'SAT.pyconf'
- self.user_config_file_path = osJoin(config.VARS.personalDir, self.config_file_name)
-
+ self.config_file_name = "SAT.pyconf"
+ self.user_config_file_path = osJoin(
+ config.VARS.personalDir, self.config_file_name
+ )
+
# if pyconf does not exist, create it from scratch
- if not os.path.isfile(self.user_config_file_path):
+ if not os.path.isfile(self.user_config_file_path):
self.create_config_file(config)
-
+
def create_config_file(self, config):
- '''This method is called when there are no user config file.
+ """This method is called when there are no user config file.
It build it from scratch.
-
+
:param config class 'src.pyconf.Config': The global config.
:return: the config corresponding to the file created.
:rtype: config class 'src.pyconf.Config'
- '''
-
+ """
+
cfg_name = self.get_user_config_file()
user_cfg = src.pyconf.Config()
#
- user_cfg.addMapping('USER', src.pyconf.Mapping(user_cfg), "")
-
- user_cfg.USER.addMapping('cvs_user', config.VARS.user,
- "This is the user name used to access salome cvs base.\n")
- user_cfg.USER.addMapping('svn_user', config.VARS.user,
- "This is the user name used to access salome svn base.\n")
- user_cfg.USER.addMapping('output_verbose_level', 3,
+ user_cfg.addMapping("USER", src.pyconf.Mapping(user_cfg), "")
+
+ user_cfg.USER.addMapping(
+ "cvs_user",
+ config.VARS.user,
+ "This is the user name used to access salome cvs base.\n",
+ )
+ user_cfg.USER.addMapping(
+ "svn_user",
+ config.VARS.user,
+ "This is the user name used to access salome svn base.\n",
+ )
+ user_cfg.USER.addMapping(
+ "output_verbose_level",
+ 3,
"This is the default output_verbose_level you want."
- " 0=>no output, 5=>debug.\n")
- user_cfg.USER.addMapping('publish_dir',
- osJoin(os.path.expanduser('~'),
- 'websupport',
- 'satreport'),
- "")
- user_cfg.USER.addMapping('editor',
- 'vi',
- "This is the editor used to "
- "modify configuration files\n")
- user_cfg.USER.addMapping('browser',
- 'firefox',
- "This is the browser used to "
- "read html documentation\n")
- user_cfg.USER.addMapping('pdf_viewer',
- 'evince',
- "This is the pdf_viewer used "
- "to read pdf documentation\n")
+ " 0=>no output, 5=>debug.\n",
+ )
+ user_cfg.USER.addMapping(
+ "publish_dir",
+ osJoin(os.path.expanduser("~"), "websupport", "satreport"),
+ "",
+ )
+ user_cfg.USER.addMapping(
+ "editor", "vi", "This is the editor used to " "modify configuration files\n"
+ )
+ user_cfg.USER.addMapping(
+ "browser",
+ "firefox",
+ "This is the browser used to " "read html documentation\n",
+ )
+ user_cfg.USER.addMapping(
+ "pdf_viewer",
+ "evince",
+ "This is the pdf_viewer used " "to read pdf documentation\n",
+ )
src.ensure_path_exists(config.VARS.personalDir)
- src.ensure_path_exists( osJoin(config.VARS.personalDir,
- 'Applications'))
+ src.ensure_path_exists(osJoin(config.VARS.personalDir, "Applications"))
- f = open(cfg_name, 'w')
+ f = open(cfg_name, "w")
user_cfg.__save__(f)
f.close()
- return user_cfg
+ return user_cfg
def get_user_config_file(self):
- '''Get the user config file
+ """Get the user config file
:return: path to the user config file.
:rtype: str
- '''
+ """
if not self.user_config_file_path:
- raise src.SatException(_("Error in get_user_config_file: "
- "missing user config file path"))
- return self.user_config_file_path
+ raise src.SatException(
+ _("Error in get_user_config_file: " "missing user config file path")
+ )
+ return self.user_config_file_path
+
def check_path(path, ext=[]):
- '''Construct a text with the input path and "not found" if it does not
+ """Construct a text with the input path and "not found" if it does not
exist.
-
+
:param path Str: the path to check.
- :param ext List: An extension. Verify that the path extension
+ :param ext List: An extension. Verify that the path extension
is in the list
:return: The string of the path with information
:rtype: Str
- '''
+ """
# check if file exists
if not os.path.exists(path):
- return "'%s'" % path + " " + src.printcolors.printcError(_(
- "** not found"))
+ return "'%s'" % path + " " + src.printcolors.printcError(_("** not found"))
# check extension
if len(ext) > 0:
fe = os.path.splitext(path)[1].lower()
if fe not in ext:
- return "'%s'" % path + " " + src.printcolors.printcError(_(
- "** bad extension"))
+ return (
+ "'%s'" % path + " " + src.printcolors.printcError(_("** bad extension"))
+ )
return path
+
def show_product_info(config, name, logger):
- '''Display on the terminal and logger information about a product.
-
+ """Display on the terminal and logger information about a product.
+
:param config Config: the global configuration.
:param name Str: The name of the product
:param logger Logger: The logger instance to use for the display
- '''
-
+ """
+
logger.write(_("%s is a product\n") % src.printcolors.printcLabel(name), 2)
pinfo = src.product.get_product_config(config, name)
-
+
if "depend" in pinfo:
src.printcolors.print_value(logger, "depends on", sorted(pinfo.depend), 2)
src.printcolors.print_value(logger, "optional", sorted(pinfo.opt_depend), 2)
if "build_depend" in pinfo:
- src.printcolors.print_value(logger, "build depend on", sorted(pinfo.build_depend), 2)
-
+ src.printcolors.print_value(
+ logger, "build depend on", sorted(pinfo.build_depend), 2
+ )
# information on pyconf
logger.write("\n", 2)
logger.write(src.printcolors.printcLabel("configuration:") + "\n", 2)
if "from_file" in pinfo:
- src.printcolors.print_value(logger,
- "pyconf file path",
- pinfo.from_file,
- 2)
+ src.printcolors.print_value(logger, "pyconf file path", pinfo.from_file, 2)
if "section" in pinfo:
- src.printcolors.print_value(logger,
- "section",
- pinfo.section,
- 2)
+ src.printcolors.print_value(logger, "section", pinfo.section, 2)
# information on prepare
logger.write("\n", 2)
method += " (dev)"
src.printcolors.print_value(logger, "get method", method, 2)
- if method == 'cvs':
+ if method == "cvs":
src.printcolors.print_value(logger, "server", pinfo.cvs_info.server, 2)
- src.printcolors.print_value(logger, "base module",
- pinfo.cvs_info.module_base, 2)
+ src.printcolors.print_value(
+ logger, "base module", pinfo.cvs_info.module_base, 2
+ )
src.printcolors.print_value(logger, "source", pinfo.cvs_info.source, 2)
src.printcolors.print_value(logger, "tag", pinfo.cvs_info.tag, 2)
- elif method == 'svn':
+ elif method == "svn":
src.printcolors.print_value(logger, "repo", pinfo.svn_info.repo, 2)
- elif method == 'git':
+ elif method == "git":
src.printcolors.print_value(logger, "repo", pinfo.git_info.repo, 2)
src.printcolors.print_value(logger, "tag", pinfo.git_info.tag, 2)
- elif method == 'archive':
- src.printcolors.print_value(logger,
- "get from",
- check_path(pinfo.archive_info.archive_name),
- 2)
+ elif method == "archive":
+ src.printcolors.print_value(
+ logger, "get from", check_path(pinfo.archive_info.archive_name), 2
+ )
- if 'patches' in pinfo:
+ if "patches" in pinfo:
for patch in pinfo.patches:
src.printcolors.print_value(logger, "patch", check_path(patch), 2)
if src.product.product_is_fixed(pinfo):
- src.printcolors.print_value(logger, "install_dir",
- check_path(pinfo.install_dir), 2)
+ src.printcolors.print_value(
+ logger, "install_dir", check_path(pinfo.install_dir), 2
+ )
if src.product.product_is_native(pinfo) or src.product.product_is_fixed(pinfo):
return
-
+
# information on compilation
if src.product.product_compiles(pinfo):
logger.write("\n", 2)
logger.write(src.printcolors.printcLabel("compile:") + "\n", 2)
- src.printcolors.print_value(logger,
- "compilation method",
- pinfo.build_source,
- 2)
-
+ src.printcolors.print_value(logger, "compilation method", pinfo.build_source, 2)
+
if pinfo.build_source == "script" and "compil_script" in pinfo:
- src.printcolors.print_value(logger,
- "Compilation script",
- pinfo.compil_script,
- 2)
-
- if 'nb_proc' in pinfo:
+ src.printcolors.print_value(
+ logger, "Compilation script", pinfo.compil_script, 2
+ )
+
+ if "nb_proc" in pinfo:
src.printcolors.print_value(logger, "make -j", pinfo.nb_proc, 2)
-
- src.printcolors.print_value(logger,
- "source dir",
- check_path(pinfo.source_dir),
- 2)
- if 'install_dir' in pinfo:
- src.printcolors.print_value(logger,
- "build dir",
- check_path(pinfo.build_dir),
- 2)
- src.printcolors.print_value(logger,
- "install dir",
- check_path(pinfo.install_dir),
- 2)
+
+ src.printcolors.print_value(
+ logger, "source dir", check_path(pinfo.source_dir), 2
+ )
+ if "install_dir" in pinfo:
+ src.printcolors.print_value(
+ logger, "build dir", check_path(pinfo.build_dir), 2
+ )
+ src.printcolors.print_value(
+ logger, "install dir", check_path(pinfo.install_dir), 2
+ )
else:
- logger.write(" " +
- src.printcolors.printcWarning(_("no install dir")) +
- "\n", 2)
+ logger.write(
+ " " + src.printcolors.printcWarning(_("no install dir")) + "\n", 2
+ )
src.printcolors.print_value(logger, "debug ", pinfo.debug, 2)
src.printcolors.print_value(logger, "verbose ", pinfo.verbose, 2)
logger.write("\n", 2)
logger.write(src.printcolors.printcLabel("environ :") + "\n", 2)
if "environ" in pinfo and "env_script" in pinfo.environ:
- src.printcolors.print_value(logger,
- "script",
- check_path(pinfo.environ.env_script),
- 2)
+ src.printcolors.print_value(
+ logger, "script", check_path(pinfo.environ.env_script), 2
+ )
# display run-time environment
- zz = src.environment.SalomeEnviron(config,
- src.fileEnviron.ScreenEnviron(logger),
- False)
+ zz = src.environment.SalomeEnviron(
+ config, src.fileEnviron.ScreenEnviron(logger), False
+ )
zz.set_python_libdirs()
zz.set_a_product(name, logger)
logger.write("\n", 2)
def show_patchs(config, logger):
- '''Prints all the used patchs in the application.
+ """Prints all the used patchs in the application.
- :param config Config: the global configuration.
- :param logger Logger: The logger instance to use for the display
- '''
- oneOrMore = False
- for product in sorted(config.APPLICATION.products):
- try:
- product_info = src.product.get_product_config(config, product)
- if src.product.product_has_patches(product_info):
- oneOrMore = True
- logger.write("%s:\n" % product, 1)
- for i in product_info.patches:
- logger.write(src.printcolors.printcInfo(" %s\n" % i), 1)
- except Exception as e:
- msg = "problem on product %s\n%s\n" % (product, str(e))
- logger.error(msg)
+ :param config Config: the global configuration.
+ :param logger Logger: The logger instance to use for the display
+ """
+ oneOrMore = False
+ for product in sorted(config.APPLICATION.products):
+ try:
+ product_info = src.product.get_product_config(config, product)
+ if src.product.product_has_patches(product_info):
+ oneOrMore = True
+ logger.write("%s:\n" % product, 1)
+ for i in product_info.patches:
+ logger.write(src.printcolors.printcInfo(" %s\n" % i), 1)
+ except Exception as e:
+ msg = "problem on product %s\n%s\n" % (product, str(e))
+ logger.error(msg)
+
+ if oneOrMore:
+ logger.write("\n", 1)
+ else:
+ logger.write("No patchs found\n", 1)
- if oneOrMore:
- logger.write("\n", 1)
- else:
- logger.write("No patchs found\n", 1)
def check_install_system(config, logger):
- '''Check the installation of all (declared) system products
-
- :param config Config: the global configuration.
- :param logger Logger: The logger instance to use for the display
- '''
- # get the command to use for checking the system dependencies
- # (either rmp or apt)
- check_cmd=src.system.get_pkg_check_cmd(config.VARS.dist_name)
- logger.write("\nCheck the system dependencies declared in the application\n",1)
- pkgmgr=check_cmd[0]
- run_dep_ko=[] # list of missing run time dependencies
- build_dep_ko=[] # list of missing compile time dependencies
- for product in sorted(config.APPLICATION.products):
- try:
- product_info = src.product.get_product_config(config, product)
- if src.product.product_is_native(product_info):
- # if the product is native, get (in two dictionnaries the runtime and compile time
- # system dependencies with the status (OK/KO)
- run_pkg,build_pkg=src.product.check_system_dep(config.VARS.dist, check_cmd, product_info)
- #logger.write("\n*** %s ***\n" % product, 1)
- for pkg in run_pkg:
- logger.write("\n - "+pkg + " : " + run_pkg[pkg], 1)
- if "KO" in run_pkg[pkg]:
- run_dep_ko.append(pkg)
- for pkg in build_pkg:
- logger.write("\n - "+pkg + " : " + build_pkg[pkg], 1)
- if "KO" in build_pkg[pkg]:
- build_dep_ko.append(pkg)
- # logger.write(src.printcolors.printcInfo(" %s\n" % i), 1)
+ """Check the installation of all (declared) system products
+
+ :param config Config: the global configuration.
+ :param logger Logger: The logger instance to use for the display
+ """
+ # get the command to use for checking the system dependencies
+ # (either rmp or apt)
+ check_cmd = src.system.get_pkg_check_cmd(config.VARS.dist_name)
+ logger.write("\nCheck the system dependencies declared in the application\n", 1)
+ pkgmgr = check_cmd[0]
+ run_dep_ko = [] # list of missing run time dependencies
+ build_dep_ko = [] # list of missing compile time dependencies
+ for product in sorted(config.APPLICATION.products):
+ try:
+ product_info = src.product.get_product_config(config, product)
+ if src.product.product_is_native(product_info):
+ # if the product is native, get (in two dictionnaries the runtime and compile time
+ # system dependencies with the status (OK/KO)
+ run_pkg, build_pkg = src.product.check_system_dep(
+ config.VARS.dist, check_cmd, product_info
+ )
+ # logger.write("\n*** %s ***\n" % product, 1)
+ for pkg in run_pkg:
+ logger.write("\n - " + pkg + " : " + run_pkg[pkg], 1)
+ if "KO" in run_pkg[pkg]:
+ run_dep_ko.append(pkg)
+ for pkg in build_pkg:
+ logger.write("\n - " + pkg + " : " + build_pkg[pkg], 1)
+ if "KO" in build_pkg[pkg]:
+ build_dep_ko.append(pkg)
+ # logger.write(src.printcolors.printcInfo(" %s\n" % i), 1)
+
+ except Exception as e:
+ msg = "\nproblem with the check of system prerequisite %s\n%s\n" % (
+ product,
+ str(e),
+ )
+ logger.error(msg)
+ raise Exception(msg)
+
+ logger.write("\n\n", 1)
+ if run_dep_ko:
+ msg = (
+ "Some run time system dependencies are missing!\n"
+ + "Please install them with %s before running salome" % pkgmgr
+ )
+ logger.warning(msg)
+ logger.write("missing run time dependencies : ", 1)
+ for md in run_dep_ko:
+ logger.write(md + " ", 1)
+ logger.write("\n\n")
+
+ if build_dep_ko:
+ msg = (
+ "Some compile time system dependencies are missing!\n"
+ + "Please install them with %s before compiling salome" % pkgmgr
+ )
+ logger.warning(msg)
+ logger.write("missing compile time dependencies : ", 1)
+ for md in build_dep_ko:
+ logger.write(md + " ", 1)
+ logger.write("\n\n")
- except Exception as e:
- msg = "\nproblem with the check of system prerequisite %s\n%s\n" % (product, str(e))
- logger.error(msg)
- raise Exception(msg)
-
- logger.write("\n\n",1)
- if run_dep_ko:
- msg="Some run time system dependencies are missing!\n"+\
- "Please install them with %s before running salome" % pkgmgr
- logger.warning(msg)
- logger.write("missing run time dependencies : ",1)
- for md in run_dep_ko:
- logger.write(md+" ",1)
- logger.write("\n\n")
-
- if build_dep_ko:
- msg="Some compile time system dependencies are missing!\n"+\
- "Please install them with %s before compiling salome" % pkgmgr
- logger.warning(msg)
- logger.write("missing compile time dependencies : ",1)
- for md in build_dep_ko:
- logger.write(md+" ",1)
- logger.write("\n\n")
-
def show_dependencies(config, products, logger):
- '''Prints dependencies of products in the application.
+ """Prints dependencies of products in the application.
:param config Config: the global configuration.
:param logger Logger: The logger instance to use for the display
- '''
+ """
+
+ from compile import get_dependencies_graph, depth_search_graph, find_path_graph
- from compile import get_dependencies_graph,depth_search_graph,find_path_graph
# Get the list of all application products, and create its dependency graph
- all_products_infos = src.product.get_products_infos(config.APPLICATION.products,config)
- all_products_graph=get_dependencies_graph(all_products_infos, compile_time=False)
+ all_products_infos = src.product.get_products_infos(
+ config.APPLICATION.products, config
+ )
+ all_products_graph = get_dependencies_graph(all_products_infos, compile_time=False)
- products_list=[]
- product_liste_name=""
+ products_list = []
+ product_liste_name = ""
if products is None:
- products_list=config.APPLICATION.products
+ products_list = config.APPLICATION.products
products_graph = all_products_graph
else:
# 1. Extend the list with all products that depends upon the given list of products
- products_list=products
- product_liste_name="_".join(products)
- visited=[]
+ products_list = products
+ product_liste_name = "_".join(products)
+ visited = []
for p_name in products_list:
- visited=depth_search_graph(all_products_graph, p_name, visited)
+ visited = depth_search_graph(all_products_graph, p_name, visited)
products_infos = src.product.get_products_infos(visited, config)
products_graph = get_dependencies_graph(products_infos, compile_time=False)
# 2. Extend the list with all the dependencies of the given list of products
- children=[]
+ children = []
for n in all_products_graph:
# for all products (that are not in products_list):
# if we we find a path from the product to the product list,
- # then we product is a child and we add it to the children list
+ # then we product is a child and we add it to the children list
if (n not in children) and (n not in products_list):
if find_path_graph(all_products_graph, n, products_list):
children = children + [n]
products_infos_rev = src.product.get_products_infos(children, config)
- products_graph_rev = get_dependencies_graph(products_infos_rev, compile_time=False)
+ products_graph_rev = get_dependencies_graph(
+ products_infos_rev, compile_time=False
+ )
logger.write("Dependency graph (python format)\n%s\n" % products_graph, 3)
- gv_file_name='%s_%s_dep.gv' % (config.VARS.application,product_liste_name)
- logger.write("\nDependency graph (graphviz format) written in file %s\n" %
- src.printcolors.printcLabel(gv_file_name), 3)
- with open(gv_file_name,"w") as f:
+ gv_file_name = "%s_%s_dep.gv" % (config.VARS.application, product_liste_name)
+ logger.write(
+ "\nDependency graph (graphviz format) written in file %s\n"
+ % src.printcolors.printcLabel(gv_file_name),
+ 3,
+ )
+ with open(gv_file_name, "w") as f:
f.write("digraph G {\n")
for p in products_graph:
for dep in products_graph[p]:
- f.write ("\t%s -> %s\n" % (p,dep))
+ f.write("\t%s -> %s\n" % (p, dep))
f.write("}\n")
-
if products is not None:
# if a list of products was given, produce also the reverse dependencies
- gv_revfile_name='%s_%s_rev_dep.gv' % (config.VARS.application,product_liste_name)
- logger.write("\nReverse dependency graph (graphviz format) written in file %s\n" %
- src.printcolors.printcLabel(gv_revfile_name), 3)
- with open(gv_revfile_name,"w") as rf:
+ gv_revfile_name = "%s_%s_rev_dep.gv" % (
+ config.VARS.application,
+ product_liste_name,
+ )
+ logger.write(
+ "\nReverse dependency graph (graphviz format) written in file %s\n"
+ % src.printcolors.printcLabel(gv_revfile_name),
+ 3,
+ )
+ with open(gv_revfile_name, "w") as rf:
rf.write("digraph G {\n")
for p in products_graph_rev:
for dep in products_graph_rev[p]:
- rf.write ("\t%s -> %s\n" % (p,dep))
+ rf.write("\t%s -> %s\n" % (p, dep))
rf.write("}\n")
-
- graph_cmd = "dot -Tpdf %s -o %s.pdf" % (gv_file_name,gv_file_name)
- logger.write("\nTo generate a graph use dot tool : \n %s" %
- src.printcolors.printcLabel(graph_cmd), 3)
-
+
+ graph_cmd = "dot -Tpdf %s -o %s.pdf" % (gv_file_name, gv_file_name)
+ logger.write(
+ "\nTo generate a graph use dot tool : \n %s"
+ % src.printcolors.printcLabel(graph_cmd),
+ 3,
+ )
+
+
def show_install_dir(config, logger):
- '''Prints all the used installed directories in the application.
+ """Prints all the used installed directories in the application.
- :param config Config: the global configuration.
- :param logger Logger: The logger instance to use for the display
- '''
- for product in sorted(config.APPLICATION.products):
- try:
- product_info = src.product.get_product_config(config, product)
- install_path=src.Path(product_info.install_dir)
- if (src.product.product_is_native(product_info)):
- install_path="Native"
- elif (src.product.product_is_fixed(product_info)):
- install_path+=" (Fixed)"
- logger.write("%s : %s\n" % (product, install_path) , 1)
- except Exception as e:
- msg = "problem on product %s\n%s\n" % (product, str(e))
- logger.error(msg)
- logger.write("\n", 1)
+ :param config Config: the global configuration.
+ :param logger Logger: The logger instance to use for the display
+ """
+ for product in sorted(config.APPLICATION.products):
+ try:
+ product_info = src.product.get_product_config(config, product)
+ install_path = src.Path(product_info.install_dir)
+ if src.product.product_is_native(product_info):
+ install_path = "Native"
+ elif src.product.product_is_fixed(product_info):
+ install_path += " (Fixed)"
+ logger.write("%s : %s\n" % (product, install_path), 1)
+ except Exception as e:
+ msg = "problem on product %s\n%s\n" % (product, str(e))
+ logger.error(msg)
+ logger.write("\n", 1)
def show_properties(config, logger):
- '''Prints all the used properties in the application.
-
- :param config Config: the global configuration.
- :param logger Logger: The logger instance to use for the display
- '''
- if "properties" in config.APPLICATION:
- # some properties are defined at application level, we display them
- logger.write("Application properties:\n", 1)
- for prop in config.APPLICATION.properties:
- logger.write(src.printcolors.printcInfo(" %s : %s\n" % (prop, config.APPLICATION.properties[prop])), 1)
- oneOrMore = False
- for product in sorted(config.APPLICATION.products):
- try:
- product_info = src.product.get_product_config(config, product)
- done = False
- try:
- for prop in product_info.properties:
- if not done:
- logger.write("%s:\n" % product, 1)
- done = True
- oneOrMore = True
- logger.write(src.printcolors.printcInfo(" %s : %s\n" % (prop, product_info.properties[prop])), 1)
- except Exception as e:
- pass
- except Exception as e:
- # logger.write(src.printcolors.printcInfo(" %s\n" % "no properties"), 1)
- msg = "problem on product %s\n%s\n" % (product, e)
- logger.error(msg)
+ """Prints all the used properties in the application.
+
+ :param config Config: the global configuration.
+ :param logger Logger: The logger instance to use for the display
+ """
+ if "properties" in config.APPLICATION:
+ # some properties are defined at application level, we display them
+ logger.write("Application properties:\n", 1)
+ for prop in config.APPLICATION.properties:
+ logger.write(
+ src.printcolors.printcInfo(
+ " %s : %s\n" % (prop, config.APPLICATION.properties[prop])
+ ),
+ 1,
+ )
+ oneOrMore = False
+ for product in sorted(config.APPLICATION.products):
+ try:
+ product_info = src.product.get_product_config(config, product)
+ done = False
+ try:
+ for prop in product_info.properties:
+ if not done:
+ logger.write("%s:\n" % product, 1)
+ done = True
+ oneOrMore = True
+ logger.write(
+ src.printcolors.printcInfo(
+ " %s : %s\n" % (prop, product_info.properties[prop])
+ ),
+ 1,
+ )
+ except Exception as e:
+ pass
+ except Exception as e:
+ # logger.write(src.printcolors.printcInfo(" %s\n" % "no properties"), 1)
+ msg = "problem on product %s\n%s\n" % (product, e)
+ logger.error(msg)
+
+ if oneOrMore:
+ logger.write("\n", 1)
+ else:
+ logger.write("No properties found\n", 1)
- if oneOrMore:
- logger.write("\n", 1)
- else:
- logger.write("No properties found\n", 1)
def print_value(config, path, show_label, logger, level=0, show_full_path=False):
- '''Prints a value from the configuration. Prints recursively the values
+ """Prints a value from the configuration. Prints recursively the values
under the initial path.
-
- :param config class 'src.pyconf.Config': The configuration
+
+ :param config class 'src.pyconf.Config': The configuration
from which the value is displayed.
:param path str : the path in the configuration of the value to print.
- :param show_label boolean: if True, do a basic display.
+ :param show_label boolean: if True, do a basic display.
(useful for bash completion)
:param logger Logger: the logger instance
:param level int: The number of spaces to add before display.
:param show_full_path :
- '''
-
+ """
+
# Make sure that the path does not ends with a point
- if path.endswith('.'):
+ if path.endswith("."):
path = path[:-1]
-
+
# display all the path or not
if show_full_path:
vname = path
else:
- vname = path.split('.')[-1]
+ vname = path.split(".")[-1]
# number of spaces before the display
tab_level = " " * level
-
+
# call to the function that gets the value of the path.
try:
val = config.getByPath(path)
except Exception as e:
logger.write(tab_level)
- logger.write("%s: ERROR %s\n" % (src.printcolors.printcLabel(vname),
- src.printcolors.printcError(str(e))))
+ logger.write(
+ "%s: ERROR %s\n"
+ % (src.printcolors.printcLabel(vname), src.printcolors.printcError(str(e)))
+ )
return
# in this case, display only the value
logger.write(tab_level)
logger.write("%s: " % src.printcolors.printcLabel(vname))
- # The case where the value has under values,
+ # The case where the value has under values,
# do a recursive call to the function
- if dir(val).__contains__('keys'):
- if show_label: logger.write("\n")
+ if dir(val).__contains__("keys"):
+ if show_label:
+ logger.write("\n")
for v in sorted(val.keys()):
- print_value(config, path + '.' + v, show_label, logger, level + 1)
- elif val.__class__ == src.pyconf.Sequence or isinstance(val, list):
+ print_value(config, path + "." + v, show_label, logger, level + 1)
+ elif val.__class__ == src.pyconf.Sequence or isinstance(val, list):
# in this case, value is a list (or a Sequence)
- if show_label: logger.write("\n")
+ if show_label:
+ logger.write("\n")
index = 0
for v in val:
- print_value(config, path + "[" + str(index) + "]",
- show_label, logger, level + 1)
+ print_value(
+ config, path + "[" + str(index) + "]", show_label, logger, level + 1
+ )
index = index + 1
- else: # case where val is just a str
+ else: # case where val is just a str
logger.write("%s\n" % val)
+
def get_config_children(config, args):
- '''Gets the names of the children of the given parameter.
+ """Gets the names of the children of the given parameter.
Useful only for completion mechanism
-
+
:param config Config: The configuration where to read the values
:param args: The path in the config from which get the keys
- '''
+ """
vals = []
rootkeys = config.keys()
-
+
if len(args) == 0:
# no parameter returns list of root keys
vals = rootkeys
else:
parent = args[0]
- pos = parent.rfind('.')
+ pos = parent.rfind(".")
if pos < 0:
# Case where there is only on key as parameter.
# For example VARS
# Case where there is a part from a key
# for example VARS.us (for VARS.user)
head = parent[0:pos]
- tail = parent[pos+1:]
+ tail = parent[pos + 1 :]
try:
a = config.getByPath(head)
- if dir(a).__contains__('keys'):
- vals = map(lambda x: head + '.' + x,
- [m for m in a.keys() if m.startswith(tail)])
+ if dir(a).__contains__("keys"):
+ vals = map(
+ lambda x: head + "." + x,
+ [m for m in a.keys() if m.startswith(tail)],
+ )
except:
pass
for v in sorted(vals):
sys.stdout.write("%s\n" % v)
+
def description():
- '''method that is called when salomeTools is called with --help option.
-
+ """method that is called when salomeTools is called with --help option.
+
:return: The text to display for the config command description.
:rtype: str
- '''
- return _("The config command allows manipulation "
- "and operation on config files.\n\nexample:\nsat config "
- "SALOME-master --info ParaView")
-
+ """
+ return _(
+ "The config command allows manipulation "
+ "and operation on config files.\n\nexample:\nsat config "
+ "SALOME-master --info ParaView"
+ )
+
def run(args, runner, logger):
- '''method that is called when salomeTools is called with config parameter.
- '''
+ """method that is called when salomeTools is called with config parameter."""
# Parse the options
(options, args) = parser.parse_args(args)
for val in sorted(runner.cfg.keys()):
print_value(runner.cfg, val, not options.no_label, logger)
else:
- print_value(runner.cfg, options.value, not options.no_label, logger,
- level=0, show_full_path=False)
-
+ print_value(
+ runner.cfg,
+ options.value,
+ not options.no_label,
+ logger,
+ level=0,
+ show_full_path=False,
+ )
+
# case : print a debug value of the config
if options.debug:
if options.debug == ".":
# if argument is ".", print all the config
res = DBG.indent(DBG.getStrConfigDbg(runner.cfg))
- logger.write("\nConfig of application %s:\n\n%s\n" % (runner.cfg.VARS.application, res))
+ logger.write(
+ "\nConfig of application %s:\n\n%s\n"
+ % (runner.cfg.VARS.application, res)
+ )
else:
- if options.debug[0] == ".": # accept ".PRODUCT.etc" as "PRODUCT.etc"
- od = options.debug[1:]
+ if options.debug[0] == ".": # accept ".PRODUCT.etc" as "PRODUCT.etc"
+ od = options.debug[1:]
else:
- od = options.debug
+ od = options.debug
try:
- aCode = "a = runner.cfg.%s" % od
- # https://stackoverflow.com/questions/15086040/behavior-of-exec-function-in-python-2-and-python-3
- aDict = {"runner": runner}
- exec(aCode, globals(), aDict)
- # DBG.write("globals()", globals(), True)
- # DBG.write("aDict", aDict, True)
- res = DBG.indent(DBG.getStrConfigDbg(aDict["a"]))
- logger.write("\nConfig.%s of application %s:\n\n%s\n" % (od, runner.cfg.VARS.application, res))
+ aCode = "a = runner.cfg.%s" % od
+ # https://stackoverflow.com/questions/15086040/behavior-of-exec-function-in-python-2-and-python-3
+ aDict = {"runner": runner}
+ exec(aCode, globals(), aDict)
+ # DBG.write("globals()", globals(), True)
+ # DBG.write("aDict", aDict, True)
+ res = DBG.indent(DBG.getStrConfigDbg(aDict["a"]))
+ logger.write(
+ "\nConfig.%s of application %s:\n\n%s\n"
+ % (od, runner.cfg.VARS.application, res)
+ )
except Exception as e:
- msg = "\nConfig.%s of application %s: Unknown pyconf key\n" % (od, runner.cfg.VARS.application)
- logger.write(src.printcolors.printcError(msg), 1)
+ msg = "\nConfig.%s of application %s: Unknown pyconf key\n" % (
+ od,
+ runner.cfg.VARS.application,
+ )
+ logger.write(src.printcolors.printcError(msg), 1)
-
# case : edit user pyconf file or application file
if options.edit:
editor = runner.cfg.USER.editor
- if ('APPLICATION' not in runner.cfg and
- 'open_application' not in runner.cfg): # edit user pyconf
- usercfg = osJoin(runner.cfg.VARS.personalDir,
- 'SAT.pyconf')
+ if (
+ "APPLICATION" not in runner.cfg and "open_application" not in runner.cfg
+ ): # edit user pyconf
+ usercfg = osJoin(runner.cfg.VARS.personalDir, "SAT.pyconf")
logger.write(_("Opening %s\n" % usercfg), 3)
src.system.show_in_editor(editor, usercfg, logger)
else:
# search for file <application>.pyconf and open it
for path in runner.cfg.PATHS.APPLICATIONPATH:
- pyconf_path = osJoin(path,
- runner.cfg.VARS.application + ".pyconf")
+ pyconf_path = osJoin(path, runner.cfg.VARS.application + ".pyconf")
if os.path.exists(pyconf_path):
logger.write(_("Opening %s\n" % pyconf_path), 3)
src.system.show_in_editor(editor, pyconf_path, logger)
break
-
+
# case : give information about the product(s) in parameter
if options.products:
- if options.info is not None:
- logger.warning('options.products %s overrides options.info %s' % (options.products, options.info))
- options.info = options.products
+ if options.info is not None:
+ logger.warning(
+ "options.products %s overrides options.info %s"
+ % (options.products, options.info)
+ )
+ options.info = options.products
if options.info:
- # DBG.write("products", sorted(runner.cfg.APPLICATION.products.keys()), True)
- src.check_config_has_application(runner.cfg)
- taggedProducts = src.getProductNames(runner.cfg, options.info, logger)
- DBG.write("tagged products", sorted(taggedProducts))
- for prod in sorted(taggedProducts):
- if prod in runner.cfg.APPLICATION.products:
- try:
- if len(taggedProducts) > 1:
- logger.write("#################### ", 2)
- show_product_info(runner.cfg, prod, logger)
- except Exception as e:
- msg = "problem on product %s\n%s\n" % (prod, str(e))
- logger.error(msg)
- # return
- else:
- msg = _("%s is not a product of %s.\n") % \
- (prod, runner.cfg.VARS.application)
- logger.warning(msg)
- #raise Exception(msg)
-
- # case : copy an existing <application>.pyconf
+ # DBG.write("products", sorted(runner.cfg.APPLICATION.products.keys()), True)
+ src.check_config_has_application(runner.cfg)
+ taggedProducts = src.getProductNames(runner.cfg, options.info, logger)
+ DBG.write("tagged products", sorted(taggedProducts))
+ for prod in sorted(taggedProducts):
+ if prod in runner.cfg.APPLICATION.products:
+ try:
+ if len(taggedProducts) > 1:
+ logger.write("#################### ", 2)
+ show_product_info(runner.cfg, prod, logger)
+ except Exception as e:
+ msg = "problem on product %s\n%s\n" % (prod, str(e))
+ logger.error(msg)
+ # return
+ else:
+ msg = _("%s is not a product of %s.\n") % (
+ prod,
+ runner.cfg.VARS.application,
+ )
+ logger.warning(msg)
+ # raise Exception(msg)
+
+ # case : copy an existing <application>.pyconf
# to ~/.salomeTools/Applications/LOCAL_<application>.pyconf
if options.copy:
# product is required
- src.check_config_has_application( runner.cfg )
+ src.check_config_has_application(runner.cfg)
- # get application file path
- source = runner.cfg.VARS.application + '.pyconf'
+ # get application file path
+ source = runner.cfg.VARS.application + ".pyconf"
source_full_path = ""
for path in runner.cfg.PATHS.APPLICATIONPATH:
# ignore personal directory
if path == runner.cfg.VARS.personalDir:
continue
# loop on all directories that can have pyconf applications
- zz = osJoin(path, source)
+ zz = osJoin(path, source)
if os.path.exists(zz):
source_full_path = zz
break
if len(source_full_path) == 0:
- raise src.SatException(_(
- "Config file for product %s not found\n") % source)
+ raise src.SatException(_("Config file for product %s not found\n") % source)
else:
if len(args) > 0:
# a name is given as parameter, use it
dest = args[0]
- elif 'copy_prefix' in runner.cfg.INTERNAL.config:
+ elif "copy_prefix" in runner.cfg.INTERNAL.config:
# use prefix
- dest = (runner.cfg.INTERNAL.config.copy_prefix
- + runner.cfg.VARS.application)
+ dest = (
+ runner.cfg.INTERNAL.config.copy_prefix + runner.cfg.VARS.application
+ )
else:
# use same name as source
dest = runner.cfg.VARS.application
-
+
# the full path
- dest_file = osJoin(runner.cfg.VARS.personalDir,
- 'Applications', dest + '.pyconf')
+ dest_file = osJoin(
+ runner.cfg.VARS.personalDir, "Applications", dest + ".pyconf"
+ )
if os.path.exists(dest_file):
- raise src.SatException(_("A personal application"
- " '%s' already exists") % dest)
-
+ raise src.SatException(
+ _("A personal application" " '%s' already exists") % dest
+ )
+
# perform the copy
shutil.copyfile(source_full_path, dest_file)
logger.write(_("%s has been created.\n") % dest_file)
-
+
# case : display all the available pyconf applications
if options.list:
lproduct = list()
logger.write("------ %s\n" % src.printcolors.printcHeader(path))
if not os.path.exists(path):
- logger.write(src.printcolors.printcError(_(
- "Directory not found")) + "\n")
+ logger.write(
+ src.printcolors.printcError(_("Directory not found")) + "\n"
+ )
else:
for f in sorted(os.listdir(path)):
# ignore file that does not ends with .pyconf
- if not f.endswith('.pyconf'):
+ if not f.endswith(".pyconf"):
continue
- appliname = f[:-len('.pyconf')]
+ appliname = f[: -len(".pyconf")]
if appliname not in lproduct:
lproduct.append(appliname)
- if path.startswith(runner.cfg.VARS.personalDir) \
- and not options.no_label:
+ if (
+ path.startswith(runner.cfg.VARS.personalDir)
+ and not options.no_label
+ ):
logger.write("%s*\n" % appliname)
else:
logger.write("%s\n" % appliname)
-
+
logger.write("\n")
# case: print all the products name of the application (internal use for completion)
if options.completion:
for product_name in runner.cfg.APPLICATION.products.keys():
logger.write("%s\n" % product_name)
-
+
# case : give a synthetic view of all patches used in the application
if options.show_patchs:
src.check_config_has_application(runner.cfg)
# Print some informations
- logger.write(_('Patchs of application %s\n') %
- src.printcolors.printcLabel(runner.cfg.VARS.application), 3)
+ logger.write(
+ _("Patchs of application %s\n")
+ % src.printcolors.printcLabel(runner.cfg.VARS.application),
+ 3,
+ )
logger.write("\n", 2, False)
show_patchs(runner.cfg, logger)
if options.show_install:
src.check_config_has_application(runner.cfg)
# Print some informations
- logger.write(_('Installation directories of application %s\n') %
- src.printcolors.printcLabel(runner.cfg.VARS.application), 3)
+ logger.write(
+ _("Installation directories of application %s\n")
+ % src.printcolors.printcLabel(runner.cfg.VARS.application),
+ 3,
+ )
logger.write("\n", 2, False)
show_install_dir(runner.cfg, logger)
if options.show_dependencies:
src.check_config_has_application(runner.cfg)
# Print some informations
- logger.write(_('List of run-time dependencies of the application %s, product by product\n') %
- src.printcolors.printcLabel(runner.cfg.VARS.application), 3)
+ logger.write(
+ _(
+ "List of run-time dependencies of the application %s, product by product\n"
+ )
+ % src.printcolors.printcLabel(runner.cfg.VARS.application),
+ 3,
+ )
logger.write("\n", 2, False)
show_dependencies(runner.cfg, options.products, logger)
src.check_config_has_application(runner.cfg)
# Print some informations
- logger.write(_('Properties of application %s\n') %
- src.printcolors.printcLabel(runner.cfg.VARS.application), 3)
+ logger.write(
+ _("Properties of application %s\n")
+ % src.printcolors.printcLabel(runner.cfg.VARS.application),
+ 3,
+ )
logger.write("\n", 2, False)
show_properties(runner.cfg, logger)
# check system prerequisites
if options.check_system:
- check_install_system(runner.cfg, logger)
- pass
+ check_install_system(runner.cfg, logger)
+ pass
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2012 CEA/DEN
#
# This library is free software; you can redistribute it and/or
# Define all possible option for configure command : sat configure <options>
parser = src.options.Options()
-parser.add_option('p', 'products', 'list2', 'products',
- _('Optional: products to configure. This option accepts a comma separated list.'))
-parser.add_option('o', 'option', 'string', 'option',
- _('Optional: Option to add to the configure or cmake command.'), "")
+parser.add_option(
+ "p",
+ "products",
+ "list2",
+ "products",
+ _("Optional: products to configure. This option accepts a comma separated list."),
+)
+parser.add_option(
+ "o",
+ "option",
+ "string",
+ "option",
+ _("Optional: Option to add to the configure or cmake command."),
+ "",
+)
def log_step(logger, header, step):
logger.write("\n==== %s \n" % src.printcolors.printcInfo(step), 4)
logger.flush()
+
def log_res_step(logger, res):
if res == 0:
logger.write("%s \n" % src.printcolors.printcSuccess("OK"), 4)
logger.write("%s \n" % src.printcolors.printcError("KO"), 4)
logger.flush()
+
def configure_all_products(config, products_infos, conf_option, logger):
- '''Execute the proper configuration commands
+ """Execute the proper configuration commands
in each product build directory.
:param config Config: The global configuration
- :param products_info list: List of
+ :param products_info list: List of
(str, Config) => (product_name, product_info)
:param conf_option str: The options to add to the command
:param logger Logger: The logger instance to use for the display and logging
:return: the number of failing commands.
:rtype: int
- '''
+ """
res = 0
for p_name_info in products_infos:
res_prod = configure_product(p_name_info, conf_option, config, logger)
if res_prod != 0:
- res += 1
+ res += 1
return res
+
def configure_product(p_name_info, conf_option, config, logger):
- '''Execute the proper configuration command(s)
+ """Execute the proper configuration command(s)
in the product build directory.
-
+
:param p_name_info tuple: (str, Config) => (product_name, product_info)
:param conf_option str: The options to add to the command
:param config Config: The global configuration
- :param logger Logger: The logger instance to use for the display
+ :param logger Logger: The logger instance to use for the display
and logging
:return: 1 if it fails, else 0.
:rtype: int
- '''
-
+ """
+
p_name, p_info = p_name_info
-
+
# Logging
logger.write("\n", 4, False)
logger.write("################ ", 4)
logger.flush()
# Do nothing if he product is not compilable
- if ("properties" in p_info and "compilation" in p_info.properties and
- p_info.properties.compilation == "no"):
+ if (
+ "properties" in p_info
+ and "compilation" in p_info.properties
+ and p_info.properties.compilation == "no"
+ ):
log_step(logger, header, "ignored")
logger.write("\n", 3, False)
return 0
# Instantiate the class that manages all the construction commands
# like cmake, make, make install, make test, environment management, etc...
builder = src.compilation.Builder(config, logger, p_name, p_info)
-
+
# Prepare the environment
log_step(logger, header, "PREPARE ENV")
res_prepare = builder.prepare()
log_res_step(logger, res_prepare)
-
+
# Execute buildconfigure, configure if the product is autotools
# Execute cmake if the product is cmake
res = 0
res_cm = builder.cmake(conf_option)
log_res_step(logger, res_cm)
res += res_cm
-
+
# Log the result
if res > 0:
logger.write("\r%s%s" % (header, " " * 20), 3)
logger.write("\r" + header + src.printcolors.printcError("KO"))
- logger.write("==== %(KO)s in configuration of %(name)s \n" %
- { "name" : p_name , "KO" : src.printcolors.printcInfo("ERROR")}, 4)
+ logger.write(
+ "==== %(KO)s in configuration of %(name)s \n"
+ % {"name": p_name, "KO": src.printcolors.printcInfo("ERROR")},
+ 4,
+ )
logger.flush()
else:
logger.write("\r%s%s" % (header, " " * 20), 3)
logger.write("\r" + header + src.printcolors.printcSuccess("OK"))
logger.write("==== %s \n" % src.printcolors.printcInfo("OK"), 4)
- logger.write("==== Configuration of %(name)s %(OK)s \n" %
- { "name" : p_name , "OK" : src.printcolors.printcInfo("OK")}, 4)
+ logger.write(
+ "==== Configuration of %(name)s %(OK)s \n"
+ % {"name": p_name, "OK": src.printcolors.printcInfo("OK")},
+ 4,
+ )
logger.flush()
logger.write("\n", 3, False)
return res
+
def description():
- '''method that is called when salomeTools is called with --help option.
-
+ """method that is called when salomeTools is called with --help option.
+
:return: The text to display for the configure command description.
:rtype: str
- '''
- return _("The configure command executes in the build directory"
- " the configure commands corresponding\nto the compilation mode"
- " of the application products.\nThe possible compilation modes"
- " are \"cmake\", \"autotools\", or a script.\n\nHere are the "
- "commands to be run :\nautotools: build_configure and configure\n"
- "cmake: cmake\nscript: do nothing\n\nexample:\nsat configure "
- "SALOME-master --products KERNEL,GUI,PARAVIS")
-
+ """
+ return _(
+ "The configure command executes in the build directory"
+ " the configure commands corresponding\nto the compilation mode"
+ " of the application products.\nThe possible compilation modes"
+ ' are "cmake", "autotools", or a script.\n\nHere are the '
+ "commands to be run :\nautotools: build_configure and configure\n"
+ "cmake: cmake\nscript: do nothing\n\nexample:\nsat configure "
+ "SALOME-master --products KERNEL,GUI,PARAVIS"
+ )
+
+
def run(args, runner, logger):
- '''method that is called when salomeTools is called with make parameter.
- '''
-
+ """method that is called when salomeTools is called with make parameter."""
+
# Parse the options
(options, args) = parser.parse_args(args)
# check that the command has been called with an application
- src.check_config_has_application( runner.cfg )
+ src.check_config_has_application(runner.cfg)
# Get the list of products to treat
products_infos = src.product.get_products_list(options, runner.cfg, logger)
-
+
# Print some informations
- logger.write(_('Configuring the sources of the application %s\n') %
- src.printcolors.printcLabel(runner.cfg.VARS.application), 1)
-
- info = [(_("BUILD directory"),
- os.path.join(runner.cfg.APPLICATION.workdir, 'BUILD'))]
+ logger.write(
+ _("Configuring the sources of the application %s\n")
+ % src.printcolors.printcLabel(runner.cfg.VARS.application),
+ 1,
+ )
+
+ info = [
+ (_("BUILD directory"), os.path.join(runner.cfg.APPLICATION.workdir, "BUILD"))
+ ]
src.print_info(logger, info)
-
+
# Call the function that will loop over all the products and execute
# the right command(s)
if options.option is None:
options.option = ""
res = configure_all_products(runner.cfg, products_infos, options.option, logger)
-
+
# Print the final state
nb_products = len(products_infos)
if res == 0:
final_status = "OK"
else:
final_status = "KO"
-
- logger.write(_("\nConfiguration: %(status)s (%(valid_result)d/%(nb_products)d)\n") % \
- { 'status': src.printcolors.printc(final_status),
- 'valid_result': nb_products - res,
- 'nb_products': nb_products }, 1)
-
- return res
+
+ logger.write(
+ _("\nConfiguration: %(status)s (%(valid_result)d/%(nb_products)d)\n")
+ % {
+ "status": src.printcolors.printc(final_status),
+ "valid_result": nb_products - res,
+ "nb_products": nb_products,
+ },
+ 1,
+ )
+
+ return res
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2012 CEA/DEN
#
# This library is free software; you can redistribute it and/or
# Define all possible option for log command : sat doc <options>
parser = src.options.Options()
-parser.add_option('x', 'xml', 'boolean', 'xml', "Open sat xml/html documentation in browser (x as firefoX)", None)
-parser.add_option('p', 'pdf', 'boolean', 'pdf', "Open sat pdf documentation in viewer", False)
-parser.add_option('e', 'edit', 'boolean', 'edit', "edit/modify source dodumentation rst files", False)
-parser.add_option('c', 'compile', 'boolean', 'compile', "how to compile html/pdf doc", False)
+parser.add_option(
+ "x",
+ "xml",
+ "boolean",
+ "xml",
+ "Open sat xml/html documentation in browser (x as firefoX)",
+ None,
+)
+parser.add_option(
+ "p", "pdf", "boolean", "pdf", "Open sat pdf documentation in viewer", False
+)
+parser.add_option(
+ "e", "edit", "boolean", "edit", "edit/modify source dodumentation rst files", False
+)
+parser.add_option(
+ "c", "compile", "boolean", "compile", "how to compile html/pdf doc", False
+)
+
def description():
"""method that is called when salomeTools is called with --help option.
:return: The text to display for the log command description.
:rtype: str
"""
- return _("""\
+ return _(
+ """\
The doc command gives access to the sat documentation.
example:
>> sat doc # --xml as default
>> sat doc --xml
>> sat doc --pdf
-""")
+"""
+ )
+
def run(args, runner, logger):
- '''method that is called when salomeTools is called with log parameter.
- '''
+ """method that is called when salomeTools is called with log parameter."""
# Parse the options
(options, args) = parser.parse_args(args)
- # get the log directory.
+ # get the log directory.
satDir = runner.cfg.VARS.salometoolsway
docDir = os.path.join(satDir, "doc")
htmlFile = os.path.join(docDir, "build", "html", "index.html")
if options.pdf:
if not os.path.isfile(pdfFile):
- msg = "\npdf documentation not found. Please build it inside doc directory\n"\
- "(follow README instructions in doc directory)\n"
+ msg = (
+ "\npdf documentation not found. Please build it inside doc directory\n"
+ "(follow README instructions in doc directory)\n"
+ )
logger.error(msg)
return 1
src.system.show_in_editor(runner.cfg.USER.pdf_viewer, pdfFile, logger)
src.system.show_in_editor(runner.cfg.USER.editor, rstFilesCommands, logger)
elif options.compile:
- logger.write("How to compile documentation:\n%s" % open(readmeFile,"r").read(), 3)
+ logger.write(
+ "How to compile documentation:\n%s" % open(readmeFile, "r").read(), 3
+ )
else:
if not os.path.isfile(htmlFile):
- msg = "\nhtml documentation not found. Please build it inside doc directory\n"\
- "(follow README instructions in doc directory)\n"
+ msg = (
+ "\nhtml documentation not found. Please build it inside doc directory\n"
+ "(follow README instructions in doc directory)\n"
+ )
logger.error(msg)
return 1
src.system.show_in_editor(runner.cfg.USER.browser, htmlFile, logger)
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2013 CEA/DEN
#
# This library is free software; you can redistribute it and/or
import src
parser = src.options.Options()
-parser.add_option('', 'shell', 'list2', 'shell',
- _("Optional: Generates the environment files for the given format: "
- "bash (default), bat (for windows), cfg (salome context file) or all."), [])
-parser.add_option('p', 'products', 'list2', 'products',
- _("Optional: Includes only the specified products."))
-parser.add_option('', 'prefix', 'string', 'prefix',
- _("Optional: Specifies the prefix for the environment files."), "env")
-parser.add_option('t', 'target', 'string', 'out_dir',
- _("Optional: Specifies the directory path where to put the environment "
- "files."),
- None)
+parser.add_option(
+ "",
+ "shell",
+ "list2",
+ "shell",
+ _(
+ "Optional: Generates the environment files for the given format: "
+ "bash (default), bat (for windows), cfg (salome context file) or all."
+ ),
+ [],
+)
+parser.add_option(
+ "p",
+ "products",
+ "list2",
+ "products",
+ _("Optional: Includes only the specified products."),
+)
+parser.add_option(
+ "",
+ "prefix",
+ "string",
+ "prefix",
+ _("Optional: Specifies the prefix for the environment files."),
+ "env",
+)
+parser.add_option(
+ "t",
+ "target",
+ "string",
+ "out_dir",
+ _("Optional: Specifies the directory path where to put the environment " "files."),
+ None,
+)
# list of available shells with extensions
-C_SHELLS = { "bash": "sh", "bat": "bat", "cfg" : "cfg", "tcl" : ""}
-C_ALL_SHELL = [ "bash", "bat", "cfg", "tcl" ]
+C_SHELLS = {"bash": "sh", "bat": "bat", "cfg": "cfg", "tcl": ""}
+C_ALL_SHELL = ["bash", "bat", "cfg", "tcl"]
##
# Writes all the environment files
-def write_all_source_files(config,
- logger,
- out_dir=None,
- src_root=None,
- silent=False,
- shells=["bash"],
- prefix="env",
- env_info=None):
- '''Generates the environment files.
-
+def write_all_source_files(
+ config,
+ logger,
+ out_dir=None,
+ src_root=None,
+ silent=False,
+ shells=["bash"],
+ prefix="env",
+ env_info=None,
+):
+ """Generates the environment files.
+
:param config Config: The global configuration
- :param logger Logger: The logger instance to use for the display
+ :param logger Logger: The logger instance to use for the display
and logging
:param out_dir str: The path to the directory where the files will be put
:param src_root str: The path to the directory where the sources are
:param env_info str: The list of products to add in the files.
:return: The list of the generated files.
:rtype: List
- '''
-
+ """
+
if not out_dir:
out_dir = config.APPLICATION.workdir
raise src.SatException(_("Target directory not found: %s") % out_dir)
if not silent:
- logger.write(_("Creating environment files for %s\n") %
- src.printcolors.printcLabel(config.APPLICATION.name), 2)
- src.printcolors.print_value(logger,
- _("Target"),
- src.printcolors.printcInfo(out_dir), 3)
+ logger.write(
+ _("Creating environment files for %s\n")
+ % src.printcolors.printcLabel(config.APPLICATION.name),
+ 2,
+ )
+ src.printcolors.print_value(
+ logger, _("Target"), src.printcolors.printcInfo(out_dir), 3
+ )
logger.write("\n", 3, False)
-
+
shells_list = []
all_shells = C_ALL_SHELL
if "all" in shells:
logger.write(_("Unknown shell: %s\n") % shell, 2)
else:
shells_list.append(src.environment.Shell(shell, C_SHELLS[shell]))
-
- writer = src.environment.FileEnvWriter(config,
- logger,
- out_dir,
- src_root,
- env_info)
+
+ writer = src.environment.FileEnvWriter(config, logger, out_dir, src_root, env_info)
writer.silent = silent
files = []
for_build = True
for_launch = False
for shell in shells_list:
- if shell.name=="tcl":
- files.append(writer.write_tcl_files(for_launch,
- shell.name))
+ if shell.name == "tcl":
+ files.append(writer.write_tcl_files(for_launch, shell.name))
else:
- files.append(writer.write_env_file("%s_launch.%s" %
- (prefix, shell.extension),
- for_launch,
- shell.name))
- files.append(writer.write_env_file("%s_build.%s" %
- (prefix, shell.extension),
- for_build,
- shell.name))
+ files.append(
+ writer.write_env_file(
+ "%s_launch.%s" % (prefix, shell.extension), for_launch, shell.name
+ )
+ )
+ files.append(
+ writer.write_env_file(
+ "%s_build.%s" % (prefix, shell.extension), for_build, shell.name
+ )
+ )
for f in files:
if f:
- logger.write(" "+f+"\n", 3)
+ logger.write(" " + f + "\n", 3)
return files
+
##################################################
##
# Describes the command
def description():
- return _("The environ command generates the environment files of your "
- "application.\n\nexample:\nsat environ SALOME-master")
+ return _(
+ "The environ command generates the environment files of your "
+ "application.\n\nexample:\nsat environ SALOME-master"
+ )
+
##
# Runs the command.
(options, args) = parser.parse_args(args)
# check that the command was called with an application
- src.check_config_has_application( runner.cfg )
-
+ src.check_config_has_application(runner.cfg)
+
if options.products is None:
environ_info = None
else:
- # add products specified by user (only products
+ # add products specified by user (only products
# included in the application)
- environ_info = filter(lambda l:
- l in runner.cfg.APPLICATION.products.keys(),
- options.products)
-
+ environ_info = filter(
+ lambda l: l in runner.cfg.APPLICATION.products.keys(), options.products
+ )
+
if options.shell == []:
shell = ["bash"]
if src.architecture.is_windows():
shell = ["bat"]
else:
shell = options.shell
-
+
out_dir = options.out_dir
if out_dir:
out_dir = os.path.abspath(out_dir)
-
- write_all_source_files(runner.cfg, logger, out_dir=out_dir, shells=shell,
- prefix=options.prefix, env_info=environ_info)
+
+ write_all_source_files(
+ runner.cfg,
+ logger,
+ out_dir=out_dir,
+ shells=shell,
+ prefix=options.prefix,
+ env_info=environ_info,
+ )
logger.write("\n", 3, False)
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2013 CEA/DEN
#
# This library is free software; you can redistribute it and/or
# create a parser for command line options
parser = src.options.Options()
-parser.add_option("s",
- "sources",
- "boolean",
- "sources",
- _("Search the duplicate files in the SOURCES directory."))
-parser.add_option("p",
- "path",
- "list2",
- "path",
- _("Optional: Search the duplicate files in the given "
- "directory paths."))
-parser.add_option("",
- "exclude-file",
- "list2",
- "exclude_file",
- _("Optional: Override the default list of filtered files."))
-parser.add_option("",
- "exclude-extension",
- "list2",
- "exclude_extension",
- _("Optional: Override the default list of filtered "
- "extensions."))
-parser.add_option("",
- "exclude-path",
- "list2",
- "exclude_path",
- _("Optional: Override the default list of filtered paths."))
-
-default_extension_ignored = ['html', 'png', 'txt', 'js', 'xml', 'cmake', 'gif',
- 'm4', 'in', 'pyo', 'pyc', 'doctree', 'css']
-default_files_ignored = ['__init__.py', 'Makefile.am', 'VERSION',
- 'build_configure',
- 'README', 'AUTHORS', 'NEWS', 'COPYING', 'ChangeLog']
+parser.add_option(
+ "s",
+ "sources",
+ "boolean",
+ "sources",
+ _("Search the duplicate files in the SOURCES directory."),
+)
+parser.add_option(
+ "p",
+ "path",
+ "list2",
+ "path",
+ _("Optional: Search the duplicate files in the given " "directory paths."),
+)
+parser.add_option(
+ "",
+ "exclude-file",
+ "list2",
+ "exclude_file",
+ _("Optional: Override the default list of filtered files."),
+)
+parser.add_option(
+ "",
+ "exclude-extension",
+ "list2",
+ "exclude_extension",
+ _("Optional: Override the default list of filtered " "extensions."),
+)
+parser.add_option(
+ "",
+ "exclude-path",
+ "list2",
+ "exclude_path",
+ _("Optional: Override the default list of filtered paths."),
+)
+
+default_extension_ignored = [
+ "html",
+ "png",
+ "txt",
+ "js",
+ "xml",
+ "cmake",
+ "gif",
+ "m4",
+ "in",
+ "pyo",
+ "pyc",
+ "doctree",
+ "css",
+]
+default_files_ignored = [
+ "__init__.py",
+ "Makefile.am",
+ "VERSION",
+ "build_configure",
+ "README",
+ "AUTHORS",
+ "NEWS",
+ "COPYING",
+ "ChangeLog",
+]
default_directories_ignored = []
+
def list_directory(lpath, extension_ignored, files_ignored, directories_ignored):
- '''Make the list of all files and paths that are not filtered
-
- :param lpath List: The list of path to of the directories where to
+ """Make the list of all files and paths that are not filtered
+
+ :param lpath List: The list of path to of the directories where to
search for duplicates
:param extension_ignored List: The list of extensions to ignore
:param files_ignored List: The list of files to ignore
:param directories_ignored List: The list of directory paths to ignore
- :return: files_arb_out is the list of [file, path]
+ :return: files_arb_out is the list of [file, path]
and files_out is is the list of files
:rtype: List, List
- '''
+ """
files_out = []
- files_arb_out=[]
+ files_arb_out = []
for path in lpath:
- for root, __, files in os.walk(path):
+ for root, __, files in os.walk(path):
for fic in files:
- extension = fic.split('.')[-1]
- if (extension not in extension_ignored and
- fic not in files_ignored):
+ extension = fic.split(".")[-1]
+ if extension not in extension_ignored and fic not in files_ignored:
in_ignored_dir = False
for rep in directories_ignored:
if rep in root:
- in_ignored_dir = True
+ in_ignored_dir = True
if not in_ignored_dir:
- files_out.append([fic])
+ files_out.append([fic])
files_arb_out.append([fic, root])
return files_arb_out, files_out
+
def format_list_of_str(l_str):
- '''Make a list from a string
-
+ """Make a list from a string
+
:param l_str List or Str: The variable to format
:return: the formatted variable
:rtype: List
- '''
+ """
if not isinstance(l_str, list):
return l_str
return ",".join(l_str)
+
def print_info(logger, info, level=2):
- '''Format a display
-
+ """Format a display
+
:param logger Logger: The logger instance
:param info List: the list of tuple to display
:param valMax float: the maximum value of the variable
:param level int: the verbose level that will be used
- '''
+ """
smax = max(map(lambda l: len(l[0]), info))
for i in info:
sp = " " * (smax - len(i[0]))
- src.printcolors.print_value(logger,
- sp + i[0],
- format_list_of_str(i[1]),
- 2)
+ src.printcolors.print_value(logger, sp + i[0], format_list_of_str(i[1]), 2)
logger.write("\n", level)
+
class Progress_bar:
"Create a progress bar in the terminal"
-
- def __init__(self, name, valMin, valMax, logger, length = 50):
- '''Initialization of the progress bar.
-
+
+ def __init__(self, name, valMin, valMax, logger, length=50):
+ """Initialization of the progress bar.
+
:param name str: The name of the progress bar
:param valMin float: the minimum value of the variable
:param valMax float: the maximum value of the variable
:param logger Logger: the logger instance
:param length int: the lenght of the progress bar
- '''
+ """
self.name = name
self.valMin = valMin
self.valMax = valMax
self.length = length
self.logger = logger
if (self.valMax - self.valMin) <= 0 or length <= 0:
- out_err = _('ERROR: Wrong init values for the progress bar\n')
+ out_err = _("ERROR: Wrong init values for the progress bar\n")
raise src.SatException(out_err)
-
- def display_value_progression(self,val):
- '''Display the progress bar.
-
+
+ def display_value_progression(self, val):
+ """Display the progress bar.
+
:param val float: val must be between valMin and valMax.
- '''
+ """
if val < self.valMin or val > self.valMax:
- self.logger.write(src.printcolors.printcWarning(_(
- 'WARNING : wrong value for the progress bar.\n')), 3)
+ self.logger.write(
+ src.printcolors.printcWarning(
+ _("WARNING : wrong value for the progress bar.\n")
+ ),
+ 3,
+ )
else:
- perc = (float(val-self.valMin) / (self.valMax - self.valMin)) * 100.
+ perc = (float(val - self.valMin) / (self.valMax - self.valMin)) * 100.0
nb_equals = int(perc * self.length / 100)
- out = '\r %s : %3d %% [%s%s]' % (self.name, perc, nb_equals*'=',
- (self.length - nb_equals)*' ' )
+ out = "\r %s : %3d %% [%s%s]" % (
+ self.name,
+ perc,
+ nb_equals * "=",
+ (self.length - nb_equals) * " ",
+ )
self.logger.write(out, 3)
self.logger.flush()
+
def description():
- '''method that is called when salomeTools is called with --help option.
-
+ """method that is called when salomeTools is called with --help option.
+
:return: The text to display for the find_duplicates command description.
:rtype: str
- '''
- return _("The find_duplicates command search recursively for all duplicates"
- " files in a the INSTALL directory (or the optionally given "
- "directory) and prints the found files to the terminal.\n\n"
- "example:\nsat find_duplicates --path /tmp")
+ """
+ return _(
+ "The find_duplicates command search recursively for all duplicates"
+ " files in a the INSTALL directory (or the optionally given "
+ "directory) and prints the found files to the terminal.\n\n"
+ "example:\nsat find_duplicates --path /tmp"
+ )
+
def run(args, runner, logger):
- '''method that is called when salomeTools is called with find_duplicates
- parameter.
- '''
+ """method that is called when salomeTools is called with find_duplicates
+ parameter.
+ """
# parse the arguments
(options, args) = parser.parse_args(args)
-
- # Determine the directory path where to search
+
+ # Determine the directory path where to search
# for duplicates files regarding the options
if options.path:
l_dir_path = options.path
else:
src.check_config_has_application(runner.cfg)
if options.sources:
- l_dir_path = [os.path.join(runner.cfg.APPLICATION.workdir,
- "SOURCES")]
+ l_dir_path = [os.path.join(runner.cfg.APPLICATION.workdir, "SOURCES")]
else:
# find all installation paths
all_products = runner.cfg.APPLICATION.products.keys()
- l_product_cfg = src.product.get_products_infos(all_products,
- runner.cfg)
+ l_product_cfg = src.product.get_products_infos(all_products, runner.cfg)
l_dir_path = [pi.install_dir for __, pi in l_product_cfg]
-
+
# Get the files to ignore during the searching
files_ignored = default_files_ignored
if options.exclude_file:
directories_ignored = default_directories_ignored
if options.exclude_path:
directories_ignored = options.exclude_path
-
+
# Check the directories
l_path = src.deepcopy_list(l_dir_path)
l_dir_path = []
for dir_path in l_path:
- if not(os.path.isdir(dir_path)):
- msg = _("%s does not exists or is not a directory path: "
- "it will be ignored" % dir_path)
+ if not (os.path.isdir(dir_path)):
+ msg = _(
+ "%s does not exists or is not a directory path: "
+ "it will be ignored" % dir_path
+ )
logger.write("%s\n" % src.printcolors.printcWarning(msg), 3)
continue
l_dir_path.append(dir_path)
-
-
+
# Display some information
- info = [(_("Directories"), "\n".join(l_dir_path)),
- (_("Ignored files"), files_ignored),
- (_("Ignored extensions"), extension_ignored),
- (_("Ignored directories"), directories_ignored)
- ]
+ info = [
+ (_("Directories"), "\n".join(l_dir_path)),
+ (_("Ignored files"), files_ignored),
+ (_("Ignored extensions"), extension_ignored),
+ (_("Ignored directories"), directories_ignored),
+ ]
print_info(logger, info)
-
+
# Get all the files and paths
logger.write(_("Store all file paths ... "), 3)
logger.flush()
- dic, fic = list_directory(l_dir_path,
- extension_ignored,
- files_ignored,
- directories_ignored)
- logger.write(src.printcolors.printcSuccess('OK\n'), 3)
-
+ dic, fic = list_directory(
+ l_dir_path, extension_ignored, files_ignored, directories_ignored
+ )
+ logger.write(src.printcolors.printcSuccess("OK\n"), 3)
+
# Eliminate all the singletons
len_fic = len(fic)
- range_fic = range(0,len_fic)
+ range_fic = range(0, len_fic)
range_fic.reverse()
- my_bar = Progress_bar(_('Eliminate the files that are not duplicated'),
- 0,
- len_fic,
- logger,
- length = 50)
+ my_bar = Progress_bar(
+ _("Eliminate the files that are not duplicated"), 0, len_fic, logger, length=50
+ )
for i in range_fic:
my_bar.display_value_progression(len_fic - i)
- if fic.count(fic[i])==1:
+ if fic.count(fic[i]) == 1:
fic.remove(fic[i])
dic.remove(dic[i])
logger.write(_("\n\nCompute the dict {files : [list of pathes]} ... "), 3)
fic.sort()
len_fic = len(fic)
- rg_fic = range(0,len_fic)
+ rg_fic = range(0, len_fic)
rg_fic.reverse()
for i in rg_fic:
- if fic[i-1] != fic[i]:
+ if fic[i - 1] != fic[i]:
fic.remove(fic[i])
dic_fic_paths = {}
if fic_path[0] == the_file:
l_path.append(fic_path[1])
dic_fic_paths[the_file] = l_path
-
- logger.write(src.printcolors.printcSuccess('OK\n'), 3)
+
+ logger.write(src.printcolors.printcSuccess("OK\n"), 3)
# End the execution if no duplicates were found
if len(dic_fic_paths) == 0:
# Check that there are no singletons in the result (it would be a bug)
for elem in dic_fic_paths:
- if len(dic_fic_paths[elem])<2:
- logger.write(_("Warning : element %s has not more than"
- " two paths.\n") % elem, 3)
-
+ if len(dic_fic_paths[elem]) < 2:
+ logger.write(
+ _("Warning : element %s has not more than" " two paths.\n") % elem, 3
+ )
# Display the results
- logger.write(src.printcolors.printcInfo(_('\nResults:\n\n')), 3)
+ logger.write(src.printcolors.printcInfo(_("\nResults:\n\n")), 3)
max_file_name_lenght = max(map(lambda l: len(l), dic_fic_paths.keys()))
for fich in dic_fic_paths:
logger.write(src.printcolors.printcLabel(fich), 1)
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2013 CEA/DEN
#
# This library is free software; you can redistribute it and/or
import subprocess
import src
-from src.versionMinorMajorPatch import MinorMajorPatch as MMP
+from src.versionMinorMajorPatch import MinorMajorPatch as MMP
import src.debug as DBG
parser = src.options.Options()
-parser.add_option('p', 'products', 'list2', 'products',
- _("Optional: the list of products to generate"))
-parser.add_option('', 'yacsgen', 'string', 'yacsgen',
- _("Optional: path to YACSGEN's module_generator package"))
+parser.add_option(
+ "p",
+ "products",
+ "list2",
+ "products",
+ _("Optional: the list of products to generate"),
+)
+parser.add_option(
+ "",
+ "yacsgen",
+ "string",
+ "yacsgen",
+ _("Optional: path to YACSGEN's module_generator package"),
+)
+
def generate_component_list(config, product_name, product_info, context, logger):
res = "?"
logger.write("\n", 3)
for compo in src.product.get_product_components(product_info):
- header = " %s %s " % (src.printcolors.printcLabel(compo),
- "." * (20 - len(compo)))
- res = generate_component(config,
- compo,
- product_name,
- product_info,
- context,
- header,
- logger)
+ header = " %s %s " % (
+ src.printcolors.printcLabel(compo),
+ "." * (20 - len(compo)),
+ )
+ res = generate_component(
+ config, compo, product_name, product_info, context, header, logger
+ )
if config.USER.output_verbose_level == 3:
logger.write("\r%s%s\r%s" % (header, " " * 20, header), 3)
logger.write(src.printcolors.printc(res), 3, False)
logger.write("\n", 3, False)
return res
-def generate_component(config, compo, product_name, product_info, context, header, logger):
-# get from config include file name and librairy name, or take default value
+
+def generate_component(
+ config, compo, product_name, product_info, context, header, logger
+):
+ # get from config include file name and librairy name, or take default value
if "hxxfile" in product_info:
hxxfile = product_info.hxxfile
else:
compo_info.install_dir = os.path.join(install_dir, compo)
compo_info.build_dir = os.path.join(build_dir, compo)
compo_info.depend = product_info.depend
- compo_info.depend.append(product_info.name, "") # add cpp module
+ compo_info.depend.append(product_info.name, "") # add cpp module
compo_info.opt_depend = product_info.opt_depend
config.PRODUCTS.addMapping(compo, src.pyconf.Mapping(config), "")
config.PRODUCTS[compo].default = compo_info
- builder = src.compilation.Builder(config, logger, product_name, compo_info, check_src=False)
+ builder = src.compilation.Builder(
+ config, logger, product_name, compo_info, check_src=False
+ )
builder.header = header
# generate the component
# inline class to override bootstrap method
import module_generator
+
class sat_generator(module_generator.Generator):
# old bootstrap for automake (used if salome version <= 7.4)
def bootstrap(self, source_dir, log_file):
# replace call to default bootstrap() by using subprocess call (cleaner)
command = "sh autogen.sh"
- ier = subprocess.call(command, shell=True, cwd=source_dir,
- stdout=log_file, stderr=subprocess.STDOUT)
+ ier = subprocess.call(
+ command,
+ shell=True,
+ cwd=source_dir,
+ stdout=log_file,
+ stderr=subprocess.STDOUT,
+ )
if ier != 0:
raise src.SatException("bootstrap has ended in error")
-
# determine salome version
VersionSalome = src.get_salome_version(config)
- if VersionSalome >= MMP([7,5,0]) :
- use_autotools=False
- builder.log('USE CMAKE', 3)
+ if VersionSalome >= MMP([7, 5, 0]):
+ use_autotools = False
+ builder.log("USE CMAKE", 3)
else:
- use_autotools=True
- builder.log('USE AUTOTOOLS', 3)
+ use_autotools = True
+ builder.log("USE AUTOTOOLS", 3)
result = "GENERATE"
- builder.log('GENERATE', 3)
+ builder.log("GENERATE", 3)
prevstdout = sys.stdout
prevstderr = sys.stderr
sys.stderr = logger.logTxtFile
if src.product.product_is_mpi(product_info):
- salome_compo = module_generator.HXX2SALOMEParaComponent(hxxfile,
- cpplib,
- cpp_path)
+ salome_compo = module_generator.HXX2SALOMEParaComponent(
+ hxxfile, cpplib, cpp_path
+ )
else:
- salome_compo = module_generator.HXX2SALOMEComponent(hxxfile,
- cpplib,
- cpp_path)
+ salome_compo = module_generator.HXX2SALOMEComponent(
+ hxxfile, cpplib, cpp_path
+ )
if src.product.product_has_salome_gui(product_info):
# get files to build a template GUI
- try: # try new yacsgen api
+ try: # try new yacsgen api
gui_files = salome_compo.getGUIfilesTemplate(compo)
except: # use old yacsgen api
gui_files = salome_compo.getGUIfilesTemplate()
else:
gui_files = None
- mg = module_generator.Module(compo, components=[salome_compo],
- prefix=generate_dir, gui=gui_files)
+ mg = module_generator.Module(
+ compo, components=[salome_compo], prefix=generate_dir, gui=gui_files
+ )
g = sat_generator(mg, context)
g.generate()
if use_autotools:
result = "BUID_CONFIGURE"
- builder.log('BUID_CONFIGURE (no bootstrap)', 3)
+ builder.log("BUID_CONFIGURE (no bootstrap)", 3)
g.bootstrap(compo_info.source_dir, logger.logTxtFile)
result = src.OK_STATUS
os.chdir(curdir)
# do the compilation using the builder object
- if builder.prepare()!= 0: return "Error in prepare"
+ if builder.prepare() != 0:
+ return "Error in prepare"
if use_autotools:
- if builder.configure()!= 0: return "Error in configure"
+ if builder.configure() != 0:
+ return "Error in configure"
else:
- if builder.cmake()!= 0: return "Error in cmake"
+ if builder.cmake() != 0:
+ return "Error in cmake"
- if builder.make(config.VARS.nb_proc, "")!=0: return "Error in make"
- if builder.install()!=0: return "Error in make install"
+ if builder.make(config.VARS.nb_proc, "") != 0:
+ return "Error in make"
+ if builder.install() != 0:
+ return "Error in make install"
# copy specified logo in generated component install directory
# rem : logo is not copied in source dir because this would require
# to modify the generated makefile
logo_path = src.product.product_has_logo(product_info)
if logo_path:
- destlogo = os.path.join(compo_info.install_dir, "share", "salome",
- "resources", compo.lower(), compo + ".png")
+ destlogo = os.path.join(
+ compo_info.install_dir,
+ "share",
+ "salome",
+ "resources",
+ compo.lower(),
+ compo + ".png",
+ )
src.Path(logo_path).copyfile(destlogo)
return result
+
def build_context(config, logger):
- products_list = [ 'KERNEL', 'GUI' ]
- ctxenv = src.environment.SalomeEnviron(config,
- src.environment.Environ(dict(
- os.environ)),
- True)
+ products_list = ["KERNEL", "GUI"]
+ ctxenv = src.environment.SalomeEnviron(
+ config, src.environment.Environ(dict(os.environ)), True
+ )
ctxenv.silent = True
ctxenv.set_full_environ(logger, config.APPLICATION.products.keys())
val = os.getenv(prod_env)
if os.getenv(prod_env) is None:
if p not in config.APPLICATION.products:
- warn = _("product %(product)s is not defined. Include it in the"
- " application or define $%(env)s.") % \
- { "product": p, "env": prod_env}
+ warn = _(
+ "product %(product)s is not defined. Include it in the"
+ " application or define $%(env)s."
+ ) % {"product": p, "env": prod_env}
logger.write(src.printcolors.printcWarning(warn), 1)
logger.write("\n", 3, False)
val = ""
"update": 1,
"makeflags": "-j2",
"kernel": dicdir["KERNEL"],
- "gui": dicdir["GUI"],
- "yacs": "",
- "med": "",
- "mesh": "",
- "visu": "",
- "geom": "",
+ "gui": dicdir["GUI"],
+ "yacs": "",
+ "med": "",
+ "mesh": "",
+ "visu": "",
+ "geom": "",
}
return context
+
def check_module_generator(directory=None):
"""Check if module_generator is available.
res = None
try:
- #import module_generator
+ # import module_generator
info = imp.find_module("module_generator")
res = info[1]
except ImportError:
return res
+
def check_yacsgen(config, directory, logger):
"""Check if YACSGEN is available.
if directory is not None:
yacsgen_dir = directory
yacs_src = _("Using YACSGEN from command line")
- elif 'YACSGEN' in config.APPLICATION.products:
- yacsgen_info = src.product.get_product_config(config, 'YACSGEN')
+ elif "YACSGEN" in config.APPLICATION.products:
+ yacsgen_info = src.product.get_product_config(config, "YACSGEN")
yacsgen_dir = yacsgen_info.install_dir
yacs_src = _("Using YACSGEN from application")
elif "YACSGEN_ROOT_DIR" in os.environ:
pv = os.getenv("PYTHON_VERSION")
if pv is None:
python_info = src.product.get_product_config(config, "Python")
- pv = '.'.join(python_info.version.split('.')[:2])
+ pv = ".".join(python_info.version.split(".")[:2])
assert pv is not None, "$PYTHON_VERSION not defined"
- yacsgen_dir = os.path.join(yacsgen_dir, "lib", "python%s" % pv,
- "site-packages")
+ yacsgen_dir = os.path.join(yacsgen_dir, "lib", "python%s" % pv, "site-packages")
c = check_module_generator(yacsgen_dir)
if c is not None:
return c
- return (False,
- _("The python module module_generator was not found in YACSGEN"))
+ return (False, _("The python module module_generator was not found in YACSGEN"))
def description():
- '''method that is called when salomeTools is called with --help option.
+ """method that is called when salomeTools is called with --help option.
:return: The text to display for the generate command description.
:rtype: str
- '''
- return _("The generate command generates SALOME modules from 'pure cpp' "
- "products.\nWARNING this command NEEDS YACSGEN to run!\n\nexample:"
- "\nsat generate SALOME-master --products FLICACPP")
+ """
+ return _(
+ "The generate command generates SALOME modules from 'pure cpp' "
+ "products.\nWARNING this command NEEDS YACSGEN to run!\n\nexample:"
+ "\nsat generate SALOME-master --products FLICACPP"
+ )
def run(args, runner, logger):
- '''method that is called when salomeTools is called with generate parameter.
- '''
+ """method that is called when salomeTools is called with generate parameter."""
# Check that the command has been called with an application
src.check_config_has_application(runner.cfg)
- logger.write(_('Generation of SALOME modules for application %s\n') % \
- src.printcolors.printcLabel(runner.cfg.VARS.application), 1)
+ logger.write(
+ _("Generation of SALOME modules for application %s\n")
+ % src.printcolors.printcLabel(runner.cfg.VARS.application),
+ 1,
+ )
(options, args) = parser.parse_args(args)
logger.write(_("\nCleaning generated directories\n"), 3, False)
# clean source, build and install directories of the generated product
# no verbosity to avoid warning at the first generation, for which dirs don't exist
- runner.clean(runner.cfg.VARS.application +
- " --products " + pi.name +
- " --generated",
- batch=True,
- verbose=0,
- logger_add_link = logger)
+ runner.clean(
+ runner.cfg.VARS.application + " --products " + pi.name + " --generated",
+ batch=True,
+ verbose=0,
+ logger_add_link=logger,
+ )
nbgen += 1
try:
- result = generate_component_list(runner.cfg,
- product,
- pi,
- context,
- logger)
+ result = generate_component_list(runner.cfg, product, pi, context, logger)
except Exception as exc:
result = str(exc)
if len(details) == 0:
status = src.OK_STATUS
- else: #if config.USER.output_level != 3:
+ else: # if config.USER.output_level != 3:
logger.write("\n", 2, False)
logger.write(_("The following modules were not generated correctly:\n"), 2)
for d in details:
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2012 CEA/DEN
#
# This library is free software; you can redistribute it and/or
# Define all possible option for the init command : sat init <options>
parser = src.options.Options()
-parser.add_option('b', 'base', 'string', 'base',
- _('Optional: The path to the products base'))
-parser.add_option('w', 'workdir', 'string', 'workdir',
- _('Optional: The path to the working directory '
- '(where to install the applications'))
-parser.add_option('a', 'archive_dir', 'string', 'archive_dir',
- _('Optional: The path to the local archive directory '
- '(where to install local source archives'))
-parser.add_option('', 'add_project ', 'string', 'add_project',
- _('Optional: The path of the project to add'))
-parser.add_option('', 'reset_projects', 'boolean', 'reset_projects',
- _('Optional: Reset the list of projects'))
-parser.add_option('v', 'VCS', 'string', 'VCS',
- _('Optional: The address of the repository of SAT '
- '(only informative)'))
-parser.add_option('t', 'tag', 'string', 'tag',
- _('Optional: The tag of SAT (only informative)'))
-parser.add_option('l', 'log_dir', 'string', 'log_dir',
- _('Optional: The directory where to put all the logs of SAT'))
+parser.add_option(
+ "b", "base", "string", "base", _("Optional: The path to the products base")
+)
+parser.add_option(
+ "w",
+ "workdir",
+ "string",
+ "workdir",
+ _(
+ "Optional: The path to the working directory "
+ "(where to install the applications"
+ ),
+)
+parser.add_option(
+ "a",
+ "archive_dir",
+ "string",
+ "archive_dir",
+ _(
+ "Optional: The path to the local archive directory "
+ "(where to install local source archives"
+ ),
+)
+parser.add_option(
+ "",
+ "add_project ",
+ "string",
+ "add_project",
+ _("Optional: The path of the project to add"),
+)
+parser.add_option(
+ "",
+ "reset_projects",
+ "boolean",
+ "reset_projects",
+ _("Optional: Reset the list of projects"),
+)
+parser.add_option(
+ "v",
+ "VCS",
+ "string",
+ "VCS",
+ _("Optional: The address of the repository of SAT " "(only informative)"),
+)
+parser.add_option(
+ "t", "tag", "string", "tag", _("Optional: The tag of SAT (only informative)")
+)
+parser.add_option(
+ "l",
+ "log_dir",
+ "string",
+ "log_dir",
+ _("Optional: The directory where to put all the logs of SAT"),
+)
+
def set_local_value(config, key, value, logger):
- """ Edit the site.pyconf file and change a value.
+ """Edit the site.pyconf file and change a value.
- :param config Config: The global configuration.
+ :param config Config: The global configuration.
:param key Str: The key from which to change the value.
:param value Str: The path to change.
:param logger Logger: The logger instance.
try:
local_cfg = src.pyconf.Config(local_file_path)
local_cfg.LOCAL[key] = value
- ff = open(local_file_path, 'w')
+ ff = open(local_file_path, "w")
local_cfg.__save__(ff, 1)
ff.close()
if key != "log_dir":
msg = _("Unable to update the local.pyconf file: %s\n" % err)
logger.write(msg, 1)
return 1
-
+
return 0
-
+
+
def add_local_project(config, project_file, logger):
- """ Add a project in local configuration (file data/local.pyconf).
+ """Add a project in local configuration (file data/local.pyconf).
- :param config Config: The global configuration.
+ :param config Config: The global configuration.
:param new_project Str: The project pyconf file to add in local config.
:param logger Logger: The logger instance.
:return: 0 if all is OK, else 1
:rtype: int
"""
if not os.path.isfile(project_file):
- logger.write("Unable to add a project in local configuration, project file %s does not exist\n" % project_file, 1)
+ logger.write(
+ "Unable to add a project in local configuration, project file %s does not exist\n"
+ % project_file,
+ 1,
+ )
return 1
# check that the project file exists
try:
local_cfg = src.pyconf.Config(local_file_path)
local_cfg.PROJECTS.project_file_paths.append(project_file, "")
- ff = open(local_file_path, 'w')
+ ff = open(local_file_path, "w")
local_cfg.__save__(ff, 1)
ff.close()
config.PROJECTS.project_file_paths.append(project_file, "")
def reset_local_projects(config, logger):
- """ Reinitialise the list of projects in local configuration (file data/local.pyconf).
+ """Reinitialise the list of projects in local configuration (file data/local.pyconf).
- :param config Config: The global configuration.
+ :param config Config: The global configuration.
:param logger Logger: The logger instance.
:return: 0 if all is OK, else 1
:rtype: int
# Update the local.pyconf file
try:
local_cfg = src.pyconf.Config(local_file_path)
- local_cfg.PROJECTS.project_file_paths=src.pyconf.Sequence(local_cfg.PROJECTS)
- ff = open(local_file_path, 'w')
+ local_cfg.PROJECTS.project_file_paths = src.pyconf.Sequence(local_cfg.PROJECTS)
+ ff = open(local_file_path, "w")
local_cfg.__save__(ff, 1)
ff.close()
- config.PROJECTS.project_file_paths=src.pyconf.Sequence(config.PROJECTS)
+ config.PROJECTS.project_file_paths = src.pyconf.Sequence(config.PROJECTS)
except Exception as e:
err = str(e)
def display_local_values(config, logger):
- """ Display the base path
+ """Display the base path
:param config Config: The global configuration.
:param key Str: The key from which to change the value.
:param logger Logger: The logger instance.
"""
- info = [("base", config.LOCAL.base),
- ("workdir", config.LOCAL.workdir),
- ("log_dir", config.LOCAL.log_dir),
- ("archive_dir", config.LOCAL.archive_dir),
- ("VCS", config.LOCAL.VCS),
- ("tag", config.LOCAL.tag),
- ("projects", config.PROJECTS.project_file_paths)]
+ info = [
+ ("base", config.LOCAL.base),
+ ("workdir", config.LOCAL.workdir),
+ ("log_dir", config.LOCAL.log_dir),
+ ("archive_dir", config.LOCAL.archive_dir),
+ ("VCS", config.LOCAL.VCS),
+ ("tag", config.LOCAL.tag),
+ ("projects", config.PROJECTS.project_file_paths),
+ ]
src.print_info(logger, info)
return 0
+
def check_path(path_to_check, logger):
- """ Verify that the given path is not a file and can be created.
-
+ """Verify that the given path is not a file and can be created.
+
:param path_to_check Str: The path to check.
:param logger Logger: The logger instance.
"""
if path_to_check == "default":
return 0
-
+
# Get the path
path = src.Path(path_to_check)
-
+
# If it is a file, do nothing and return error
if path.isfile():
- msg = _("Error: The given path is a file. Please provide a path to "
- "a directory")
+ msg = _(
+ "Error: The given path is a file. Please provide a path to " "a directory"
+ )
logger.write(src.printcolors.printcError(msg), 1)
return 1
-
+
# Try to create the given path
try:
src.ensure_path_exists(str(path))
except Exception as e:
err = src.printcolors.printcError(str(e))
- msg = _("Unable to create the directory %s: %s\n" % (str(path),
- err))
+ msg = _("Unable to create the directory %s: %s\n" % (str(path), err))
logger.write(msg, 1)
return 1
-
+
return 0
+
def description():
- '''method that is called when salomeTools is called with --help option.
-
+ """method that is called when salomeTools is called with --help option.
+
:return: The text to display for the init command description.
:rtype: str
- '''
+ """
return _("The init command Changes the local settings of SAT.")
-
+
+
def run(args, runner, logger):
- '''method that is called when salomeTools is called with init parameter.
- '''
-
+ """method that is called when salomeTools is called with init parameter."""
+
# Parse the options
(options, args) = parser.parse_args(args)
-
+
# Print some informations
- logger.write(_('Local Settings of SAT %s\n\n') %
- src.printcolors.printcLabel(runner.cfg.VARS.salometoolsway), 1)
+ logger.write(
+ _("Local Settings of SAT %s\n\n")
+ % src.printcolors.printcLabel(runner.cfg.VARS.salometoolsway),
+ 1,
+ )
res = 0
-
# Set the options corresponding to a directory
- for opt in [("base" , options.base),
- ("workdir", options.workdir),
- ("log_dir", options.log_dir),
- ("archive_dir", options.archive_dir)]:
+ for opt in [
+ ("base", options.base),
+ ("workdir", options.workdir),
+ ("log_dir", options.log_dir),
+ ("archive_dir", options.archive_dir),
+ ]:
key, value = opt
if value:
res_check = check_path(value, logger)
# set the options corresponding to projects file names
if options.add_project:
- res_add=add_local_project(runner.cfg, options.add_project, logger)
+ res_add = add_local_project(runner.cfg, options.add_project, logger)
res += res_add
if options.reset_projects:
- res_rem=reset_local_projects(runner.cfg, logger)
+ res_rem = reset_local_projects(runner.cfg, logger)
res += res_rem
- # Set the options corresponding to an informative value
+ # Set the options corresponding to an informative value
for opt in [("VCS", options.VCS), ("tag", options.tag)]:
key, value = opt
if value:
res_set = set_local_value(runner.cfg, key, value, logger)
res += res_set
-
+
display_local_values(runner.cfg, logger)
-
+
return res
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2012 CEA/DEN
#
# This library is free software; you can redistribute it and/or
import prepare
import src.debug as DBG
-PACKAGE_EXT=".tar.gz" # the extension we use for the packages
+PACKAGE_EXT = ".tar.gz" # the extension we use for the packages
# Define all possible option for patch command : sat patch <options>
parser = src.options.Options()
-parser.add_option('p', 'products', 'list2', 'products',
- _('Optional: products from which to get the sources. This option accepts a comma separated list.'))
+parser.add_option(
+ "p",
+ "products",
+ "list2",
+ "products",
+ _(
+ "Optional: products from which to get the sources. This option accepts a comma separated list."
+ ),
+)
def get_binary_from_archive(config, product_name, product_info, install_dir, logger):
- '''The method get the binary of the product from an archive
-
+ """The method get the binary of the product from an archive
+
:param config Config: The global configuration
:param product_name : The name of the product
- :param product_info Config: The configuration specific to
+ :param product_info Config: The configuration specific to
the product to be prepared
- :param install_dir Path: The Path instance corresponding to the
+ :param install_dir Path: The Path instance corresponding to the
directory where to put the sources
:param logger Logger: The logger instance to use for the display and logging
:return: True if it succeed, else False
:rtype: boolean
- '''
-
+ """
# check archive exists
# the expected name of the bin archive, as produced by sat package --bin_products
- archive_name = product_name + '-' + product_info.version + "-" + config.VARS.dist + PACKAGE_EXT
+ archive_name = (
+ product_name + "-" + product_info.version + "-" + config.VARS.dist + PACKAGE_EXT
+ )
# we search this archive in bin directory
- bin_arch_name = os.path.join("bin",archive_name)
+ bin_arch_name = os.path.join("bin", archive_name)
# search in the config.PATHS.ARCHIVEPATH
arch_path = src.find_file_in_lpath(archive_name, config.PATHS.ARCHIVEPATH, "bin")
if not arch_path:
# bin archive was not found locally in ARCHIVEPATH
# search on ftp site
- logger.write("\n The bin archive is not found on local file system, we try ftp\n", 3)
- ret=src.find_file_in_ftppath(archive_name, config.PATHS.ARCHIVEFTP,
- config.LOCAL.archive_dir, logger, "bin")
-
+ logger.write(
+ "\n The bin archive is not found on local file system, we try ftp\n", 3
+ )
+ ret = src.find_file_in_ftppath(
+ archive_name,
+ config.PATHS.ARCHIVEFTP,
+ config.LOCAL.archive_dir,
+ logger,
+ "bin",
+ )
+
if ret:
# archive was found on ftp and stored in ret
arch_path = ret
else:
- logger.write('%s ' % src.printcolors.printc(src.OK_STATUS), 3, False)
- msg = _("Archive not found in ARCHIVEPATH, nor on ARCHIVEFTP: '%s'") % bin_arch_name
+ logger.write("%s " % src.printcolors.printc(src.OK_STATUS), 3, False)
+ msg = (
+ _("Archive not found in ARCHIVEPATH, nor on ARCHIVEFTP: '%s'")
+ % bin_arch_name
+ )
logger.write(msg, 3)
return 1
- logger.write('arc:%s ... ' %
- src.printcolors.printcInfo(archive_name),
- 3,
- False)
+ logger.write("arc:%s ... " % src.printcolors.printcInfo(archive_name), 3, False)
logger.flush()
# Call the system function that do the extraction in archive mode
- retcode, NameExtractedDirectory = src.system.archive_extract(arch_path,
- install_dir.dir(), logger)
-
- # Rename the source directory if
+ retcode, NameExtractedDirectory = src.system.archive_extract(
+ arch_path, install_dir.dir(), logger
+ )
+
+ # Rename the source directory if
# it does not match with product_info.source_dir
- if (NameExtractedDirectory.replace('/', '') !=
- os.path.basename(product_info.install_dir)):
- shutil.move(os.path.join(os.path.dirname(product_info.install_dir),
- NameExtractedDirectory),
- product_info.install_dir)
-
- return retcode
+ if NameExtractedDirectory.replace("/", "") != os.path.basename(
+ product_info.install_dir
+ ):
+ shutil.move(
+ os.path.join(
+ os.path.dirname(product_info.install_dir), NameExtractedDirectory
+ ),
+ product_info.install_dir,
+ )
+ return retcode
def get_all_product_binaries(config, products, logger):
- '''Get all the product sources.
-
+ """Get all the product sources.
+
:param config Config: The global configuration
:param products List: The list of tuples (product name, product informations)
:param logger Logger: The logger instance to be used for the logging
:return: the tuple (number of success, dictionary product_name/success_fail)
:rtype: (int,dict)
- '''
+ """
# Initialize the variables that will count the fails and success
results = dict()
max_product_name_len = 1
if len(products) > 0:
max_product_name_len = max(map(lambda l: len(l), products[0])) + 4
-
+
# The loop on all the products from which to get the binaries
for product_name, product_info in products:
# display and log
- logger.write('%s: ' % src.printcolors.printcLabel(product_name), 3)
- logger.write(' ' * (max_product_name_len - len(product_name)), 3, False)
+ logger.write("%s: " % src.printcolors.printcLabel(product_name), 3)
+ logger.write(" " * (max_product_name_len - len(product_name)), 3, False)
logger.write("\n", 4, False)
#
- do_install_prod=True
+ do_install_prod = True
# check if there is something to do!
if src.product.product_is_fixed(product_info):
- do_install_prod=False
- msg = _("INFO : Not doing anything because the products %s is fixed\n") % product_name
+ do_install_prod = False
+ msg = (
+ _("INFO : Not doing anything because the products %s is fixed\n")
+ % product_name
+ )
elif src.product.product_is_native(product_info):
- do_install_prod=False
- msg = _("INFO : Not doing anything because the products %s is native\n") % product_name
- elif src.appli_test_property(config,"pip", "yes") and \
- src.product.product_test_property(product_info,"pip", "yes"):
- do_install_prod=False
- msg = _("INFO : Not doing anything because the products %s is managed by pip\n") % product_name
+ do_install_prod = False
+ msg = (
+ _("INFO : Not doing anything because the products %s is native\n")
+ % product_name
+ )
+ elif src.appli_test_property(
+ config, "pip", "yes"
+ ) and src.product.product_test_property(product_info, "pip", "yes"):
+ do_install_prod = False
+ msg = (
+ _(
+ "INFO : Not doing anything because the products %s is managed by pip\n"
+ )
+ % product_name
+ )
else:
- install_dir=src.Path(product_info.install_dir)
+ install_dir = src.Path(product_info.install_dir)
if install_dir.exists():
- do_install_prod=False
- msg = _("INFO : Not doing anything because the install directory already exists:\n %s\n") % install_dir
+ do_install_prod = False
+ msg = (
+ _(
+ "INFO : Not doing anything because the install directory already exists:\n %s\n"
+ )
+ % install_dir
+ )
if not do_install_prod:
- logger.write('%s ' % src.printcolors.printc(src.OK_STATUS), 3, False)
+ logger.write("%s " % src.printcolors.printc(src.OK_STATUS), 3, False)
logger.write(msg, 3)
- good_result = good_result + 1
+ good_result = good_result + 1
# Do not get the binaries and go to next product
continue
# we neeed to install binaries for the product
- retcode = get_binary_from_archive(config, product_name, product_info, install_dir, logger)
+ retcode = get_binary_from_archive(
+ config, product_name, product_info, install_dir, logger
+ )
# Check that the sources are correctly get using the files to be tested
# in product information
if retcode:
pass
# CNC TODO check md5sum
- #check_OK, wrong_path = check_sources(product_info, logger)
- #if not check_OK:
+ # check_OK, wrong_path = check_sources(product_info, logger)
+ # if not check_OK:
# # Print the missing file path
# msg = _("The required file %s does not exists. " % wrong_path)
# logger.write(src.printcolors.printcError("\nERROR: ") + msg, 3)
# retcode = False
-# does post install substitutions
-#for f in $(grep -RIl -e /volatile/salome/jenkins/workspace/Salome_master_CO7/SALOME-9.7.0-CO7/INSTALL INSTALL); do
-# sed -i "
-# s?/volatile/salome/jenkins/workspace/Salome_master_CO7/SALOME-9.7.0-CO7/INSTALL?$(pwd)/INSTALL?g
-# " $f
-#done
-
+ # does post install substitutions
+ # for f in $(grep -RIl -e /volatile/salome/jenkins/workspace/Salome_master_CO7/SALOME-9.7.0-CO7/INSTALL INSTALL); do
+ # sed -i "
+ # s?/volatile/salome/jenkins/workspace/Salome_master_CO7/SALOME-9.7.0-CO7/INSTALL?$(pwd)/INSTALL?g
+ # " $f
+ # done
# show results
results[product_name] = retcode
else:
# The case where it failed
res = src.KO_STATUS
-
+
# print the result
if do_install_prod:
- logger.write('%s\n' % src.printcolors.printc(res), 3, False)
+ logger.write("%s\n" % src.printcolors.printc(res), 3, False)
return good_result, results
+
def check_sources(product_info, logger):
- '''Check that the sources are correctly get, using the files to be tested
+ """Check that the sources are correctly get, using the files to be tested
in product information
-
- :param product_info Config: The configuration specific to
+
+ :param product_info Config: The configuration specific to
the product to be prepared
:return: True if the files exists (or no files to test is provided).
:rtype: boolean
- '''
+ """
# Get the files to test if there is any
- if ("present_files" in product_info and
- "source" in product_info.present_files):
+ if "present_files" in product_info and "source" in product_info.present_files:
l_files_to_be_tested = product_info.present_files.source
for file_path in l_files_to_be_tested:
- # The path to test is the source directory
+ # The path to test is the source directory
# of the product joined the file path provided
path_to_test = os.path.join(product_info.source_dir, file_path)
logger.write(_("\nTesting existence of file: \n"), 5)
logger.write(src.printcolors.printcSuccess(" OK\n"), 5)
return True, ""
+
def description():
- '''method that is called when salomeTools is called with --help option.
-
+ """method that is called when salomeTools is called with --help option.
+
:return: The text to display for the source command description.
:rtype: str
- '''
- return _("The install command gets the binaries of the application products "
- "from local (ARCHIVEPATH) or ftp server.\n\nexample:"
- "\nsat install SALOME-master --products GEOM,SMESH")
-
+ """
+ return _(
+ "The install command gets the binaries of the application products "
+ "from local (ARCHIVEPATH) or ftp server.\n\nexample:"
+ "\nsat install SALOME-master --products GEOM,SMESH"
+ )
+
+
def run(args, runner, logger):
- '''method that is called when salomeTools is called with install parameter.
- '''
+ """method that is called when salomeTools is called with install parameter."""
DBG.write("install.run()", args)
# Parse the options
(options, args) = parser.parse_args(args)
-
+
# check that the command has been called with an application
- src.check_config_has_application( runner.cfg )
+ src.check_config_has_application(runner.cfg)
# Print some informations
- logger.write(_('Getting binaries of the application %s\n') %
- src.printcolors.printcLabel(runner.cfg.VARS.application), 1)
- src.printcolors.print_value(logger, 'workdir',
- runner.cfg.APPLICATION.workdir, 2)
+ logger.write(
+ _("Getting binaries of the application %s\n")
+ % src.printcolors.printcLabel(runner.cfg.VARS.application),
+ 1,
+ )
+ src.printcolors.print_value(logger, "workdir", runner.cfg.APPLICATION.workdir, 2)
logger.write("\n", 2, False)
-
# Get the list of all application products, and create its dependency graph
- all_products_infos = src.product.get_products_infos(runner.cfg.APPLICATION.products,
- runner.cfg)
- from compile import get_dependencies_graph,depth_search_graph
- all_products_graph=get_dependencies_graph(all_products_infos)
- #logger.write("Dependency graph of all application products : %s\n" % all_products_graph, 6)
+ all_products_infos = src.product.get_products_infos(
+ runner.cfg.APPLICATION.products, runner.cfg
+ )
+ from compile import get_dependencies_graph, depth_search_graph
+
+ all_products_graph = get_dependencies_graph(all_products_infos)
+ # logger.write("Dependency graph of all application products : %s\n" % all_products_graph, 6)
DBG.write("Dependency graph of all application products : ", all_products_graph)
- products_infos=[]
+ products_infos = []
if options.products is None:
- #implicit selection of all products
+ # implicit selection of all products
products_infos = all_products_infos
else:
# a list of products is specified
- products_list=options.products
+ products_list = options.products
# we evaluate the complete list including dependencies (~ to the --with-fathers of sat compile)
# Extend the list with all recursive dependencies of the given products
- visited=[]
+ visited = []
for p_name in products_list:
- visited=depth_search_graph(all_products_graph, p_name, visited)
+ visited = depth_search_graph(all_products_graph, p_name, visited)
products_list = visited
- logger.write("Product we have to compile (as specified by user) : %s\n" % products_list, 5)
+ logger.write(
+ "Product we have to compile (as specified by user) : %s\n" % products_list,
+ 5,
+ )
# Create a dict of all products to facilitate products_infos sorting
- all_products_dict={}
- for (pname,pinfo) in all_products_infos:
- all_products_dict[pname]=(pname,pinfo)
+ all_products_dict = {}
+ for (pname, pinfo) in all_products_infos:
+ all_products_dict[pname] = (pname, pinfo)
# build products_infos for the products we have to install
for product in products_list:
products_infos.append(all_products_dict[product])
-
-
# Call to the function that gets all the sources
- good_result, results = get_all_product_binaries(runner.cfg,
- products_infos,
- logger)
+ good_result, results = get_all_product_binaries(runner.cfg, products_infos, logger)
# Display the results (how much passed, how much failed, etc...)
status = src.OK_STATUS
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2012 CEA/DEN
#
# This library is free software; you can redistribute it and/or
# Define all possible option for the make command : sat make <options>
parser = src.options.Options()
-parser.add_option('j', 'jobs_config', 'string', 'jobs_cfg',
- _('Mandatory: The name of the config file that contains'
- ' the jobs configuration'))
-parser.add_option('', 'name', 'string', 'job',
- _('Mandatory: The job name from which to execute commands.'), "")
+parser.add_option(
+ "j",
+ "jobs_config",
+ "string",
+ "jobs_cfg",
+ _("Mandatory: The name of the config file that contains" " the jobs configuration"),
+)
+parser.add_option(
+ "",
+ "name",
+ "string",
+ "job",
+ _("Mandatory: The job name from which to execute commands."),
+ "",
+)
+
def description():
- '''method that is called when salomeTools is called with --help option.
-
+ """method that is called when salomeTools is called with --help option.
+
:return: The text to display for the job command description.
:rtype: str
- '''
- return _("""\
+ """
+ return _(
+ """\
The job command executes the commands of the job defined in the jobs configuration file
example:
>> sat job --jobs_config my_jobs --name my_job
-""")
-
+"""
+ )
+
+
def run(args, runner, logger):
- '''method that is called when salomeTools is called with job parameter.
- '''
-
+ """method that is called when salomeTools is called with job parameter."""
+
# Parse the options
(options, args) = parser.parse_args(args)
-
+
l_cfg_dir = runner.cfg.PATHS.JOBPATH
-
+
# Make sure the jobs_config option has been called
if not options.jobs_cfg:
- message = _("The option --jobs_config is required\n")
+ message = _("The option --jobs_config is required\n")
logger.write(src.printcolors.printcError(message))
return 1
-
+
# Make sure the name option has been called
if not options.job:
- message = _("The option --name is required\n")
+ message = _("The option --name is required\n")
logger.write(src.printcolors.printcError(message))
return 1
-
+
# Find the file in the directories
found = False
for cfg_dir in l_cfg_dir:
file_jobs_cfg = os.path.join(cfg_dir, options.jobs_cfg)
- if not file_jobs_cfg.endswith('.pyconf'):
- file_jobs_cfg += '.pyconf'
-
+ if not file_jobs_cfg.endswith(".pyconf"):
+ file_jobs_cfg += ".pyconf"
+
if not os.path.exists(file_jobs_cfg):
continue
else:
found = True
break
-
+
if not found:
- msg = _("The file configuration %(name_file)s was not found."
- "\nUse the --list option to get the possible files.")
+ msg = _(
+ "The file configuration %(name_file)s was not found."
+ "\nUse the --list option to get the possible files."
+ )
src.printcolors.printcError(msg)
return 1
-
+
info = [
- (_("Platform"), runner.cfg.VARS.dist),
- (_("File containing the jobs configuration"), file_jobs_cfg)
+ (_("Platform"), runner.cfg.VARS.dist),
+ (_("File containing the jobs configuration"), file_jobs_cfg),
]
src.print_info(logger, info)
-
+
# Read the config that is in the file
config_jobs = src.read_config_from_a_file(file_jobs_cfg)
-
+
# Find the job and its commands
found = False
for job in config_jobs.jobs:
found = True
break
if not found:
- msg = _("Impossible to find the job \"%(job_name)s\" in "
- "%(jobs_config_file)s" % {"job_name" : options.job,
- "jobs_config_file" : file_jobs_cfg})
+ msg = _(
+ 'Impossible to find the job "%(job_name)s" in '
+ "%(jobs_config_file)s"
+ % {"job_name": options.job, "jobs_config_file": file_jobs_cfg}
+ )
logger.write(src.printcolors.printcError(msg) + "\n")
return 1
-
+
# Find the maximum length of the commands in order to format the display
len_max_command = max([len(cmd) for cmd in commands])
-
+
# Loop over the commands and execute it
res = 0
nb_pass = 0
for command in commands:
specific_option = False
# Determine if it is a sat command or a shell command
- cmd_exe = command.split(" ")[0] # first part
+ cmd_exe = command.split(" ")[0] # first part
if cmd_exe == "sat":
# use the salomeTools parser to get the options of the command
sat_parser = src.salomeTools.parser
- input_parser = src.remove_item_from_list(command.split(' ')[1:], "")
+ input_parser = src.remove_item_from_list(command.split(" ")[1:], "")
(options, argus) = sat_parser.parse_args(input_parser)
# Verify if there is a changed option
for attr in dir(options):
sat_command_name = "shell"
end_cmd = ["--command", command]
# Do not change the options if no option was called in the command
- if not(specific_option):
+ if not (specific_option):
options = None
# Get dynamically the command function to call
sat_command = runner.__getattr__(sat_command_name)
- logger.write("Executing " +
- src.printcolors.printcLabel(command) + " ", 3)
+ logger.write("Executing " + src.printcolors.printcLabel(command) + " ", 3)
logger.write("." * (len_max_command - len(command)) + " ", 3)
logger.flush()
-
+
error = ""
stack = ""
# Execute the command
- code = sat_command(end_cmd,
- options = options,
- batch = True,
- verbose = 0,
- logger_add_link = logger)
-
+ code = sat_command(
+ end_cmd, options=options, batch=True, verbose=0, logger_add_link=logger
+ )
+
# Print the status of the command
if code == 0:
nb_pass += 1
- logger.write('%s\n' % src.printcolors.printc(src.OK_STATUS), 3)
+ logger.write("%s\n" % src.printcolors.printc(src.OK_STATUS), 3)
else:
if sat_command_name != "test":
res = 1
- logger.write('%s %s\n' % (src.printcolors.printc(src.KO_STATUS),
- error), 3)
+ logger.write("%s %s\n" % (src.printcolors.printc(src.KO_STATUS), error), 3)
if len(stack) > 0:
- logger.write('stack: %s\n' % stack, 3)
-
+ logger.write("stack: %s\n" % stack, 3)
+
# Print the final state
if res == 0:
final_status = "OK"
else:
final_status = "KO"
-
- logger.write(_("\nCommands: %(status)s (%(valid_result)d/%(nb_products)d)\n") % \
- { 'status': src.printcolors.printc(final_status),
- 'valid_result': nb_pass,
- 'nb_products': len(commands) }, 3)
-
- return res
\ No newline at end of file
+
+ logger.write(
+ _("\nCommands: %(status)s (%(valid_result)d/%(nb_products)d)\n")
+ % {
+ "status": src.printcolors.printc(final_status),
+ "valid_result": nb_pass,
+ "nb_products": len(commands),
+ },
+ 3,
+ )
+
+ return res
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2013 CEA/DEN
#
# This library is free software; you can redistribute it and/or
# generate problem
try:
- import paramiko
+ import paramiko
except:
- paramiko = "import paramiko impossible"
- pass
+ paramiko = "import paramiko impossible"
+ pass
import src
parser = src.options.Options()
-parser.add_option('n', 'name', 'list2', 'jobs_cfg',
- _('Mandatory: The name of the config file that contains'
- ' the jobs configuration. Can be a list.'))
-parser.add_option('o', 'only_jobs', 'list2', 'only_jobs',
- _('Optional: the list of jobs to launch, by their name. '))
-parser.add_option('l', 'list', 'boolean', 'list',
- _('Optional: list all available config files.'))
-parser.add_option('t', 'test_connection', 'boolean', 'test_connection',
- _("Optional: try to connect to the machines. "
- "Not executing the jobs."),
- False)
-parser.add_option('p', 'publish', 'boolean', 'publish',
- _("Optional: generate an xml file that can be read in a "
- "browser to display the jobs status."),
- False)
-parser.add_option('i', 'input_boards', 'string', 'input_boards', _("Optional: "
- "the path to csv file that contain "
- "the expected boards."),"")
-parser.add_option('', 'completion', 'boolean', 'no_label',
- _("Optional (internal use): do not print labels, Works only "
- "with --list."),
- False)
+parser.add_option(
+ "n",
+ "name",
+ "list2",
+ "jobs_cfg",
+ _(
+ "Mandatory: The name of the config file that contains"
+ " the jobs configuration. Can be a list."
+ ),
+)
+parser.add_option(
+ "o",
+ "only_jobs",
+ "list2",
+ "only_jobs",
+ _("Optional: the list of jobs to launch, by their name. "),
+)
+parser.add_option(
+ "l", "list", "boolean", "list", _("Optional: list all available config files.")
+)
+parser.add_option(
+ "t",
+ "test_connection",
+ "boolean",
+ "test_connection",
+ _("Optional: try to connect to the machines. " "Not executing the jobs."),
+ False,
+)
+parser.add_option(
+ "p",
+ "publish",
+ "boolean",
+ "publish",
+ _(
+ "Optional: generate an xml file that can be read in a "
+ "browser to display the jobs status."
+ ),
+ False,
+)
+parser.add_option(
+ "i",
+ "input_boards",
+ "string",
+ "input_boards",
+ _("Optional: " "the path to csv file that contain " "the expected boards."),
+ "",
+)
+parser.add_option(
+ "",
+ "completion",
+ "boolean",
+ "no_label",
+ _("Optional (internal use): do not print labels, Works only " "with --list."),
+ False,
+)
+
class Machine(object):
- '''Class to manage a ssh connection on a machine
- '''
- def __init__(self,
- name,
- host,
- user,
- port=22,
- passwd=None,
- sat_path="salomeTools"):
+ """Class to manage a ssh connection on a machine"""
+
+ def __init__(self, name, host, user, port=22, passwd=None, sat_path="salomeTools"):
self.name = name
self.host = host
self.port = port
- self.distribution = None # Will be filled after copying SAT on the machine
+ self.distribution = None # Will be filled after copying SAT on the machine
self.user = user
self.password = passwd
self.sat_path = sat_path
self.ssh = paramiko.SSHClient()
self._connection_successful = None
-
+
def connect(self, logger):
- '''Initiate the ssh connection to the remote machine
-
- :param logger src.logger.Logger: The logger instance
+ """Initiate the ssh connection to the remote machine
+
+ :param logger src.logger.Logger: The logger instance
:return: Nothing
:rtype: N\A
- '''
+ """
self._connection_successful = False
self.ssh.load_system_host_keys()
self.ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
try:
- self.ssh.connect(self.host,
- port=self.port,
- username=self.user,
- password = self.password)
+ self.ssh.connect(
+ self.host, port=self.port, username=self.user, password=self.password
+ )
except paramiko.AuthenticationException:
message = src.KO_STATUS + _("Authentication failed")
except paramiko.BadHostKeyException:
- message = (src.KO_STATUS +
- _("The server's host key could not be verified"))
+ message = src.KO_STATUS + _("The server's host key could not be verified")
except paramiko.SSHException:
- message = ( _("SSHException error connecting or "
- "establishing an SSH session"))
+ message = _(
+ "SSHException error connecting or " "establishing an SSH session"
+ )
except:
- message = ( _("Error connecting or establishing an SSH session"))
+ message = _("Error connecting or establishing an SSH session")
else:
self._connection_successful = True
message = ""
return message
-
+
def successfully_connected(self, logger):
- '''Verify if the connection to the remote machine has succeed
-
- :param logger src.logger.Logger: The logger instance
+ """Verify if the connection to the remote machine has succeed
+
+ :param logger src.logger.Logger: The logger instance
:return: True if the connection has succeed, False if not
:rtype: bool
- '''
+ """
if self._connection_successful == None:
- message = _("Warning : trying to ask if the connection to "
- "(name: %s host: %s, port: %s, user: %s) is OK whereas there were"
- " no connection request" %
- (self.name, self.host, self.port, self.user))
- logger.write( src.printcolors.printcWarning(message))
+ message = _(
+ "Warning : trying to ask if the connection to "
+ "(name: %s host: %s, port: %s, user: %s) is OK whereas there were"
+ " no connection request" % (self.name, self.host, self.port, self.user)
+ )
+ logger.write(src.printcolors.printcWarning(message))
return self._connection_successful
def copy_sat(self, sat_local_path, job_file):
- '''Copy salomeTools to the remote machine in self.sat_path
- '''
+ """Copy salomeTools to the remote machine in self.sat_path"""
res = 0
try:
# open a sftp connection
# Create the sat directory on remote machine if it is not existing
self.mkdir(self.sat_path, ignore_existing=True)
# Put sat
- self.put_dir(sat_local_path, self.sat_path, filters = ['.git'])
- # put the job configuration file in order to make it reachable
+ self.put_dir(sat_local_path, self.sat_path, filters=[".git"])
+ # put the job configuration file in order to make it reachable
# on the remote machine
remote_job_file_name = ".%s" % os.path.basename(job_file)
- self.sftp.put(job_file, os.path.join(self.sat_path,
- remote_job_file_name))
+ self.sftp.put(job_file, os.path.join(self.sat_path, remote_job_file_name))
except Exception as e:
res = str(e)
self._connection_successful = False
-
+
return res
-
- def put_dir(self, source, target, filters = []):
- ''' Uploads the contents of the source directory to the target path. The
- target directory needs to exists. All sub-directories in source are
- created under target.
- '''
+
+ def put_dir(self, source, target, filters=[]):
+ """Uploads the contents of the source directory to the target path. The
+ target directory needs to exists. All sub-directories in source are
+ created under target.
+ """
for item in os.listdir(source):
if item in filters:
continue
linkto = os.readlink(source_path)
try:
self.sftp.symlink(linkto, destination_path)
- self.sftp.chmod(destination_path,
- os.stat(source_path).st_mode)
+ self.sftp.chmod(destination_path, os.stat(source_path).st_mode)
except IOError:
pass
else:
if os.path.isfile(source_path):
self.sftp.put(source_path, destination_path)
- self.sftp.chmod(destination_path,
- os.stat(source_path).st_mode)
+ self.sftp.chmod(destination_path, os.stat(source_path).st_mode)
else:
self.mkdir(destination_path, ignore_existing=True)
self.put_dir(source_path, destination_path)
def mkdir(self, path, mode=511, ignore_existing=False):
- ''' Augments mkdir by adding an option to not fail
- if the folder exists
- '''
+ """Augments mkdir by adding an option to not fail
+ if the folder exists
+ """
try:
self.sftp.mkdir(path, mode)
except IOError:
if ignore_existing:
pass
else:
- raise
-
+ raise
+
def exec_command(self, command, logger):
- '''Execute the command on the remote machine
-
+ """Execute the command on the remote machine
+
:param command str: The command to be run
- :param logger src.logger.Logger: The logger instance
+ :param logger src.logger.Logger: The logger instance
:return: the stdin, stdout, and stderr of the executing command,
as a 3-tuple
:rtype: (paramiko.channel.ChannelFile, paramiko.channel.ChannelFile,
paramiko.channel.ChannelFile)
- '''
- try:
+ """
+ try:
# Does not wait the end of the command
(stdin, stdout, stderr) = self.ssh.exec_command(command)
except paramiko.SSHException:
- message = src.KO_STATUS + _(
- ": the server failed to execute the command\n")
- logger.write( src.printcolors.printcError(message))
+ message = src.KO_STATUS + _(": the server failed to execute the command\n")
+ logger.write(src.printcolors.printcError(message))
return (None, None, None)
except:
- logger.write( src.printcolors.printcError(src.KO_STATUS + '\n'))
+ logger.write(src.printcolors.printcError(src.KO_STATUS + "\n"))
return (None, None, None)
else:
return (stdin, stdout, stderr)
def close(self):
- '''Close the ssh connection
-
+ """Close the ssh connection
+
:rtype: N\A
- '''
+ """
self.ssh.close()
-
+
def write_info(self, logger):
- '''Prints the informations relative to the machine in the logger
+ """Prints the informations relative to the machine in the logger
(terminal traces and log file)
-
+
:param logger src.logger.Logger: The logger instance
:return: Nothing
:rtype: N\A
- '''
+ """
logger.write("host : " + self.host + "\n")
logger.write("port : " + str(self.port) + "\n")
logger.write("user : " + str(self.user) + "\n")
status = src.OK_STATUS
else:
status = src.KO_STATUS
- logger.write("Connection : " + status + "\n\n")
+ logger.write("Connection : " + status + "\n\n")
class Job(object):
- '''Class to manage one job
- '''
- def __init__(self,
- name,
- machine,
- application,
- board,
- commands,
- timeout,
- config,
- job_file_path,
- logger,
- after=None,
- prefix=None):
+ """Class to manage one job"""
+
+ def __init__(
+ self,
+ name,
+ machine,
+ application,
+ board,
+ commands,
+ timeout,
+ config,
+ job_file_path,
+ logger,
+ after=None,
+ prefix=None,
+ ):
self.name = name
self.machine = machine
self.board = board
self.config = config
self.logger = logger
- # The list of log files to download from the remote machine
+ # The list of log files to download from the remote machine
self.remote_log_files = []
-
+
# The remote command status
- # -1 means that it has not been launched,
+ # -1 means that it has not been launched,
# 0 means success and 1 means fail
self.res_job = "-1"
self.cancelled = False
-
+
self._T0 = -1
self._Tf = -1
self._has_begun = False
self._has_finished = False
self._has_timouted = False
- self._stdin = None # Store the command inputs field
- self._stdout = None # Store the command outputs field
- self._stderr = None # Store the command errors field
+ self._stdin = None # Store the command inputs field
+ self._stdout = None # Store the command outputs field
+ self._stderr = None # Store the command errors field
self.out = ""
self.err = ""
-
+
self.name_remote_jobs_pyconf = ".%s" % os.path.basename(job_file_path)
self.commands = commands
- self.command = (os.path.join(self.machine.sat_path, "sat") +
- " -l " +
- os.path.join(self.machine.sat_path,
- "list_log_files.txt") +
- " job --jobs_config " +
- os.path.join(self.machine.sat_path,
- self.name_remote_jobs_pyconf) +
- " --name " + self.name)
+ self.command = (
+ os.path.join(self.machine.sat_path, "sat")
+ + " -l "
+ + os.path.join(self.machine.sat_path, "list_log_files.txt")
+ + " job --jobs_config "
+ + os.path.join(self.machine.sat_path, self.name_remote_jobs_pyconf)
+ + " --name "
+ + self.name
+ )
if prefix:
- self.command = prefix + ' "' + self.command +'"'
-
+ self.command = prefix + ' "' + self.command + '"'
+
def get_pids(self):
- """ Get the pid(s) corresponding to the command that have been launched
+ """Get the pid(s) corresponding to the command that have been launched
On the remote machine
-
+
:return: The list of integers corresponding to the found pids
:rtype: List
"""
pids = []
- cmd_pid = 'ps aux | grep "' + self.command + '" | awk \'{print $2}\''
+ cmd_pid = 'ps aux | grep "' + self.command + "\" | awk '{print $2}'"
(_, out_pid, _) = self.machine.exec_command(cmd_pid, self.logger)
pids_cmd = out_pid.readlines()
pids_cmd = [str(src.only_numbers(pid)) for pid in pids_cmd]
- pids+=pids_cmd
+ pids += pids_cmd
return pids
-
+
def kill_remote_process(self, wait=1):
- '''Kills the process on the remote machine.
-
+ """Kills the process on the remote machine.
+
:return: (the output of the kill, the error of the kill)
:rtype: (str, str)
- '''
+ """
try:
pids = self.get_pids()
except:
return ("Unable to get the pid of the command.", "")
-
+
cmd_kill = " ; ".join([("kill -2 " + pid) for pid in pids])
- (_, out_kill, err_kill) = self.machine.exec_command(cmd_kill,
- self.logger)
+ (_, out_kill, err_kill) = self.machine.exec_command(cmd_kill, self.logger)
time.sleep(wait)
return (out_kill.read().decode(), err_kill.read().decode())
-
+
def has_begun(self):
- '''Returns True if the job has already begun
-
+ """Returns True if the job has already begun
+
:return: True if the job has already begun
:rtype: bool
- '''
+ """
return self._has_begun
-
+
def has_finished(self):
- '''Returns True if the job has already finished
+ """Returns True if the job has already finished
(i.e. all the commands have been executed)
If it is finished, the outputs are stored in the fields out and err.
-
+
:return: True if the job has already finished
:rtype: bool
- '''
-
+ """
+
# If the method has already been called and returned True
if self._has_finished:
return True
-
+
# If the job has not begun yet
if not self.has_begun():
return False
-
+
if self._stdout.channel.closed:
self._has_finished = True
# Store the result outputs
self.get_log_files()
except Exception as e:
self.err += _("Unable to get remote log files: %s" % e)
-
+
return self._has_finished
-
+
def get_log_files(self):
- """Get the log files produced by the command launched
- on the remote machine, and put it in the log directory of the user,
- so they can be accessible from
+ """Get the log files produced by the command launched
+ on the remote machine, and put it in the log directory of the user,
+ so they can be accessible from
"""
# Do not get the files if the command is not finished
if not self.has_finished():
msg = _("Trying to get log files whereas the job is not finished.")
self.logger.write(src.printcolors.printcWarning(msg))
return
-
+
# First get the file that contains the list of log files to get
tmp_file_path = src.get_tmp_filename(self.config, "list_log_files.txt")
remote_path = os.path.join(self.machine.sat_path, "list_log_files.txt")
- self.machine.sftp.get(
- remote_path,
- tmp_file_path)
-
+ self.machine.sftp.get(remote_path, tmp_file_path)
+
# Read the file and get the result of the command and all the log files
# to get
fstream_tmp = open(tmp_file_path, "r")
file_lines = [line.replace("\n", "") for line in file_lines]
fstream_tmp.close()
os.remove(tmp_file_path)
-
- try :
+
+ try:
# The first line is the result of the command (0 success or 1 fail)
self.res_job = file_lines[0]
except Exception as e:
- self.err += _("Unable to get status from remote file %s: %s" %
- (remote_path, str(e)))
+ self.err += _(
+ "Unable to get status from remote file %s: %s" % (remote_path, str(e))
+ )
for i, job_path_remote in enumerate(file_lines[1:]):
try:
# For each command, there is two files to get :
- # 1- The xml file describing the command and giving the
+ # 1- The xml file describing the command and giving the
# internal traces.
- # 2- The txt file containing the system command traces (like
+ # 2- The txt file containing the system command traces (like
# traces produced by the "make" command)
# 3- In case of the test command, there is another file to get :
# the xml board that contain the test results
dirname = os.path.basename(os.path.dirname(job_path_remote))
- if dirname != 'OUT' and dirname != 'TEST':
+ if dirname != "OUT" and dirname != "TEST":
# Case 1-
- local_path = os.path.join(os.path.dirname(
- self.logger.logFilePath),
- os.path.basename(job_path_remote))
- if i==0: # The first is the job command
- self.logger.add_link(os.path.basename(job_path_remote),
- "job",
- self.res_job,
- self.command)
- elif dirname == 'OUT':
+ local_path = os.path.join(
+ os.path.dirname(self.logger.logFilePath),
+ os.path.basename(job_path_remote),
+ )
+ if i == 0: # The first is the job command
+ self.logger.add_link(
+ os.path.basename(job_path_remote),
+ "job",
+ self.res_job,
+ self.command,
+ )
+ elif dirname == "OUT":
# Case 2-
- local_path = os.path.join(os.path.dirname(
- self.logger.logFilePath),
- 'OUT',
- os.path.basename(job_path_remote))
- elif dirname == 'TEST':
+ local_path = os.path.join(
+ os.path.dirname(self.logger.logFilePath),
+ "OUT",
+ os.path.basename(job_path_remote),
+ )
+ elif dirname == "TEST":
# Case 3-
- local_path = os.path.join(os.path.dirname(
- self.logger.logFilePath),
- 'TEST',
- os.path.basename(job_path_remote))
-
+ local_path = os.path.join(
+ os.path.dirname(self.logger.logFilePath),
+ "TEST",
+ os.path.basename(job_path_remote),
+ )
+
# Get the file
if not os.path.exists(local_path):
self.machine.sftp.get(job_path_remote, local_path)
self.remote_log_files.append(local_path)
except Exception as e:
- self.err += _("Unable to get %s log file from remote: %s" %
- (str(job_path_remote),
- str(e)))
+ self.err += _(
+ "Unable to get %s log file from remote: %s"
+ % (str(job_path_remote), str(e))
+ )
def has_failed(self):
- '''Returns True if the job has failed.
+ """Returns True if the job has failed.
A job is considered as failed if the machine could not be reached,
- if the remote command failed,
+ if the remote command failed,
or if the job finished with a time out.
-
+
:return: True if the job has failed
:rtype: bool
- '''
+ """
if not self.has_finished():
return False
if not self.machine.successfully_connected(self.logger):
if self.res_job == "1":
return True
return False
-
+
def cancel(self):
- """In case of a failing job, one has to cancel every job that depend
- on it. This method put the job as failed and will not be executed.
+ """In case of a failing job, one has to cancel every job that depend
+ on it. This method put the job as failed and will not be executed.
"""
if self.cancelled:
return
self.err += _("This job was not launched because its father has failed.")
def is_running(self):
- '''Returns True if the job commands are running
-
+ """Returns True if the job commands are running
+
:return: True if the job is running
:rtype: bool
- '''
+ """
return self.has_begun() and not self.has_finished()
def is_timeout(self):
- '''Returns True if the job commands has finished with timeout
-
+ """Returns True if the job commands has finished with timeout
+
:return: True if the job has finished with timeout
:rtype: bool
- '''
+ """
return self._has_timouted
def time_elapsed(self):
"""Get the time elapsed since the job launching
-
+
:return: The number of seconds
:rtype: int
"""
return -1
T_now = time.time()
return T_now - self._T0
-
+
def check_time(self):
"""Verify that the job has not exceeded its timeout.
- If it has, kill the remote command and consider the job as finished.
+ If it has, kill the remote command and consider the job as finished.
"""
if not self.has_begun():
return
self.get_log_files()
except Exception as e:
self.err += _("Unable to get remote log files!\n%s\n" % str(e))
-
+
def total_duration(self):
"""Give the total duration of the job
-
+
:return: the total duration of the job in seconds
:rtype: int
"""
return self._Tf - self._T0
-
+
def run(self):
- """Launch the job by executing the remote command.
- """
-
+ """Launch the job by executing the remote command."""
+
# Prevent multiple run
if self.has_begun():
msg = _("Warning: A job can only be launched one time")
- msg2 = _("Trying to launch the job \"%s\" whereas it has "
- "already been launched." % self.name)
- self.logger.write(src.printcolors.printcWarning("%s\n%s\n" % (msg,
- msg2)))
+ msg2 = _(
+ 'Trying to launch the job "%s" whereas it has '
+ "already been launched." % self.name
+ )
+ self.logger.write(src.printcolors.printcWarning("%s\n%s\n" % (msg, msg2)))
return
-
+
# Do not execute the command if the machine could not be reached
if not self.machine.successfully_connected(self.logger):
self._has_finished = True
self.out = "N\A"
- self.err += ("Connection to machine (name : %s, host: %s, port:"
- " %s, user: %s) has failed\nUse the log command "
- "to get more information."
- % (self.machine.name,
- self.machine.host,
- self.machine.port,
- self.machine.user))
+ self.err += (
+ "Connection to machine (name : %s, host: %s, port:"
+ " %s, user: %s) has failed\nUse the log command "
+ "to get more information."
+ % (
+ self.machine.name,
+ self.machine.host,
+ self.machine.port,
+ self.machine.user,
+ )
+ )
else:
# Usual case : Launch the command on remote machine
self._T0 = time.time()
self._stdin, self._stdout, self._stderr = self.machine.exec_command(
- self.command,
- self.logger)
+ self.command, self.logger
+ )
# If the results are not initialized, finish the job
if (self._stdin, self._stdout, self._stderr) == (None, None, None):
self._has_finished = True
self._Tf = time.time()
self.out += "N\A"
self.err += "The server failed to execute the command"
-
+
# Put the beginning flag to true.
self._has_begun = True
-
+
def write_results(self):
- """Display on the terminal all the job's information
- """
+ """Display on the terminal all the job's information"""
self.logger.write("name : " + self.name + "\n")
if self.after:
self.logger.write("after : %s\n" % self.after)
- self.logger.write("Time elapsed : %4imin %2is \n" %
- (self.total_duration()//60 , self.total_duration()%60))
+ self.logger.write(
+ "Time elapsed : %4imin %2is \n"
+ % (self.total_duration() // 60, self.total_duration() % 60)
+ )
if self._T0 != -1:
- self.logger.write("Begin time : %s\n" %
- time.strftime('%Y-%m-%d %H:%M:%S',
- time.localtime(self._T0)) )
+ self.logger.write(
+ "Begin time : %s\n"
+ % time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(self._T0))
+ )
if self._Tf != -1:
- self.logger.write("End time : %s\n\n" %
- time.strftime('%Y-%m-%d %H:%M:%S',
- time.localtime(self._Tf)) )
-
+ self.logger.write(
+ "End time : %s\n\n"
+ % time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(self._Tf))
+ )
+
machine_head = "Informations about connection :\n"
underline = (len(machine_head) - 2) * "-"
- self.logger.write(src.printcolors.printcInfo(
- machine_head+underline+"\n"))
+ self.logger.write(src.printcolors.printcInfo(machine_head + underline + "\n"))
self.machine.write_info(self.logger)
-
+
self.logger.write(src.printcolors.printcInfo("out : \n"))
if self.out == "":
self.logger.write("Unable to get output\n")
self.logger.write(self.out + "\n")
self.logger.write(src.printcolors.printcInfo("err : \n"))
self.logger.write(self.err + "\n")
-
+
def get_status(self):
"""Get the status of the job (used by the Gui for xml display)
-
+
:return: The current status of the job
:rtype: String
"""
if self.cancelled:
return "Cancelled"
if self.is_running():
- return "running since " + time.strftime('%Y-%m-%d %H:%M:%S',
- time.localtime(self._T0))
+ return "running since " + time.strftime(
+ "%Y-%m-%d %H:%M:%S", time.localtime(self._T0)
+ )
if self.has_finished():
if self.is_timeout():
- return "Timeout since " + time.strftime('%Y-%m-%d %H:%M:%S',
- time.localtime(self._Tf))
- return "Finished since " + time.strftime('%Y-%m-%d %H:%M:%S',
- time.localtime(self._Tf))
-
+ return "Timeout since " + time.strftime(
+ "%Y-%m-%d %H:%M:%S", time.localtime(self._Tf)
+ )
+ return "Finished since " + time.strftime(
+ "%Y-%m-%d %H:%M:%S", time.localtime(self._Tf)
+ )
+
+
class Jobs(object):
- '''Class to manage the jobs to be run
- '''
- def __init__(self,
- runner,
- logger,
- job_file_path,
- config_jobs,
- lenght_columns = 20):
+ """Class to manage the jobs to be run"""
+
+ def __init__(self, runner, logger, job_file_path, config_jobs, lenght_columns=20):
# The jobs configuration
self.cfg_jobs = config_jobs
self.job_file_path = job_file_path
# The machine that will be used today
self.lmachines = []
- # The list of machine (hosts, port) that will be used today
- # (a same host can have several machine instances since there
- # can be several ssh parameters)
+ # The list of machine (hosts, port) that will be used today
+ # (a same host can have several machine instances since there
+ # can be several ssh parameters)
self.lhosts = []
- # The jobs to be launched today
+ # The jobs to be launched today
self.ljobs = []
# The jobs that will not be launched today
self.ljobs_not_today = []
self.runner = runner
self.logger = logger
self.len_columns = lenght_columns
-
+
# the list of jobs that have not been run yet
self._l_jobs_not_started = []
- # the list of jobs that have already ran
+ # the list of jobs that have already ran
self._l_jobs_finished = []
- # the list of jobs that are running
- self._l_jobs_running = []
-
+ # the list of jobs that are running
+ self._l_jobs_running = []
+
self.determine_jobs_and_machines()
-
+
def define_job(self, job_def, machine):
- '''Takes a pyconf job definition and a machine (from class machine)
+ """Takes a pyconf job definition and a machine (from class machine)
and returns the job instance corresponding to the definition.
-
- :param job_def src.config.Mapping: a job definition
+
+ :param job_def src.config.Mapping: a job definition
:param machine machine: the machine on which the job will run
:return: The corresponding job in a job class instance
:rtype: job
- '''
+ """
name = job_def.name
cmmnds = job_def.commands
if not "timeout" in job_def:
- timeout = 4*60*60 # default timeout = 4h
+ timeout = 4 * 60 * 60 # default timeout = 4h
else:
timeout = job_def.timeout
after = None
- if 'after' in job_def:
+ if "after" in job_def:
after = job_def.after
application = None
- if 'application' in job_def:
+ if "application" in job_def:
application = job_def.application
board = None
- if 'board' in job_def:
+ if "board" in job_def:
board = job_def.board
prefix = None
if "prefix" in job_def:
prefix = job_def.prefix
-
- return Job(name,
- machine,
- application,
- board,
- cmmnds,
- timeout,
- self.runner.cfg,
- self.job_file_path,
- self.logger,
- after = after,
- prefix = prefix)
-
+
+ return Job(
+ name,
+ machine,
+ application,
+ board,
+ cmmnds,
+ timeout,
+ self.runner.cfg,
+ self.job_file_path,
+ self.logger,
+ after=after,
+ prefix=prefix,
+ )
+
def determine_jobs_and_machines(self):
- '''Function that reads the pyconf jobs definition and instantiates all
+ """Function that reads the pyconf jobs definition and instantiates all
the machines and jobs to be done today.
:return: Nothing
:rtype: N\A
- '''
+ """
today = datetime.date.weekday(datetime.date.today())
host_list = []
-
- for job_def in self.cfg_jobs.jobs :
-
+
+ for job_def in self.cfg_jobs.jobs:
+
if not "machine" in job_def:
- msg = _('WARNING: The job "%s" do not have the key '
- '"machine", this job is ignored.\n\n' % job_def.name)
+ msg = _(
+ 'WARNING: The job "%s" do not have the key '
+ '"machine", this job is ignored.\n\n' % job_def.name
+ )
self.logger.write(src.printcolors.printcWarning(msg))
continue
name_machine = job_def.machine
-
+
a_machine = None
for mach in self.lmachines:
if mach.name == name_machine:
a_machine = mach
break
-
+
if a_machine == None:
for machine_def in self.cfg_jobs.machines:
if machine_def.name == name_machine:
- if 'host' not in machine_def:
+ if "host" not in machine_def:
host = self.runner.cfg.VARS.hostname
else:
host = machine_def.host
- if 'user' not in machine_def:
+ if "user" not in machine_def:
user = self.runner.cfg.VARS.user
else:
user = machine_def.user
- if 'port' not in machine_def:
+ if "port" not in machine_def:
port = 22
else:
port = machine_def.port
-
- if 'password' not in machine_def:
+
+ if "password" not in machine_def:
passwd = None
else:
- passwd = machine_def.password
-
- if 'sat_path' not in machine_def:
+ passwd = machine_def.password
+
+ if "sat_path" not in machine_def:
sat_path = "salomeTools"
else:
sat_path = machine_def.sat_path
-
+
a_machine = Machine(
- machine_def.name,
- host,
- user,
- port=port,
- passwd=passwd,
- sat_path=sat_path
- )
-
+ machine_def.name,
+ host,
+ user,
+ port=port,
+ passwd=passwd,
+ sat_path=sat_path,
+ )
+
self.lmachines.append(a_machine)
if (host, port) not in host_list:
host_list.append((host, port))
-
+
if a_machine == None:
- msg = _("WARNING: The job \"%(job_name)s\" requires the "
- "machine \"%(machine_name)s\" but this machine "
- "is not defined in the configuration file.\n"
- "The job will not be launched\n")
- self.logger.write(src.printcolors.printcWarning(
- msg % {"job_name" : job_def.name,
- "machine_name" : name_machine}))
+ msg = _(
+ 'WARNING: The job "%(job_name)s" requires the '
+ 'machine "%(machine_name)s" but this machine '
+ "is not defined in the configuration file.\n"
+ "The job will not be launched\n"
+ )
+ self.logger.write(
+ src.printcolors.printcWarning(
+ msg
+ % {"job_name": job_def.name, "machine_name": name_machine}
+ )
+ )
continue
-
+
a_job = self.define_job(job_def, a_machine)
-
- if today in job_def.when:
+
+ if today in job_def.when:
self.ljobs.append(a_job)
- else: # today in job_def.when
+ else: # today in job_def.when
self.ljobs_not_today.append(a_job)
-
+
self.lhosts = host_list
-
+
def ssh_connection_all_machines(self, pad=50):
- '''Function that do the ssh connection to every machine
+ """Function that do the ssh connection to every machine
to be used today.
:return: Nothing
:rtype: N\A
- '''
- self.logger.write(src.printcolors.printcInfo((
- "Establishing connection with all the machines :\n")))
+ """
+ self.logger.write(
+ src.printcolors.printcInfo(
+ ("Establishing connection with all the machines :\n")
+ )
+ )
for machine in self.lmachines:
# little algorithm in order to display traces
- begin_line = (_("Connection to %s: " % machine.name))
+ begin_line = _("Connection to %s: " % machine.name)
if pad - len(begin_line) < 0:
endline = " "
else:
endline = (pad - len(begin_line)) * "." + " "
-
+
step = "SSH connection"
- self.logger.write( begin_line + endline + step)
+ self.logger.write(begin_line + endline + step)
self.logger.flush()
# the call to the method that initiate the ssh connection
msg = machine.connect(self.logger)
-
+
# Copy salomeTools to the remote machine
if machine.successfully_connected(self.logger):
step = _("Remove SAT")
- self.logger.write('\r%s%s%s' % (begin_line, endline, 20 * " "),3)
- self.logger.write('\r%s%s%s' % (begin_line, endline, step), 3)
+ self.logger.write("\r%s%s%s" % (begin_line, endline, 20 * " "), 3)
+ self.logger.write("\r%s%s%s" % (begin_line, endline, step), 3)
(__, out_dist, __) = machine.exec_command(
- "rm -rf %s" % machine.sat_path,
- self.logger)
+ "rm -rf %s" % machine.sat_path, self.logger
+ )
out_dist.read()
-
+
self.logger.flush()
step = _("Copy SAT")
- self.logger.write('\r%s%s%s' % (begin_line, endline, 20 * " "),3)
- self.logger.write('\r%s%s%s' % (begin_line, endline, step), 3)
+ self.logger.write("\r%s%s%s" % (begin_line, endline, 20 * " "), 3)
+ self.logger.write("\r%s%s%s" % (begin_line, endline, step), 3)
self.logger.flush()
- res_copy = machine.copy_sat(self.runner.cfg.VARS.salometoolsway,
- self.job_file_path)
+ res_copy = machine.copy_sat(
+ self.runner.cfg.VARS.salometoolsway, self.job_file_path
+ )
# set the local settings of sat on the remote machine using
# the init command
(__, out_dist, __) = machine.exec_command(
- os.path.join(machine.sat_path,
- "sat init --base default --workdir"
- " default --log_dir default"),
- self.logger)
- out_dist.read()
-
+ os.path.join(
+ machine.sat_path,
+ "sat init --base default --workdir"
+ " default --log_dir default",
+ ),
+ self.logger,
+ )
+ out_dist.read()
+
# get the remote machine distribution using a sat command
(__, out_dist, __) = machine.exec_command(
- os.path.join(machine.sat_path,
- "sat config --value VARS.dist --no_label"),
- self.logger)
- machine.distribution = out_dist.read().decode().replace("\n",
- "")
-
+ os.path.join(
+ machine.sat_path, "sat config --value VARS.dist --no_label"
+ ),
+ self.logger,
+ )
+ machine.distribution = out_dist.read().decode().replace("\n", "")
+
# Print the status of the copy
if res_copy == 0:
- self.logger.write('\r%s' %
- ((len(begin_line)+len(endline)+20) * " "), 3)
- self.logger.write('\r%s%s%s' %
- (begin_line,
- endline,
- src.printcolors.printc(src.OK_STATUS)), 3)
+ self.logger.write(
+ "\r%s" % ((len(begin_line) + len(endline) + 20) * " "), 3
+ )
+ self.logger.write(
+ "\r%s%s%s"
+ % (begin_line, endline, src.printcolors.printc(src.OK_STATUS)),
+ 3,
+ )
else:
- self.logger.write('\r%s' %
- ((len(begin_line)+len(endline)+20) * " "), 3)
- self.logger.write('\r%s%s%s %s' %
- (begin_line,
- endline,
- src.printcolors.printc(src.KO_STATUS),
- _("Copy of SAT failed: %s" % res_copy)), 3)
+ self.logger.write(
+ "\r%s" % ((len(begin_line) + len(endline) + 20) * " "), 3
+ )
+ self.logger.write(
+ "\r%s%s%s %s"
+ % (
+ begin_line,
+ endline,
+ src.printcolors.printc(src.KO_STATUS),
+ _("Copy of SAT failed: %s" % res_copy),
+ ),
+ 3,
+ )
else:
- self.logger.write('\r%s' %
- ((len(begin_line)+len(endline)+20) * " "), 3)
- self.logger.write('\r%s%s%s %s' %
- (begin_line,
- endline,
- src.printcolors.printc(src.KO_STATUS),
- msg), 3)
+ self.logger.write(
+ "\r%s" % ((len(begin_line) + len(endline) + 20) * " "), 3
+ )
+ self.logger.write(
+ "\r%s%s%s %s"
+ % (begin_line, endline, src.printcolors.printc(src.KO_STATUS), msg),
+ 3,
+ )
self.logger.write("\n", 3)
-
+
self.logger.write("\n")
-
def is_occupied(self, hostname):
- '''Function that returns True if a job is running on
+ """Function that returns True if a job is running on
the machine defined by its host and its port.
-
+
:param hostname (str, int): the pair (host, port)
- :return: the job that is running on the host,
- or false if there is no job running on the host.
+ :return: the job that is running on the host,
+ or false if there is no job running on the host.
:rtype: job / bool
- '''
+ """
host = hostname[0]
port = hostname[1]
for jb in self.ljobs:
if jb.is_running():
return jb
return False
-
+
def update_jobs_states_list(self):
- '''Function that updates the lists that store the currently
+ """Function that updates the lists that store the currently
running jobs and the jobs that have already finished.
-
- :return: Nothing.
+
+ :return: Nothing.
:rtype: N\A
- '''
+ """
jobs_finished_list = []
jobs_running_list = []
for jb in self.ljobs:
jb.check_time()
if jb.has_finished():
jobs_finished_list.append(jb)
-
+
nb_job_finished_before = len(self._l_jobs_finished)
self._l_jobs_finished = jobs_finished_list
self._l_jobs_running = jobs_running_list
-
+
nb_job_finished_now = len(self._l_jobs_finished)
-
+
return nb_job_finished_now > nb_job_finished_before
-
+
def cancel_dependencies_of_failing_jobs(self):
- '''Function that cancels all the jobs that depend on a failing one.
-
- :return: Nothing.
+ """Function that cancels all the jobs that depend on a failing one.
+
+ :return: Nothing.
:rtype: N\A
- '''
-
+ """
+
for job in self.ljobs:
if job.after is None:
continue
father_job = self.find_job_that_has_name(job.after)
if father_job is not None and father_job.has_failed():
job.cancel()
-
+
def find_job_that_has_name(self, name):
- '''Returns the job by its name.
-
+ """Returns the job by its name.
+
:param name str: a job name
- :return: the job that has the name.
+ :return: the job that has the name.
:rtype: job
- '''
+ """
for jb in self.ljobs:
if jb.name == name:
return jb
# the following is executed only if the job was not found
return None
-
+
def str_of_length(self, text, length):
- '''Takes a string text of any length and returns
+ """Takes a string text of any length and returns
the most close string of length "length".
-
+
:param text str: any string
:param length int: a length for the returned string
:return: the most close string of length "length"
:rtype: str
- '''
+ """
if len(text) > length:
- text_out = text[:length-3] + '...'
+ text_out = text[: length - 3] + "..."
else:
diff = length - len(text)
- before = " " * (diff//2)
- after = " " * (diff//2 + diff%2)
+ before = " " * (diff // 2)
+ after = " " * (diff // 2 + diff % 2)
text_out = before + text + after
-
+
return text_out
-
+
def display_status(self, len_col):
- '''Takes a lenght and construct the display of the current status
+ """Takes a lenght and construct the display of the current status
of the jobs in an array that has a column for each host.
- It displays the job that is currently running on the host
+ It displays the job that is currently running on the host
of the column.
-
- :param len_col int: the size of the column
+
+ :param len_col int: the size of the column
:return: Nothing
:rtype: N\A
- '''
-
+ """
+
display_line = ""
for host_port in self.lhosts:
jb = self.is_occupied(host_port)
- if not jb: # nothing running on the host
+ if not jb: # nothing running on the host
empty = self.str_of_length("empty", len_col)
- display_line += "|" + empty
+ display_line += "|" + empty
else:
display_line += "|" + src.printcolors.printcInfo(
- self.str_of_length(jb.name, len_col))
-
+ self.str_of_length(jb.name, len_col)
+ )
+
self.logger.write("\r" + display_line + "|")
self.logger.flush()
-
def run_jobs(self):
- '''The main method. Runs all the jobs on every host.
+ """The main method. Runs all the jobs on every host.
For each host, at a given time, only one job can be running.
The jobs that have the field after (that contain the job that has
to be run before it) are run after the previous job.
This method stops when all the jobs are finished.
-
+
:return: Nothing
:rtype: N\A
- '''
+ """
# Print header
- self.logger.write(src.printcolors.printcInfo(
- _('Executing the jobs :\n')))
+ self.logger.write(src.printcolors.printcInfo(_("Executing the jobs :\n")))
text_line = ""
for host_port in self.lhosts:
host = host_port[0]
port = host_port[1]
- if port == 22: # default value
+ if port == 22: # default value
text_line += "|" + self.str_of_length(host, self.len_columns)
else:
text_line += "|" + self.str_of_length(
- "("+host+", "+str(port)+")", self.len_columns)
-
- tiret_line = " " + "-"*(len(text_line)-1) + "\n"
+ "(" + host + ", " + str(port) + ")", self.len_columns
+ )
+
+ tiret_line = " " + "-" * (len(text_line) - 1) + "\n"
self.logger.write(tiret_line)
self.logger.write(text_line + "|\n")
self.logger.write(tiret_line)
self.logger.flush()
-
+
# The infinite loop that runs the jobs
l_jobs_not_started = src.deepcopy_list(self.ljobs)
while len(self._l_jobs_finished) != len(self.ljobs):
new_job_start = False
for host_port in self.lhosts:
-
+
if self.is_occupied(host_port):
continue
-
+
for jb in l_jobs_not_started:
if (jb.machine.host, jb.machine.port) != host_port:
- continue
+ continue
if jb.after == None:
jb.run()
l_jobs_not_started.remove(jb)
jb_before = self.find_job_that_has_name(jb.after)
if jb_before is None:
jb.cancel()
- msg = _("This job was not launched because its "
- "father is not in the jobs list.")
+ msg = _(
+ "This job was not launched because its "
+ "father is not in the jobs list."
+ )
jb.out = msg
jb.err = msg
break
break
self.cancel_dependencies_of_failing_jobs()
new_job_finished = self.update_jobs_states_list()
-
+
if new_job_start or new_job_finished:
if self.gui:
- self.gui.update_xml_files(self.ljobs)
- # Display the current status
+ self.gui.update_xml_files(self.ljobs)
+ # Display the current status
self.display_status(self.len_columns)
-
+
# Make sure that the proc is not entirely busy
time.sleep(0.001)
-
- self.logger.write("\n")
- self.logger.write(tiret_line)
+
+ self.logger.write("\n")
+ self.logger.write(tiret_line)
self.logger.write("\n\n")
-
+
if self.gui:
self.gui.update_xml_files(self.ljobs)
self.gui.last_update()
def write_all_results(self):
- '''Display all the jobs outputs.
-
+ """Display all the jobs outputs.
+
:return: Nothing
:rtype: N\A
- '''
-
+ """
+
for jb in self.ljobs:
- self.logger.write(src.printcolors.printcLabel(
- "#------- Results for job %s -------#\n" % jb.name))
+ self.logger.write(
+ src.printcolors.printcLabel(
+ "#------- Results for job %s -------#\n" % jb.name
+ )
+ )
jb.write_results()
self.logger.write("\n\n")
+
class Gui(object):
- '''Class to manage the the xml data that can be displayed in a browser to
- see the jobs states
- '''
-
- def __init__(self,
- xml_dir_path,
- l_jobs,
- l_jobs_not_today,
- prefix,
- logger,
- file_boards=""):
- '''Initialization
-
- :param xml_dir_path str: The path to the directory where to put
+ """Class to manage the the xml data that can be displayed in a browser to
+ see the jobs states
+ """
+
+ def __init__(
+ self, xml_dir_path, l_jobs, l_jobs_not_today, prefix, logger, file_boards=""
+ ):
+ """Initialization
+
+ :param xml_dir_path str: The path to the directory where to put
the xml resulting files
:param l_jobs List: the list of jobs that run today
:param l_jobs_not_today List: the list of jobs that do not run today
:param file_boards str: the file path from which to read the
expected boards
- '''
+ """
# The logging instance
self.logger = logger
-
+
# The prefix to add to the xml files : date_hour
self.prefix = prefix
-
+
# The path of the csv files to read to fill the expected boards
self.file_boards = file_boards
-
+
if file_boards != "":
today = datetime.date.weekday(datetime.date.today())
self.parse_csv_boards(today)
else:
self.d_input_boards = {}
-
+
# The path of the global xml file
self.xml_dir_path = xml_dir_path
# Initialize the xml files
self.global_name = "global_report"
- xml_global_path = os.path.join(self.xml_dir_path,
- self.global_name + ".xml")
- self.xml_global_file = src.xmlManager.XmlLogFile(xml_global_path,
- "JobsReport")
+ xml_global_path = os.path.join(self.xml_dir_path, self.global_name + ".xml")
+ self.xml_global_file = src.xmlManager.XmlLogFile(xml_global_path, "JobsReport")
# Find history for each job
self.history = {}
# Write the xml file
self.update_xml_files(l_jobs)
-
+
def add_xml_board(self, name):
- '''Add a board to the board list
+ """Add a board to the board list
:param name str: the board name
- '''
+ """
xml_board_path = os.path.join(self.xml_dir_path, name + ".xml")
- self.d_xml_board_files[name] = src.xmlManager.XmlLogFile(
- xml_board_path,
- "JobsReport")
+ self.d_xml_board_files[name] = src.xmlManager.XmlLogFile(
+ xml_board_path, "JobsReport"
+ )
self.d_xml_board_files[name].add_simple_node("distributions")
self.d_xml_board_files[name].add_simple_node("applications")
self.d_xml_board_files[name].add_simple_node("board", text=name)
-
+
def initialize_boards(self, l_jobs, l_jobs_not_today):
- '''Get all the first information needed for each file and write the
- first version of the files
+ """Get all the first information needed for each file and write the
+ first version of the files
:param l_jobs List: the list of jobs that run today
:param l_jobs_not_today List: the list of jobs that do not run today
- '''
+ """
# Get the boards to fill and put it in a dictionary
# {board_name : xml instance corresponding to the board}
for job in l_jobs + l_jobs_not_today:
board = job.board
- if (board is not None and
- board not in self.d_xml_board_files.keys()):
+ if board is not None and board not in self.d_xml_board_files.keys():
self.add_xml_board(board)
-
+
# Verify that the boards given as input are done
for board in list(self.d_input_boards.keys()):
if board not in self.d_xml_board_files:
self.add_xml_board(board)
root_node = self.d_xml_board_files[board].xmlroot
- src.xmlManager.append_node_attrib(root_node,
- {"input_file" : self.file_boards})
-
- # Loop over all jobs in order to get the lines and columns for each
+ src.xmlManager.append_node_attrib(
+ root_node, {"input_file": self.file_boards}
+ )
+
+ # Loop over all jobs in order to get the lines and columns for each
# xml file
d_dist = {}
d_application = {}
for board in self.d_xml_board_files:
d_dist[board] = []
d_application[board] = []
-
+
l_hosts_ports = []
-
+
for job in l_jobs + l_jobs_not_today:
-
+
if (job.machine.host, job.machine.port) not in l_hosts_ports:
l_hosts_ports.append((job.machine.host, job.machine.port))
-
+
distrib = job.machine.distribution
application = job.application
-
+
board_job = job.board
if board is None:
continue
for board in self.d_xml_board_files:
if board_job == board:
- if (distrib not in [None, ''] and
- distrib not in d_dist[board]):
+ if distrib not in [None, ""] and distrib not in d_dist[board]:
d_dist[board].append(distrib)
src.xmlManager.add_simple_node(
- self.d_xml_board_files[board].xmlroot.find(
- 'distributions'),
- "dist",
- attrib={"name" : distrib})
-
+ self.d_xml_board_files[board].xmlroot.find("distributions"),
+ "dist",
+ attrib={"name": distrib},
+ )
+
if board_job == board:
- if (application not in [None, ''] and
- application not in d_application[board]):
+ if (
+ application not in [None, ""]
+ and application not in d_application[board]
+ ):
d_application[board].append(application)
src.xmlManager.add_simple_node(
- self.d_xml_board_files[board].xmlroot.find(
- 'applications'),
- "application",
- attrib={
- "name" : application})
-
+ self.d_xml_board_files[board].xmlroot.find("applications"),
+ "application",
+ attrib={"name": application},
+ )
+
# Verify that there are no missing application or distribution in the
# xml board files (regarding the input boards)
for board in self.d_xml_board_files:
for dist in self.d_input_boards[board]["rows"]:
if dist not in l_dist:
src.xmlManager.add_simple_node(
- self.d_xml_board_files[board].xmlroot.find(
- 'distributions'),
- "dist",
- attrib={"name" : dist})
+ self.d_xml_board_files[board].xmlroot.find("distributions"),
+ "dist",
+ attrib={"name": dist},
+ )
l_appli = d_application[board]
for appli in self.d_input_boards[board]["columns"]:
if appli not in l_appli:
src.xmlManager.add_simple_node(
- self.d_xml_board_files[board].xmlroot.find(
- 'applications'),
- "application",
- attrib={"name" : appli})
-
+ self.d_xml_board_files[board].xmlroot.find("applications"),
+ "application",
+ attrib={"name": appli},
+ )
+
# Initialize the hosts_ports node for the global file
- self.xmlhosts_ports = self.xml_global_file.add_simple_node(
- "hosts_ports")
+ self.xmlhosts_ports = self.xml_global_file.add_simple_node("hosts_ports")
for host, port in l_hosts_ports:
host_port = "%s:%i" % (host, port)
- src.xmlManager.add_simple_node(self.xmlhosts_ports,
- "host_port",
- attrib={"name" : host_port})
-
+ src.xmlManager.add_simple_node(
+ self.xmlhosts_ports, "host_port", attrib={"name": host_port}
+ )
+
# Initialize the jobs node in all files
- for xml_file in [self.xml_global_file] + list(
- self.d_xml_board_files.values()):
- xml_jobs = xml_file.add_simple_node("jobs")
- # Get the jobs present in the config file but
+ for xml_file in [self.xml_global_file] + list(self.d_xml_board_files.values()):
+ xml_jobs = xml_file.add_simple_node("jobs")
+ # Get the jobs present in the config file but
# that will not be launched today
self.put_jobs_not_today(l_jobs_not_today, xml_jobs)
-
+
# add also the infos node
- xml_file.add_simple_node("infos",
- attrib={"name" : "last update",
- "JobsCommandStatus" : "running"})
-
+ xml_file.add_simple_node(
+ "infos", attrib={"name": "last update", "JobsCommandStatus": "running"}
+ )
+
# and put the history node
history_node = xml_file.add_simple_node("history")
- name_board = os.path.basename(xml_file.logFile)[:-len(".xml")]
+ name_board = os.path.basename(xml_file.logFile)[: -len(".xml")]
# serach for board files
expression = "^[0-9]{8}_+[0-9]{6}_" + name_board + ".xml$"
oExpr = re.compile(expression)
if oExpr.search(file_name):
date = os.path.basename(file_name).split("_")[0]
file_path = os.path.join(self.xml_dir_path, file_name)
- src.xmlManager.add_simple_node(history_node,
- "link",
- text=file_path,
- attrib={"date" : date})
-
-
+ src.xmlManager.add_simple_node(
+ history_node, "link", text=file_path, attrib={"date": date}
+ )
+
# Find in each board the squares that needs to be filled regarding the
# input csv files but that are not covered by a today job
for board in self.d_input_boards.keys():
xml_root_board = self.d_xml_board_files[board].xmlroot
# Find the missing jobs for today
- xml_missing = src.xmlManager.add_simple_node(xml_root_board,
- "missing_jobs")
+ xml_missing = src.xmlManager.add_simple_node(xml_root_board, "missing_jobs")
for row, column in self.d_input_boards[board]["jobs"]:
found = False
for job in l_jobs:
- if (job.application == column and
- job.machine.distribution == row):
+ if job.application == column and job.machine.distribution == row:
found = True
break
if not found:
- src.xmlManager.add_simple_node(xml_missing,
- "job",
- attrib={"distribution" : row,
- "application" : column })
+ src.xmlManager.add_simple_node(
+ xml_missing,
+ "job",
+ attrib={"distribution": row, "application": column},
+ )
# Find the missing jobs not today
xml_missing_not_today = src.xmlManager.add_simple_node(
- xml_root_board,
- "missing_jobs_not_today")
+ xml_root_board, "missing_jobs_not_today"
+ )
for row, column in self.d_input_boards[board]["jobs_not_today"]:
found = False
for job in l_jobs_not_today:
- if (job.application == column and
- job.machine.distribution == row):
+ if job.application == column and job.machine.distribution == row:
found = True
break
if not found:
- src.xmlManager.add_simple_node(xml_missing_not_today,
- "job",
- attrib={"distribution" : row,
- "application" : column })
+ src.xmlManager.add_simple_node(
+ xml_missing_not_today,
+ "job",
+ attrib={"distribution": row, "application": column},
+ )
def find_history(self, l_jobs, l_jobs_not_today):
- """find, for each job, in the existent xml boards the results for the
- job. Store the results in the dictionnary self.history = {name_job :
+ """find, for each job, in the existent xml boards the results for the
+ job. Store the results in the dictionnary self.history = {name_job :
list of (date, status, list links)}
-
- :param l_jobs List: the list of jobs to run today
+
+ :param l_jobs List: the list of jobs to run today
:param l_jobs_not_today List: the list of jobs that do not run today
"""
# load the all the history
global_xml = src.xmlManager.ReadXmlFile(file_path)
l_globalxml.append(global_xml)
except Exception as e:
- msg = _("\nWARNING: the file %s can not be read, it will be "
- "ignored\n%s" % (file_path, e))
- self.logger.write("%s\n" % src.printcolors.printcWarning(
- msg), 5)
-
- # Construct the dictionnary self.history
+ msg = _(
+ "\nWARNING: the file %s can not be read, it will be "
+ "ignored\n%s" % (file_path, e)
+ )
+ self.logger.write("%s\n" % src.printcolors.printcWarning(msg), 5)
+
+ # Construct the dictionnary self.history
for job in l_jobs + l_jobs_not_today:
l_links = []
for global_xml in l_globalxml:
date = os.path.basename(global_xml.filePath).split("_")[0]
global_root_node = global_xml.xmlroot.find("jobs")
job_node = src.xmlManager.find_node_by_attrib(
- global_root_node,
- "job",
- "name",
- job.name)
+ global_root_node, "job", "name", job.name
+ )
if job_node:
if job_node.find("remote_log_file_path") is not None:
link = job_node.find("remote_log_file_path").text
l_links.append((date, res_job, link))
l_links = sorted(l_links, reverse=True)
self.history[job.name] = l_links
-
+
def put_jobs_not_today(self, l_jobs_not_today, xml_node_jobs):
- '''Get all the first information needed for each file and write the
- first version of the files
+ """Get all the first information needed for each file and write the
+ first version of the files
:param xml_node_jobs etree.Element: the node corresponding to a job
:param l_jobs_not_today List: the list of jobs that do not run today
- '''
+ """
for job in l_jobs_not_today:
- xmlj = src.xmlManager.add_simple_node(xml_node_jobs,
- "job",
- attrib={"name" : job.name})
+ xmlj = src.xmlManager.add_simple_node(
+ xml_node_jobs, "job", attrib={"name": job.name}
+ )
src.xmlManager.add_simple_node(xmlj, "application", job.application)
- src.xmlManager.add_simple_node(xmlj,
- "distribution",
- job.machine.distribution)
+ src.xmlManager.add_simple_node(
+ xmlj, "distribution", job.machine.distribution
+ )
src.xmlManager.add_simple_node(xmlj, "board", job.board)
- src.xmlManager.add_simple_node(xmlj,
- "commands", " ; ".join(job.commands))
+ src.xmlManager.add_simple_node(xmlj, "commands", " ; ".join(job.commands))
src.xmlManager.add_simple_node(xmlj, "state", "Not today")
src.xmlManager.add_simple_node(xmlj, "machine", job.machine.name)
src.xmlManager.add_simple_node(xmlj, "host", job.machine.host)
src.xmlManager.add_simple_node(xmlj, "port", str(job.machine.port))
src.xmlManager.add_simple_node(xmlj, "user", job.machine.user)
- src.xmlManager.add_simple_node(xmlj, "sat_path",
- job.machine.sat_path)
+ src.xmlManager.add_simple_node(xmlj, "sat_path", job.machine.sat_path)
xml_history = src.xmlManager.add_simple_node(xmlj, "history")
for i, (date, res_job, link) in enumerate(self.history[job.name]):
- if i==0:
+ if i == 0:
# tag the first one (the last one)
- src.xmlManager.add_simple_node(xml_history,
- "link",
- text=link,
- attrib={"date" : date,
- "res" : res_job,
- "last" : "yes"})
+ src.xmlManager.add_simple_node(
+ xml_history,
+ "link",
+ text=link,
+ attrib={"date": date, "res": res_job, "last": "yes"},
+ )
else:
- src.xmlManager.add_simple_node(xml_history,
- "link",
- text=link,
- attrib={"date" : date,
- "res" : res_job,
- "last" : "no"})
+ src.xmlManager.add_simple_node(
+ xml_history,
+ "link",
+ text=link,
+ attrib={"date": date, "res": res_job, "last": "no"},
+ )
def parse_csv_boards(self, today):
- """ Parse the csv file that describes the boards to produce and fill
+ """Parse the csv file that describes the boards to produce and fill
the dict d_input_boards that contain the csv file contain
-
- :param today int: the current day of the week
+
+ :param today int: the current day of the week
"""
# open the csv file and read its content
l_read = []
- with open(self.file_boards, 'r') as f:
- reader = csv.reader(f,delimiter=CSV_DELIMITER)
+ with open(self.file_boards, "r") as f:
+ reader = csv.reader(f, delimiter=CSV_DELIMITER)
for row in reader:
l_read.append(row)
# get the delimiter for the boards (empty line)
- boards_delimiter = [''] * len(l_read[0])
+ boards_delimiter = [""] * len(l_read[0])
# Make the list of boards, by splitting with the delimiter
- l_boards = [list(y) for x, y in itertools.groupby(l_read,
- lambda z: z == boards_delimiter) if not x]
-
+ l_boards = [
+ list(y)
+ for x, y in itertools.groupby(l_read, lambda z: z == boards_delimiter)
+ if not x
+ ]
+
# loop over the csv lists of lines and get the rows, columns and jobs
d_boards = {}
for input_board in l_boards:
# get board name
board_name = input_board[0][0]
-
+
# Get columns list
columns = input_board[0][1:]
-
+
rows = []
jobs = []
jobs_not_today = []
row = line[0]
rows.append(row)
for i, square in enumerate(line[1:]):
- if square=='':
+ if square == "":
continue
days = square.split(DAYS_SEPARATOR)
days = [int(day) for day in days]
job = (row, columns[i])
- if today in days:
+ if today in days:
jobs.append(job)
else:
jobs_not_today.append(job)
- d_boards[board_name] = {"rows" : rows,
- "columns" : columns,
- "jobs" : jobs,
- "jobs_not_today" : jobs_not_today}
-
+ d_boards[board_name] = {
+ "rows": rows,
+ "columns": columns,
+ "jobs": jobs,
+ "jobs_not_today": jobs_not_today,
+ }
+
self.d_input_boards = d_boards
def update_xml_files(self, l_jobs):
- '''Write all the xml files with updated information about the jobs
+ """Write all the xml files with updated information about the jobs
:param l_jobs List: the list of jobs that run today
- '''
- for xml_file in [self.xml_global_file] + list(
- self.d_xml_board_files.values()):
+ """
+ for xml_file in [self.xml_global_file] + list(self.d_xml_board_files.values()):
self.update_xml_file(l_jobs, xml_file)
-
+
# Write the file
self.write_xml_files()
-
- def update_xml_file(self, l_jobs, xml_file):
- '''update information about the jobs for the file xml_file
+
+ def update_xml_file(self, l_jobs, xml_file):
+ """update information about the jobs for the file xml_file
:param l_jobs List: the list of jobs that run today
:param xml_file xmlManager.XmlLogFile: the xml instance to update
- '''
-
- xml_node_jobs = xml_file.xmlroot.find('jobs')
+ """
+
+ xml_node_jobs = xml_file.xmlroot.find("jobs")
# Update the job names and status node
for job in l_jobs:
# Find the node corresponding to the job and delete it
# in order to recreate it
- for xmljob in xml_node_jobs.findall('job'):
- if xmljob.attrib['name'] == job.name:
+ for xmljob in xml_node_jobs.findall("job"):
+ if xmljob.attrib["name"] == job.name:
xml_node_jobs.remove(xmljob)
-
+
T0 = str(job._T0)
if T0 != "-1":
- T0 = time.strftime('%Y-%m-%d %H:%M:%S',
- time.localtime(job._T0))
+ T0 = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(job._T0))
Tf = str(job._Tf)
if Tf != "-1":
- Tf = time.strftime('%Y-%m-%d %H:%M:%S',
- time.localtime(job._Tf))
-
+ Tf = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(job._Tf))
+
# recreate the job node
- xmlj = src.xmlManager.add_simple_node(xml_node_jobs,
- "job",
- attrib={"name" : job.name})
+ xmlj = src.xmlManager.add_simple_node(
+ xml_node_jobs, "job", attrib={"name": job.name}
+ )
src.xmlManager.add_simple_node(xmlj, "machine", job.machine.name)
src.xmlManager.add_simple_node(xmlj, "host", job.machine.host)
src.xmlManager.add_simple_node(xmlj, "port", str(job.machine.port))
src.xmlManager.add_simple_node(xmlj, "user", job.machine.user)
xml_history = src.xmlManager.add_simple_node(xmlj, "history")
for date, res_job, link in self.history[job.name]:
- src.xmlManager.add_simple_node(xml_history,
- "link",
- text=link,
- attrib={"date" : date,
- "res" : res_job})
-
- src.xmlManager.add_simple_node(xmlj, "sat_path",
- job.machine.sat_path)
+ src.xmlManager.add_simple_node(
+ xml_history,
+ "link",
+ text=link,
+ attrib={"date": date, "res": res_job},
+ )
+
+ src.xmlManager.add_simple_node(xmlj, "sat_path", job.machine.sat_path)
src.xmlManager.add_simple_node(xmlj, "application", job.application)
- src.xmlManager.add_simple_node(xmlj, "distribution",
- job.machine.distribution)
+ src.xmlManager.add_simple_node(
+ xmlj, "distribution", job.machine.distribution
+ )
src.xmlManager.add_simple_node(xmlj, "board", job.board)
src.xmlManager.add_simple_node(xmlj, "timeout", str(job.timeout))
- src.xmlManager.add_simple_node(xmlj, "commands",
- " ; ".join(job.commands))
+ src.xmlManager.add_simple_node(xmlj, "commands", " ; ".join(job.commands))
src.xmlManager.add_simple_node(xmlj, "state", job.get_status())
src.xmlManager.add_simple_node(xmlj, "begin", T0)
src.xmlManager.add_simple_node(xmlj, "end", Tf)
- src.xmlManager.add_simple_node(xmlj, "out",
- src.printcolors.cleancolor(job.out))
- src.xmlManager.add_simple_node(xmlj, "err",
- src.printcolors.cleancolor(job.err))
+ src.xmlManager.add_simple_node(
+ xmlj, "out", src.printcolors.cleancolor(job.out)
+ )
+ src.xmlManager.add_simple_node(
+ xmlj, "err", src.printcolors.cleancolor(job.err)
+ )
src.xmlManager.add_simple_node(xmlj, "res", str(job.res_job))
if len(job.remote_log_files) > 0:
- src.xmlManager.add_simple_node(xmlj,
- "remote_log_file_path",
- job.remote_log_files[0])
+ src.xmlManager.add_simple_node(
+ xmlj, "remote_log_file_path", job.remote_log_files[0]
+ )
else:
- src.xmlManager.add_simple_node(xmlj,
- "remote_log_file_path",
- "nothing")
+ src.xmlManager.add_simple_node(xmlj, "remote_log_file_path", "nothing")
# Search for the test log if there is any
l_test_log_files = self.find_test_log(job.remote_log_files)
- xml_test = src.xmlManager.add_simple_node(xmlj,
- "test_log_file_path")
+ xml_test = src.xmlManager.add_simple_node(xmlj, "test_log_file_path")
for test_log_path, res_test, nb_fails in l_test_log_files:
- test_path_node = src.xmlManager.add_simple_node(xml_test,
- "path",
- test_log_path)
+ test_path_node = src.xmlManager.add_simple_node(
+ xml_test, "path", test_log_path
+ )
test_path_node.attrib["res"] = res_test
test_path_node.attrib["nb_fails"] = nb_fails
-
+
xmlafter = src.xmlManager.add_simple_node(xmlj, "after", job.after)
# get the job father
if job.after is not None:
for jb in l_jobs:
if jb.name == job.after:
job_father = jb
-
- if (job_father is not None and
- len(job_father.remote_log_files) > 0):
+
+ if job_father is not None and len(job_father.remote_log_files) > 0:
link = job_father.remote_log_files[0]
else:
link = "nothing"
- src.xmlManager.append_node_attrib(xmlafter, {"link" : link})
-
+ src.xmlManager.append_node_attrib(xmlafter, {"link": link})
+
# Verify that the job is to be done today regarding the input csv
# files
if job.board and job.board in self.d_input_boards.keys():
found = False
for dist, appli in self.d_input_boards[job.board]["jobs"]:
- if (job.machine.distribution == dist
- and job.application == appli):
+ if job.machine.distribution == dist and job.application == appli:
found = True
- src.xmlManager.add_simple_node(xmlj,
- "extra_job",
- "no")
+ src.xmlManager.add_simple_node(xmlj, "extra_job", "no")
break
if not found:
- src.xmlManager.add_simple_node(xmlj,
- "extra_job",
- "yes")
-
-
+ src.xmlManager.add_simple_node(xmlj, "extra_job", "yes")
+
# Update the date
- xml_node_infos = xml_file.xmlroot.find('infos')
- src.xmlManager.append_node_attrib(xml_node_infos,
- attrib={"value" :
- datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")})
-
+ xml_node_infos = xml_file.xmlroot.find("infos")
+ src.xmlManager.append_node_attrib(
+ xml_node_infos,
+ attrib={"value": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")},
+ )
def find_test_log(self, l_remote_log_files):
- '''Find if there is a test log (board) in the remote log files and
+ """Find if there is a test log (board) in the remote log files and
the path to it. There can be several test command, so the result is
a list.
:param l_remote_log_files List: the list of all remote log files
:return: the list of (test log files path, res of the command)
:rtype: List
- '''
+ """
res = []
for file_path in l_remote_log_files:
dirname = os.path.basename(os.path.dirname(file_path))
# find the number of fails
testbase_node = prod_node.find("tests").find("testbase")
nb_fails = int(testbase_node.attrib["failed"])
- # put the file path, the res of the test command and the number
+ # put the file path, the res of the test command and the number
# of fails in the output
res.append((file_path, res_test, nb_fails))
-
+
return res
-
- def last_update(self, finish_status = "finished"):
- '''update information about the jobs for the file xml_file
+
+ def last_update(self, finish_status="finished"):
+ """update information about the jobs for the file xml_file
:param l_jobs List: the list of jobs that run today
:param xml_file xmlManager.XmlLogFile: the xml instance to update
- '''
+ """
for xml_file in [self.xml_global_file] + list(self.d_xml_board_files.values()):
- xml_node_infos = xml_file.xmlroot.find('infos')
- src.xmlManager.append_node_attrib(xml_node_infos,
- attrib={"JobsCommandStatus" : finish_status})
+ xml_node_infos = xml_file.xmlroot.find("infos")
+ src.xmlManager.append_node_attrib(
+ xml_node_infos, attrib={"JobsCommandStatus": finish_status}
+ )
# Write the file
self.write_xml_files()
def write_xml_file(self, xml_file, stylesheet):
- ''' Write one xml file and the same file with prefix
- '''
+ """Write one xml file and the same file with prefix"""
xml_file.write_tree(stylesheet)
file_path = xml_file.logFile
file_dir = os.path.dirname(file_path)
file_name = os.path.basename(file_path)
file_name_with_prefix = self.prefix + "_" + file_name
- xml_file.write_tree(stylesheet, os.path.join(file_dir,
- file_name_with_prefix))
-
+ xml_file.write_tree(stylesheet, os.path.join(file_dir, file_name_with_prefix))
+
def write_xml_files(self):
- ''' Write the xml files
- '''
+ """Write the xml files"""
self.write_xml_file(self.xml_global_file, STYLESHEET_GLOBAL)
for xml_file in self.d_xml_board_files.values():
self.write_xml_file(xml_file, STYLESHEET_BOARD)
+
def get_config_file_path(job_config_name, l_cfg_dir):
found = False
file_jobs_cfg = None
else:
for cfg_dir in l_cfg_dir:
file_jobs_cfg = os.path.join(cfg_dir, job_config_name)
- if not file_jobs_cfg.endswith('.pyconf'):
- file_jobs_cfg += '.pyconf'
-
+ if not file_jobs_cfg.endswith(".pyconf"):
+ file_jobs_cfg += ".pyconf"
+
if not os.path.exists(file_jobs_cfg):
continue
else:
break
return found, file_jobs_cfg
+
def develop_factorized_jobs(config_jobs):
- '''update information about the jobs for the file xml_file
-
+ """update information about the jobs for the file xml_file
+
:param config_jobs Config: the config corresponding to the jos description
- '''
+ """
developed_jobs_list = []
for jb in config_jobs.jobs:
# case where the jobs are not developed
for machine in jb.machine:
new_job = src.pyconf.deepCopyMapping(jb)
# case where there is a jobs on the machine corresponding to all
- # days in when variable.
+ # days in when variable.
if type(machine) == type(""):
new_job.machine = machine
new_job.name = name_job + " / " + machine
new_job.name = name_job + " / " + machine[0]
new_job.when = machine[1:]
developed_jobs_list.append(new_job)
-
+
config_jobs.jobs = developed_jobs_list
-
+
##
# Describes the command
def description():
- return _("The jobs command launches maintenances that are described"
- " in the dedicated jobs configuration file.\n\nexample:\nsat "
- "jobs --name my_jobs --publish")
+ return _(
+ "The jobs command launches maintenances that are described"
+ " in the dedicated jobs configuration file.\n\nexample:\nsat "
+ "jobs --name my_jobs --publish"
+ )
+
##
# Runs the command.
def run(args, runner, logger):
-
+
(options, args) = parser.parse_args(args)
-
+
l_cfg_dir = runner.cfg.PATHS.JOBPATH
-
+
# list option : display all the available config files
if options.list:
for cfg_dir in l_cfg_dir:
if not options.no_label:
- logger.write("------ %s\n" %
- src.printcolors.printcHeader(cfg_dir))
+ logger.write("------ %s\n" % src.printcolors.printcHeader(cfg_dir))
if not os.path.exists(cfg_dir):
continue
for f in sorted(os.listdir(cfg_dir)):
- if not f.endswith('.pyconf'):
+ if not f.endswith(".pyconf"):
continue
cfilename = f[:-7]
logger.write("%s\n" % cfilename)
# Make sure the jobs_config option has been called
if not options.jobs_cfg:
- message = _("The option --jobs_config is required\n")
+ message = _("The option --jobs_config is required\n")
src.printcolors.printcError(message)
return 1
-
+
# Find the file in the directories, unless it is a full path
- # merge all in a config
+ # merge all in a config
merger = src.pyconf.ConfigMerger()
config_jobs = src.pyconf.Config()
l_conf_files_path = []
for config_file in options.jobs_cfg:
found, file_jobs_cfg = get_config_file_path(config_file, l_cfg_dir)
if not found:
- msg = _("The file configuration %s was not found."
- "\nUse the --list option to get the "
- "possible files." % config_file)
+ msg = _(
+ "The file configuration %s was not found."
+ "\nUse the --list option to get the "
+ "possible files." % config_file
+ )
logger.write("%s\n" % src.printcolors.printcError(msg), 1)
return 1
l_conf_files_path.append(file_jobs_cfg)
# Read the config that is in the file
one_config_jobs = src.read_config_from_a_file(file_jobs_cfg)
merger.merge(config_jobs, one_config_jobs)
-
+
info = [
(_("Platform"), runner.cfg.VARS.dist),
- (_("Files containing the jobs configuration"), l_conf_files_path)
- ]
+ (_("Files containing the jobs configuration"), l_conf_files_path),
+ ]
src.print_info(logger, info)
if options.only_jobs:
l_jb = src.pyconf.Sequence()
for jb in config_jobs.jobs:
if jb.name in options.only_jobs:
- l_jb.append(jb,
- "Job that was given in only_jobs option parameters\n")
+ l_jb.append(jb, "Job that was given in only_jobs option parameters\n")
config_jobs.jobs = l_jb
-
+
# Parse the config jobs in order to develop all the factorized jobs
develop_factorized_jobs(config_jobs)
-
- # Make a unique file that contain all the jobs in order to use it
+
+ # Make a unique file that contain all the jobs in order to use it
# on every machine
- name_pyconf = "_".join([os.path.basename(path)[:-len('.pyconf')]
- for path in l_conf_files_path]) + ".pyconf"
+ name_pyconf = (
+ "_".join(
+ [os.path.basename(path)[: -len(".pyconf")] for path in l_conf_files_path]
+ )
+ + ".pyconf"
+ )
path_pyconf = src.get_tmp_filename(runner.cfg, name_pyconf)
- #Save config
- f = file( path_pyconf , 'w')
+ # Save config
+ f = file(path_pyconf, "w")
config_jobs.__save__(f)
-
- # log the paramiko problems
+
+ # log the paramiko problems
log_dir = src.get_log_path(runner.cfg)
paramiko_log_dir_path = os.path.join(log_dir, "JOBS")
src.ensure_path_exists(paramiko_log_dir_path)
- paramiko.util.log_to_file(os.path.join(paramiko_log_dir_path,
- logger.txtFileName))
-
+ paramiko.util.log_to_file(os.path.join(paramiko_log_dir_path, logger.txtFileName))
+
# Initialization
- today_jobs = Jobs(runner,
- logger,
- path_pyconf,
- config_jobs)
-
+ today_jobs = Jobs(runner, logger, path_pyconf, config_jobs)
+
# SSH connection to all machines
today_jobs.ssh_connection_all_machines()
if options.test_connection:
return 0
-
+
gui = None
if options.publish:
- logger.write(src.printcolors.printcInfo(
- _("Initialize the xml boards : ")), 5)
+ logger.write(src.printcolors.printcInfo(_("Initialize the xml boards : ")), 5)
logger.flush()
-
- # Copy the stylesheets in the log directory
+
+ # Copy the stylesheets in the log directory
log_dir = log_dir
- xsl_dir = os.path.join(runner.cfg.VARS.srcDir, 'xsl')
+ xsl_dir = os.path.join(runner.cfg.VARS.srcDir, "xsl")
files_to_copy = []
files_to_copy.append(os.path.join(xsl_dir, STYLESHEET_GLOBAL))
files_to_copy.append(os.path.join(xsl_dir, STYLESHEET_BOARD))
# OP We use copy instead of copy2 to update the creation date
# So we can clean the LOGS directories easily
shutil.copy(file_path, log_dir)
-
+
# Instanciate the Gui in order to produce the xml files that contain all
# the boards
- gui = Gui(log_dir,
- today_jobs.ljobs,
- today_jobs.ljobs_not_today,
- runner.cfg.VARS.datehour,
- logger,
- file_boards = options.input_boards)
-
+ gui = Gui(
+ log_dir,
+ today_jobs.ljobs,
+ today_jobs.ljobs_not_today,
+ runner.cfg.VARS.datehour,
+ logger,
+ file_boards=options.input_boards,
+ )
+
logger.write(src.printcolors.printcSuccess("OK"), 5)
logger.write("\n\n", 5)
logger.flush()
-
+
# Display the list of the xml files
- logger.write(src.printcolors.printcInfo(("Here is the list of published"
- " files :\n")), 4)
+ logger.write(
+ src.printcolors.printcInfo(("Here is the list of published" " files :\n")),
+ 4,
+ )
logger.write("%s\n" % gui.xml_global_file.logFile, 4)
for board in gui.d_xml_board_files.keys():
file_path = gui.d_xml_board_files[board].logFile
file_name = os.path.basename(file_path)
logger.write("%s\n" % file_path, 4)
logger.add_link(file_name, "board", 0, board)
-
+
logger.write("\n", 4)
-
+
today_jobs.gui = gui
-
+
interruped = False
try:
# Run all the jobs contained in config_jobs
today_jobs.run_jobs()
except KeyboardInterrupt:
interruped = True
- logger.write("\n\n%s\n\n" %
- (src.printcolors.printcWarning(_("Forced interruption"))), 1)
+ logger.write(
+ "\n\n%s\n\n" % (src.printcolors.printcWarning(_("Forced interruption"))), 1
+ )
except Exception as e:
msg = _("CRITICAL ERROR: The jobs loop has been interrupted\n")
- logger.write("\n\n%s\n" % src.printcolors.printcError(msg) )
+ logger.write("\n\n%s\n" % src.printcolors.printcError(msg))
logger.write("%s\n" % str(e))
# get stack
__, __, exc_traceback = sys.exc_info()
traceback.print_tb(exc_traceback, file=fp)
fp.seek(0)
stack = fp.read()
- logger.write("\nTRACEBACK: %s\n" % stack.replace('"',"'"), 1)
-
+ logger.write("\nTRACEBACK: %s\n" % stack.replace('"', "'"), 1)
+
finally:
res = 0
if interruped:
res = 1
- msg = _("Killing the running jobs and trying"
- " to get the corresponding logs\n")
+ msg = _(
+ "Killing the running jobs and trying" " to get the corresponding logs\n"
+ )
logger.write(src.printcolors.printcWarning(msg))
-
+
# find the potential not finished jobs and kill them
for jb in today_jobs.ljobs:
if not jb.has_finished():
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2013 CEA/DEN
#
# This library is free software; you can redistribute it and/or
parser = src.options.Options()
-parser.add_option('n', 'name', 'string', 'name', _('Optional: The name of the'
- ' launcher (default is APPLICATION.profile.launcher_name)'))
-parser.add_option('e', 'exe', 'string', 'path_exe', _('Use this option to generate a launcher which sets'
- ' the environment and call the executable given as argument'
- ' (its relative path to application workdir, or an exe name present in appli PATH)'))
-parser.add_option('p', 'products', 'list2', 'products',
- _("Optional: Includes only the specified products."))
-parser.add_option('c', 'catalog', 'string', 'catalog',
- _('Optional: The resources catalog to use'))
-parser.add_option('', 'gencat', 'string', 'gencat',
- _("Optional: Create a resources catalog for the specified machines "
- "(separated with ',') \n\tNOTICE: this command will ssh to retrieve"
- " information to each machine in the list"))
-parser.add_option('', 'use_mesa', 'boolean', 'use_mesa',
- _("Optional: Create a launcher that will use mesa products\n\t"
- "It can be usefull whan salome is used on a remote machine through ssh"))
-parser.add_option('', 'no_path_init', 'boolean', 'no_path_init',
- _("Optional: Create a launcher that will not reinitilise all path variables\n\t"
- "By default only PATH is not reinitialised (its value is inherited from "
- "user's environment)\n\tUse no_path_init option to suppress the reinitilisation"
- " of every paths (LD_LIBRARY_PATH, PYTHONPATH, ...)"))
-
-
-def generate_launch_file(config,
- logger,
- launcher_name,
- pathlauncher,
- path_exe,
- env_info,
- display=True,
- additional_env={},
- no_path_init=False):
- '''Generates the launcher file.
-
+parser.add_option(
+ "n",
+ "name",
+ "string",
+ "name",
+ _(
+ "Optional: The name of the"
+ " launcher (default is APPLICATION.profile.launcher_name)"
+ ),
+)
+parser.add_option(
+ "e",
+ "exe",
+ "string",
+ "path_exe",
+ _(
+ "Use this option to generate a launcher which sets"
+ " the environment and call the executable given as argument"
+ " (its relative path to application workdir, or an exe name present in appli PATH)"
+ ),
+)
+parser.add_option(
+ "p",
+ "products",
+ "list2",
+ "products",
+ _("Optional: Includes only the specified products."),
+)
+parser.add_option(
+ "c", "catalog", "string", "catalog", _("Optional: The resources catalog to use")
+)
+parser.add_option(
+ "",
+ "gencat",
+ "string",
+ "gencat",
+ _(
+ "Optional: Create a resources catalog for the specified machines "
+ "(separated with ',') \n\tNOTICE: this command will ssh to retrieve"
+ " information to each machine in the list"
+ ),
+)
+parser.add_option(
+ "",
+ "use_mesa",
+ "boolean",
+ "use_mesa",
+ _(
+ "Optional: Create a launcher that will use mesa products\n\t"
+ "It can be usefull whan salome is used on a remote machine through ssh"
+ ),
+)
+parser.add_option(
+ "",
+ "no_path_init",
+ "boolean",
+ "no_path_init",
+ _(
+ "Optional: Create a launcher that will not reinitilise all path variables\n\t"
+ "By default only PATH is not reinitialised (its value is inherited from "
+ "user's environment)\n\tUse no_path_init option to suppress the reinitilisation"
+ " of every paths (LD_LIBRARY_PATH, PYTHONPATH, ...)"
+ ),
+)
+
+
+def generate_launch_file(
+ config,
+ logger,
+ launcher_name,
+ pathlauncher,
+ path_exe,
+ env_info,
+ display=True,
+ additional_env={},
+ no_path_init=False,
+):
+ """Generates the launcher file.
+
:param config Config: The global configuration
- :param logger Logger: The logger instance to use for the display
+ :param logger Logger: The logger instance to use for the display
and logging
:param launcher_name str: The name of the launcher to generate
- :param path_exe str: The executable to use (either a relative path to
+ :param path_exe str: The executable to use (either a relative path to
application workdir, or an exe name in the path)
:param pathlauncher str: The path to the launcher to generate
:param display boolean: If False, do not print anything in the terminal
- :param additional_env dict: The dict giving additional
+ :param additional_env dict: The dict giving additional
environment variables
:param env_info str: The list of products to add in the files.
:return: The launcher file path.
:rtype: str
- '''
+ """
# build the launcher path, delete it if it exists
filepath = os.path.join(pathlauncher, launcher_name)
if os.path.exists(filepath):
os.remove(filepath)
- kernel_root_dir=None
- cmd=None
- salome_application_name=None
- app_root_dir=None
+ kernel_root_dir = None
+ cmd = None
+ salome_application_name = None
+ app_root_dir = None
if path_exe:
- #case of a launcher based upon an executable
-
+ # case of a launcher based upon an executable
+
if os.path.basename(path_exe) != path_exe:
- # for a relative (to workdir) path
+ # for a relative (to workdir) path
# build absolute path of exe and check it
- exepath=os.path.join(config.APPLICATION.workdir, path_exe)
+ exepath = os.path.join(config.APPLICATION.workdir, path_exe)
if not os.path.exists(exepath):
raise src.SatException(_("cannot find executable given : %s" % exepath))
else:
- exepath=path_exe
+ exepath = path_exe
# select the shell for the launcher (bast/bat)
# and build the command used to launch the exe
if src.architecture.is_windows():
- shell="bat"
- cmd="\n\nrem Launch exe with user arguments\n%s " % exepath + "%*"
+ shell = "bat"
+ cmd = "\n\nrem Launch exe with user arguments\n%s " % exepath + "%*"
else:
- shell="bash"
- cmd='\n\n# Launch exe with user arguments\n%s "$*"' % exepath
+ shell = "bash"
+ cmd = '\n\n# Launch exe with user arguments\n%s "$*"' % exepath
else:
- #case of a salome python2/3 launcher
- shell="cfgForPy"
+ # case of a salome python2/3 launcher
+ shell = "cfgForPy"
- # get KERNEL bin installation path
+ # get KERNEL bin installation path
# (in order for the launcher to get python salomeContext API)
kernel_cfg = src.product.get_product_config(config, "KERNEL")
if not src.product.check_installation(config, kernel_cfg):
kernel_root_dir = kernel_cfg.install_dir
# set kernel bin dir (considering fhs property)
if src.get_property_in_product_cfg(kernel_cfg, "fhs"):
- bin_kernel_install_dir = os.path.join(kernel_root_dir,"bin")
+ bin_kernel_install_dir = os.path.join(kernel_root_dir, "bin")
else:
- bin_kernel_install_dir = os.path.join(kernel_root_dir,"bin","salome")
+ bin_kernel_install_dir = os.path.join(kernel_root_dir, "bin", "salome")
- # Add two sat variables used by fileEnviron to choose the right launcher header
+ # Add two sat variables used by fileEnviron to choose the right launcher header
# and do substitutions
- additional_env['sat_bin_kernel_install_dir'] = bin_kernel_install_dir
+ additional_env["sat_bin_kernel_install_dir"] = bin_kernel_install_dir
if "python3" in config.APPLICATION and config.APPLICATION.python3 == "yes":
- additional_env['sat_python_version'] = 3
+ additional_env["sat_python_version"] = 3
else:
- additional_env['sat_python_version'] = 2
+ additional_env["sat_python_version"] = 2
# check if the application contains an application module
- l_product_info = src.product.get_products_infos(config.APPLICATION.products.keys(),
- config)
+ l_product_info = src.product.get_products_infos(
+ config.APPLICATION.products.keys(), config
+ )
for prod_name, prod_info in l_product_info:
# look for a salome application
if src.get_property_in_product_cfg(prod_info, "is_salome_application") == "yes":
# if user choose -p option (env_info not None), the set appli name only if product was selected.
- if env_info == None or ( prod_name in env_info):
- salome_application_name=prod_info.install_dir
+ if env_info == None or (prod_name in env_info):
+ salome_application_name = prod_info.install_dir
continue
# if the application contains an application module, we set ABSOLUTE_APPLI_PATH to it.
# if not we set it to KERNEL_INSTALL_DIR, which is sufficient, except for salome test
if salome_application_name:
- app_root_dir=salome_application_name
+ app_root_dir = salome_application_name
elif kernel_root_dir:
- app_root_dir=kernel_root_dir
+ app_root_dir = kernel_root_dir
# Add the APPLI and ABSOLUTE_APPLI_PATH variable
- additional_env['APPLI'] = filepath
+ additional_env["APPLI"] = filepath
if app_root_dir:
- additional_env['ABSOLUTE_APPLI_PATH'] = app_root_dir
+ additional_env["ABSOLUTE_APPLI_PATH"] = app_root_dir
# create an environment file writer
- writer = src.environment.FileEnvWriter(config,
- logger,
- pathlauncher,
- None,
- env_info)
+ writer = src.environment.FileEnvWriter(config, logger, pathlauncher, None, env_info)
# Display some information
if display:
# Write the launcher file
- logger.write(_("Generating launcher for %s :\n") %
- src.printcolors.printcLabel(config.VARS.application), 1)
+ logger.write(
+ _("Generating launcher for %s :\n")
+ % src.printcolors.printcLabel(config.VARS.application),
+ 1,
+ )
logger.write(" %s\n" % src.printcolors.printcLabel(filepath), 1)
-
+
# Write the launcher
- writer.write_env_file(filepath,
- False, # for launch
- shell,
- additional_env=additional_env,
- no_path_init=no_path_init)
-
-
- # ... and append the launch of the exe
+ writer.write_env_file(
+ filepath,
+ False, # for launch
+ shell,
+ additional_env=additional_env,
+ no_path_init=no_path_init,
+ )
+
+ # ... and append the launch of the exe
if cmd:
with open(filepath, "a") as exe_launcher:
exe_launcher.write(cmd)
# change the rights in order to make the file executable for everybody
- os.chmod(filepath,
- stat.S_IRUSR |
- stat.S_IRGRP |
- stat.S_IROTH |
- stat.S_IWUSR |
- stat.S_IXUSR |
- stat.S_IXGRP |
- stat.S_IXOTH)
+ os.chmod(
+ filepath,
+ stat.S_IRUSR
+ | stat.S_IRGRP
+ | stat.S_IROTH
+ | stat.S_IWUSR
+ | stat.S_IXUSR
+ | stat.S_IXGRP
+ | stat.S_IXOTH,
+ )
return filepath
def generate_catalog(machines, config, logger):
"""Generates an xml catalog file from a list of machines.
-
- :param machines List: The list of machines to add in the catalog
+
+ :param machines List: The list of machines to add in the catalog
:param config Config: The global configuration
- :param logger Logger: The logger instance to use for the display
+ :param logger Logger: The logger instance to use for the display
and logging
:return: The catalog file path.
:rtype: str
# remove empty machines
machines = map(lambda l: l.strip(), machines)
machines = filter(lambda l: len(l) > 0, machines)
-
+
# log something
- src.printcolors.print_value(logger, _("Generate Resources Catalog"),
- ", ".join(machines), 4)
-
+ src.printcolors.print_value(
+ logger, _("Generate Resources Catalog"), ", ".join(machines), 4
+ )
+
# The command to execute on each machine in order to get some information
cmd = '"cat /proc/cpuinfo | grep MHz ; cat /proc/meminfo | grep MemTotal"'
user = getpass.getuser()
# Create the catalog path
catfile = src.get_tmp_filename(config, "CatalogResources.xml")
- with open(catfile, 'w') as catalog:
+ with open(catfile, "w") as catalog:
# Write into it
catalog.write("<!DOCTYPE ResourcesCatalog>\n<resources>\n")
for k in machines:
- if not src.architecture.is_windows():
- logger.write(" ssh %s " % (k + " ").ljust(20, '.'), 4)
+ if not src.architecture.is_windows():
+ logger.write(" ssh %s " % (k + " ").ljust(20, "."), 4)
logger.flush()
# Verify that the machine is accessible
ssh_cmd = 'ssh -o "StrictHostKeyChecking no" %s %s' % (k, cmd)
- p = subprocess.Popen(ssh_cmd, shell=True,
- stdin=subprocess.PIPE,
- stdout=subprocess.PIPE,
- stderr=subprocess.PIPE)
+ p = subprocess.Popen(
+ ssh_cmd,
+ shell=True,
+ stdin=subprocess.PIPE,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE,
+ )
p.wait()
- machine_access = (p.returncode == 0)
- if not machine_access: # The machine is not accessible
+ machine_access = p.returncode == 0
+ if not machine_access: # The machine is not accessible
logger.write(src.printcolors.printc(src.KO_STATUS) + "\n", 4)
- logger.write(" " +
- src.printcolors.printcWarning(p.stderr.read()), 2)
+ logger.write(
+ " " + src.printcolors.printcWarning(p.stderr.read()), 2
+ )
else:
# The machine is accessible, write the corresponding section on
# the xml file
logger.write(src.printcolors.printc(src.OK_STATUS) + "\n", 4)
lines = p.stdout.readlines()
- freq = lines[0][:-1].split(':')[-1].split('.')[0].strip()
- nb_proc = len(lines) -1
- memory = lines[-1].split(':')[-1].split()[0].strip()
+ freq = lines[0][:-1].split(":")[-1].split(".")[0].strip()
+ nb_proc = len(lines) - 1
+ memory = lines[-1].split(":")[-1].split()[0].strip()
memory = int(memory) / 1000
catalog.write(" <machine\n")
- catalog.write(" protocol=\"ssh\"\n")
- catalog.write(" nbOfNodes=\"1\"\n")
- catalog.write(" mode=\"interactif\"\n")
- catalog.write(" OS=\"LINUX\"\n")
-
- if (not src.architecture.is_windows()) and machine_access :
- catalog.write(" CPUFreqMHz=\"%s\"\n" % freq)
- catalog.write(" nbOfProcPerNode=\"%s\"\n" % nb_proc)
- catalog.write(" memInMB=\"%s\"\n" % memory)
-
- catalog.write(" userName=\"%s\"\n" % user)
- catalog.write(" name=\"%s\"\n" % k)
- catalog.write(" hostname=\"%s\"\n" % k)
+ catalog.write(' protocol="ssh"\n')
+ catalog.write(' nbOfNodes="1"\n')
+ catalog.write(' mode="interactif"\n')
+ catalog.write(' OS="LINUX"\n')
+
+ if (not src.architecture.is_windows()) and machine_access:
+ catalog.write(' CPUFreqMHz="%s"\n' % freq)
+ catalog.write(' nbOfProcPerNode="%s"\n' % nb_proc)
+ catalog.write(' memInMB="%s"\n' % memory)
+
+ catalog.write(' userName="%s"\n' % user)
+ catalog.write(' name="%s"\n' % k)
+ catalog.write(' hostname="%s"\n' % k)
catalog.write(" >\n")
catalog.write(" </machine>\n")
catalog.write("</resources>\n")
return catfile
+
def copy_catalog(config, catalog_path):
"""Copy the xml catalog file into the right location
-
+
:param config Config: The global configuration
:param catalog_path str: the catalog file path
:return: The environment dictionary corresponding to the file path.
# Do the copy
if catalog_path != new_catalog_path:
shutil.copy(catalog_path, new_catalog_path)
- additional_environ = {'USER_CATALOG_RESOURCES_FILE' : new_catalog_path}
+ additional_environ = {"USER_CATALOG_RESOURCES_FILE": new_catalog_path}
return additional_environ
-
##################################################
##
# Describes the command
def description():
- return _("The launcher command generates a SALOME launcher.\n\nexample:"
- "\nsat launcher SALOME-master")
+ return _(
+ "The launcher command generates a SALOME launcher.\n\nexample:"
+ "\nsat launcher SALOME-master"
+ )
+
##
# Runs the command.
(options, args) = parser.parse_args(args)
# Verify that the command was called with an application
- src.check_config_has_application( runner.cfg )
-
+ src.check_config_has_application(runner.cfg)
+
# Determine the launcher name (from option, profile section or by default "salome")
if options.products is None:
environ_info = None
else:
- # add products specified by user (only products
+ # add products specified by user (only products
# included in the application)
- environ_info = filter(lambda l:
- l in runner.cfg.APPLICATION.products.keys(),
- options.products)
+ environ_info = filter(
+ lambda l: l in runner.cfg.APPLICATION.products.keys(), options.products
+ )
if options.name:
launcher_name = options.name
else:
launcher_name = src.get_launcher_name(runner.cfg)
- no_path_initialisation=False
+ no_path_initialisation = False
if options.no_path_init:
no_path_initialisation = True
-
+
# set the launcher path
launcher_path = runner.cfg.APPLICATION.workdir
# Generate a catalog of resources if the corresponding option was called
if options.gencat:
- catalog_path = generate_catalog(options.gencat.split(","),
- runner.cfg,
- logger)
+ catalog_path = generate_catalog(options.gencat.split(","), runner.cfg, logger)
additional_environ = copy_catalog(runner.cfg, catalog_path)
# activate mesa use in the generated launcher
# option -e has precedence over section profile
if not options.path_exe and src.get_launcher_exe(runner.cfg):
- options.path_exe=src.get_launcher_exe(runner.cfg)
+ options.path_exe = src.get_launcher_exe(runner.cfg)
# Generate the launcher
- generate_launch_file(runner.cfg,
- logger,
- launcher_name,
- launcher_path,
- options.path_exe,
- additional_env = additional_environ,
- env_info=environ_info,
- no_path_init = no_path_initialisation )
+ generate_launch_file(
+ runner.cfg,
+ logger,
+ launcher_name,
+ launcher_path,
+ options.path_exe,
+ additional_env=additional_environ,
+ env_info=environ_info,
+ no_path_init=no_path_initialisation,
+ )
return 0
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2012 CEA/DEN
#
# This library is free software; you can redistribute it and/or
# Compatibility python 2/3 for input function
# input stays input for python 3 and input = raw_input for python 2
-try:
+try:
input = raw_input
-except NameError:
+except NameError:
pass
import src
# Define all possible option for log command : sat log <options>
parser = src.options.Options()
-parser.add_option('t', 'terminal', 'boolean', 'terminal',
- "Optional: Show the log (in terminal) of a command, with user choice.")
-parser.add_option('l', 'last', 'boolean', 'last',
- "Optional: Show the log (in browser) of the last launched command.")
-parser.add_option('', 'last_compile', 'boolean', 'last_compile',
- "Optional: Show the log (in terminal) of the last compilation for all products.")
-parser.add_option('f', 'full', 'boolean', 'full',
- "Optional: Show the logs of ALL the launched commands.")
-parser.add_option('c', 'clean', 'int', 'clean',
- "Erase the n most ancient log files.")
-parser.add_option('n', 'no_browser', 'boolean', 'no_browser',
- "Optional: Do not launch the browser at the end of the command. Only update the hat file.")
+parser.add_option(
+ "t",
+ "terminal",
+ "boolean",
+ "terminal",
+ "Optional: Show the log (in terminal) of a command, with user choice.",
+)
+parser.add_option(
+ "l",
+ "last",
+ "boolean",
+ "last",
+ "Optional: Show the log (in browser) of the last launched command.",
+)
+parser.add_option(
+ "",
+ "last_compile",
+ "boolean",
+ "last_compile",
+ "Optional: Show the log (in terminal) of the last compilation for all products.",
+)
+parser.add_option(
+ "f",
+ "full",
+ "boolean",
+ "full",
+ "Optional: Show the logs of ALL the launched commands.",
+)
+parser.add_option("c", "clean", "int", "clean", "Erase the n most ancient log files.")
+parser.add_option(
+ "n",
+ "no_browser",
+ "boolean",
+ "no_browser",
+ "Optional: Do not launch the browser at the end of the command. Only update the hat file.",
+)
+
def get_last_log_file(logDir, notShownCommands):
- '''Used in case of last option. Get the last log command file path.
-
+ """Used in case of last option. Get the last log command file path.
+
:param logDir str: The directory where to search the log files
:param notShownCommands list: the list of commands to ignore
:return: the path to the last log file
:rtype: str
- '''
+ """
last = (_, 0)
for fileName in os.listdir(logDir):
# YYYYMMDD_HHMMSS_namecmd.xml
oExpr = re.compile(sExpr)
if oExpr.search(fileName):
# get date and hour and format it
- date_hour_cmd = fileName.split('_')
+ date_hour_cmd = fileName.split("_")
datehour = date_hour_cmd[0] + date_hour_cmd[1]
cmd = date_hour_cmd[2]
if cmd in notShownCommands:
last = (fileName, int(datehour))
return os.path.join(logDir, last[0])
+
def remove_log_file(filePath, logger):
- '''if it exists, print a warning and remove the input file
-
+ """if it exists, print a warning and remove the input file
+
:param filePath: the path of the file to delete
- :param logger Logger: the logger instance to use for the print
- '''
+ :param logger Logger: the logger instance to use for the print
+ """
if os.path.exists(filePath):
- logger.write(src.printcolors.printcWarning("Removing ")
- + filePath + "\n", 5)
+ logger.write(src.printcolors.printcWarning("Removing ") + filePath + "\n", 5)
os.remove(filePath)
+
def print_log_command_in_terminal(filePath, logger):
- '''Print the contain of filePath. It contains a command log in xml format.
-
- :param filePath: The command xml file from which extract the commands
+ """Print the contain of filePath. It contains a command log in xml format.
+
+ :param filePath: The command xml file from which extract the commands
context and traces
- :param logger Logger: the logging instance to use in order to print.
- '''
+ :param logger Logger: the logging instance to use in order to print.
+ """
logger.write(_("Reading ") + src.printcolors.printcHeader(filePath) + "\n", 5)
# Instantiate the ReadXmlFile class that reads xml files
xmlRead = src.xmlManager.ReadXmlFile(filePath)
# Get the attributes containing the context (user, OS, time, etc..)
- dAttrText = xmlRead.get_attrib('Site')
+ dAttrText = xmlRead.get_attrib("Site")
# format dAttrText and print the context
lAttrText = []
for attrib in dAttrText:
logger.write("\n", 1)
src.print_info(logger, lAttrText)
# Get the traces
- command_traces = xmlRead.get_node_text('Log')
+ command_traces = xmlRead.get_node_text("Log")
# Print it if there is any
if command_traces:
- logger.write(src.printcolors.printcHeader(
- _("Here are the command traces :\n")), 1)
+ logger.write(
+ src.printcolors.printcHeader(_("Here are the command traces :\n")), 1
+ )
logger.write(command_traces, 1)
logger.write("\n", 1)
+
def show_last_logs(logger, config, log_dirs):
"""Show last compilation logs"""
- log_dir = os.path.join(config.APPLICATION.workdir, 'LOGS')
+ log_dir = os.path.join(config.APPLICATION.workdir, "LOGS")
sorted_log_dirs = sorted(log_dirs)
# list the logs
nb = len(log_dirs)
k = index + i * col_size
if k < nb:
l = sorted_log_dirs[k]
- str_indice = src.printcolors.printcLabel("%2d" % (k+1))
+ str_indice = src.printcolors.printcLabel("%2d" % (k + 1))
log_name = l
logger.write("%s: %-30s" % (str_indice, log_name), 1, False)
logger.write("\n", 1, False)
# loop till exit
x = -1
- while (x < 0):
+ while x < 0:
x = ask_value(nb)
if x > 0:
- product_log_dir = os.path.join(log_dir, sorted_log_dirs[x-1])
+ product_log_dir = os.path.join(log_dir, sorted_log_dirs[x - 1])
show_product_last_logs(logger, config, product_log_dir)
+
def show_product_last_logs(logger, config, product_log_dir):
"""Show last compilation logs of a product"""
# sort the files chronologically
for file_n in os.listdir(product_log_dir):
my_stat = os.stat(os.path.join(product_log_dir, file_n))
l_time_file.append(
- (datetime.datetime.fromtimestamp(my_stat[stat.ST_MTIME]), file_n))
-
- # display the available logs
+ (datetime.datetime.fromtimestamp(my_stat[stat.ST_MTIME]), file_n)
+ )
+
+ # display the available logs
for i, (__, file_name) in enumerate(sorted(l_time_file)):
- str_indice = src.printcolors.printcLabel("%2d" % (i+1))
+ str_indice = src.printcolors.printcLabel("%2d" % (i + 1))
opt = []
my_stat = os.stat(os.path.join(product_log_dir, file_name))
opt.append(str(datetime.datetime.fromtimestamp(my_stat[stat.ST_MTIME])))
-
+
opt.append("(%8.2f)" % (my_stat[stat.ST_SIZE] / 1024.0))
logger.write(" %-35s" % " ".join(opt), 1, False)
logger.write("%s: %-30s\n" % (str_indice, file_name), 1, False)
-
+
# loop till exit
x = -1
- while (x < 0):
+ while x < 0:
x = ask_value(len(l_time_file))
if x > 0:
- (__, file_name) = sorted(l_time_file)[x-1]
+ (__, file_name) = sorted(l_time_file)[x - 1]
log_file_path = os.path.join(product_log_dir, file_name)
src.system.show_in_editor(config.USER.editor, log_file_path, logger)
-
+
+
def ask_value(nb):
- '''Ask for an int n. 0<n<nb
-
+ """Ask for an int n. 0<n<nb
+
:param nb int: The maximum value of the value to be returned by the user.
:return: the value entered by the user. Return -1 if it is not as expected
:rtype: int
- '''
+ """
try:
# ask for a value
rep = input(_("Which one (enter or 0 to quit)? "))
x = -1
except:
x = -1
-
+
return x
+
def description():
- '''method that is called when salomeTools is called with --help option.
-
+ """method that is called when salomeTools is called with --help option.
+
:return: The text to display for the log command description.
:rtype: str
- '''
- return _("""\
+ """
+ return _(
+ """\
The log command gives access to the logs produced by the salomeTools commands.
example:
>> sat log
-""")
+"""
+ )
+
def run(args, runner, logger):
- '''method that is called when salomeTools is called with log parameter.
- '''
+ """method that is called when salomeTools is called with log parameter."""
# Parse the options
(options, args) = parser.parse_args(args)
# Print a header
nb_files_log_dir = len(glob.glob(os.path.join(logDir, "*")))
- info = [("log directory", logDir),
- ("number of log files", nb_files_log_dir)]
+ info = [("log directory", logDir), ("number of log files", nb_files_log_dir)]
src.print_info(logger, info)
-
- # If the clean options is invoked,
+
+ # If the clean options is invoked,
# do nothing but deleting the concerned files.
if options.clean:
nbClean = options.clean
# get the list of files to remove
- lLogs = src.logger.list_log_file(logDir,
- src.logger.log_all_command_file_expression)
+ lLogs = src.logger.list_log_file(
+ logDir, src.logger.log_all_command_file_expression
+ )
nbLogFiles = len(lLogs)
# Delete all if the invoked number is bigger than the number of log files
if nbClean > nbLogFiles:
# remove the xml log file
remove_log_file(filePath, logger)
# remove also the corresponding txt file in OUT directory
- txtFilePath = os.path.join(os.path.dirname(filePath),
- 'OUT',
- os.path.basename(filePath)[:-len('.xml')] + '.txt')
+ txtFilePath = os.path.join(
+ os.path.dirname(filePath),
+ "OUT",
+ os.path.basename(filePath)[: -len(".xml")] + ".txt",
+ )
remove_log_file(txtFilePath, logger)
- # remove also the corresponding pyconf (do not exist 2016-06)
+ # remove also the corresponding pyconf (do not exist 2016-06)
# file in OUT directory
- pyconfFilePath = os.path.join(os.path.dirname(filePath),
- 'OUT',
- os.path.basename(filePath)[:-len('.xml')] + '.pyconf')
+ pyconfFilePath = os.path.join(
+ os.path.dirname(filePath),
+ "OUT",
+ os.path.basename(filePath)[: -len(".xml")] + ".pyconf",
+ )
remove_log_file(pyconfFilePath, logger)
-
logger.write(src.printcolors.printcSuccess("OK\n"))
logger.write("%i logs deleted.\n" % nbClean)
- return 0
+ return 0
# determine the commands to show in the hat log
notShownCommands = list(runner.cfg.INTERNAL.log.not_shown_commands)
notShownCommands = []
# Find the stylesheets Directory and files
- xslDir = os.path.join(runner.cfg.VARS.srcDir, 'xsl')
+ xslDir = os.path.join(runner.cfg.VARS.srcDir, "xsl")
xslCommand = os.path.join(xslDir, "command.xsl")
xslHat = os.path.join(xslDir, "hat.xsl")
xsltest = os.path.join(xslDir, "test.xsl")
imgLogo = os.path.join(xslDir, "LOGO-SAT.png")
-
+
# copy the stylesheets in the log directory
# OP We use copy instead of copy2 to update the creation date
# So we can clean the LOGS directories easily
try:
- src.ensure_path_exists(logDir)
- shutil.copy(xslCommand, logDir)
- shutil.copy(xslHat, logDir)
- src.ensure_path_exists(os.path.join(logDir, "TEST"))
- shutil.copy(xsltest, os.path.join(logDir, "TEST"))
- shutil.copy(imgLogo, logDir)
+ src.ensure_path_exists(logDir)
+ shutil.copy(xslCommand, logDir)
+ shutil.copy(xslHat, logDir)
+ src.ensure_path_exists(os.path.join(logDir, "TEST"))
+ shutil.copy(xsltest, os.path.join(logDir, "TEST"))
+ shutil.copy(imgLogo, logDir)
except:
- # we are here if an user make sat log in jenkins LOGS without write rights
- # Make a warning and do nothing
- logger.warning("problem for writing in directory '%s', may be not owner." % logDir)
+ # we are here if an user make sat log in jenkins LOGS without write rights
+ # Make a warning and do nothing
+ logger.warning(
+ "problem for writing in directory '%s', may be not owner." % logDir
+ )
# If the last option is invoked, just, show the last log file
if options.last_compile:
src.check_config_has_application(runner.cfg)
- log_dirs = os.listdir(os.path.join(runner.cfg.APPLICATION.workdir, 'LOGS'))
+ log_dirs = os.listdir(os.path.join(runner.cfg.APPLICATION.workdir, "LOGS"))
show_last_logs(logger, runner.cfg, log_dirs)
return 0
# If the last option is invoked, just, show the last log file
if options.last:
- lastLogFilePath = get_last_log_file(logDir,
- notShownCommands + ["config"])
+ lastLogFilePath = get_last_log_file(logDir, notShownCommands + ["config"])
if options.terminal:
# Show the log corresponding to the selected command call
print_log_command_in_terminal(lastLogFilePath, logger)
else:
# open the log xml file in the user editor
- src.system.show_in_editor(runner.cfg.USER.browser,
- lastLogFilePath, logger)
+ src.system.show_in_editor(runner.cfg.USER.browser, lastLogFilePath, logger)
return 0
# If the user asks for a terminal display
if options.terminal:
- # Parse the log directory in order to find
+ # Parse the log directory in order to find
# all the files corresponding to the commands
- lLogs = src.logger.list_log_file(logDir,
- src.logger.log_macro_command_file_expression)
+ lLogs = src.logger.list_log_file(
+ logDir, src.logger.log_macro_command_file_expression
+ )
lLogsFiltered = []
for filePath, __, date, __, hour, cmd, __ in lLogs:
- showLog, cmdAppli, __ = src.logger.show_command_log(filePath, cmd,
- runner.cfg.VARS.application, notShownCommands)
+ showLog, cmdAppli, __ = src.logger.show_command_log(
+ filePath, cmd, runner.cfg.VARS.application, notShownCommands
+ )
if showLog:
lLogsFiltered.append((filePath, date, hour, cmd, cmdAppli))
-
+
lLogsFiltered = sorted(lLogsFiltered)
nb_logs = len(lLogsFiltered)
index = 0
- # loop on all files and print it with date, time and command name
- for __, date, hour, cmd, cmdAppli in lLogsFiltered:
+ # loop on all files and print it with date, time and command name
+ for __, date, hour, cmd, cmdAppli in lLogsFiltered:
num = src.printcolors.printcLabel("%2d" % (nb_logs - index))
- logger.write("%s: %13s %s %s %s\n" %
- (num, cmd, date, hour, cmdAppli), 1, False)
+ logger.write(
+ "%s: %13s %s %s %s\n" % (num, cmd, date, hour, cmdAppli), 1, False
+ )
index += 1
-
+
# ask the user what for what command he wants to be displayed
x = -1
- while (x < 0):
+ while x < 0:
x = ask_value(nb_logs)
if x > 0:
index = len(lLogsFiltered) - int(x)
# Show the log corresponding to the selected command call
- print_log_command_in_terminal(lLogsFiltered[index][0], logger)
+ print_log_command_in_terminal(lLogsFiltered[index][0], logger)
x = 0
-
+
return 0
-
+
# Create or update the hat xml that gives access to all the commands log files
logger.write(_("Generating the hat log file (can be long) ... "), 3)
- xmlHatFilePath = os.path.join(logDir, 'hat.xml')
+ xmlHatFilePath = os.path.join(logDir, "hat.xml")
try:
- src.logger.update_hat_xml(logDir,
- application = runner.cfg.VARS.application,
- notShownCommands = notShownCommands)
+ src.logger.update_hat_xml(
+ logDir,
+ application=runner.cfg.VARS.application,
+ notShownCommands=notShownCommands,
+ )
- logger.write(src.printcolors.printc("OK"), 3)
+ logger.write(src.printcolors.printc("OK"), 3)
except:
- logger.write(src.printcolors.printc("KO"), 3)
- logger.write(" problem update hat.xml", 3)
+ logger.write(src.printcolors.printc("KO"), 3)
+ logger.write(" problem update hat.xml", 3)
logger.write("\n", 3)
-
+
# open the hat xml in the user editor
if not options.no_browser:
logger.write(_("\nOpening the hat log file %s\n" % xmlHatFilePath), 3)
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2012 CEA/DEN
#
# This library is free software; you can redistribute it and/or
# Define all possible option for the make command : sat make <options>
parser = src.options.Options()
-parser.add_option('p', 'products', 'list2', 'products',
- _('Optional: products to configure. This option accepts a comma separated list.'))
-parser.add_option('o', 'option', 'string', 'option',
- _('Optional: Option to add to the make command.'), "")
+parser.add_option(
+ "p",
+ "products",
+ "list2",
+ "products",
+ _("Optional: products to configure. This option accepts a comma separated list."),
+)
+parser.add_option(
+ "o",
+ "option",
+ "string",
+ "option",
+ _("Optional: Option to add to the make command."),
+ "",
+)
def log_step(logger, header, step):
logger.write("\n==== %s \n" % src.printcolors.printcInfo(step), 4)
logger.flush()
+
def log_res_step(logger, res):
if res == 0:
logger.write("%s \n" % src.printcolors.printcSuccess("OK"), 4)
logger.write("%s \n" % src.printcolors.printcError("KO"), 4)
logger.flush()
+
def make_all_products(config, products_infos, make_option, logger):
- '''Execute the proper configuration commands
+ """Execute the proper configuration commands
in each product build directory.
:param config Config: The global configuration
- :param products_info list: List of
+ :param products_info list: List of
(str, Config) => (product_name, product_info)
:param make_option str: The options to add to the command
:param logger Logger: The logger instance to use for the display and logging
:return: the number of failing commands.
:rtype: int
- '''
+ """
res = 0
for p_name_info in products_infos:
res_prod = make_product(p_name_info, make_option, config, logger)
if res_prod != 0:
- res += 1
+ res += 1
return res
+
def make_product(p_name_info, make_option, config, logger):
- '''Execute the proper configuration command(s)
+ """Execute the proper configuration command(s)
in the product build directory.
-
+
:param p_name_info tuple: (str, Config) => (product_name, product_info)
:param make_option str: The options to add to the command
:param config Config: The global configuration
- :param logger Logger: The logger instance to use for the display
+ :param logger Logger: The logger instance to use for the display
and logging
:return: 1 if it fails, else 0.
:rtype: int
- '''
-
+ """
+
p_name, p_info = p_name_info
-
+
# Logging
logger.write("\n", 4, False)
logger.write("################ ", 4)
logger.flush()
# Do nothing if he product is not compilable
- if ("properties" in p_info and "compilation" in p_info.properties and
- p_info.properties.compilation == "no"):
+ if (
+ "properties" in p_info
+ and "compilation" in p_info.properties
+ and p_info.properties.compilation == "no"
+ ):
log_step(logger, header, "ignored")
logger.write("\n", 3, False)
return 0
# Instantiate the class that manages all the construction commands
# like cmake, make, make install, make test, environment management, etc...
builder = src.compilation.Builder(config, logger, p_name, p_info)
-
+
# Prepare the environment
log_step(logger, header, "PREPARE ENV")
res_prepare = builder.prepare()
log_res_step(logger, res_prepare)
-
+
# Execute buildconfigure, configure if the product is autotools
# Execute cmake if the product is cmake
len_end_line = 20
else:
res = builder.make(nb_proc, make_opt_without_j)
log_res_step(logger, res)
-
+
# Log the result
if res > 0:
logger.write("\r%s%s" % (header, " " * len_end_line), 3)
logger.write("\r" + header + src.printcolors.printcError("KO"))
- logger.write("==== %(KO)s in make of %(name)s \n" %
- { "name" : p_name , "KO" : src.printcolors.printcInfo("ERROR")}, 4)
+ logger.write(
+ "==== %(KO)s in make of %(name)s \n"
+ % {"name": p_name, "KO": src.printcolors.printcInfo("ERROR")},
+ 4,
+ )
logger.flush()
else:
logger.write("\r%s%s" % (header, " " * len_end_line), 3)
logger.write("\r" + header + src.printcolors.printcSuccess("OK"))
logger.write("==== %s \n" % src.printcolors.printcInfo("OK"), 4)
- logger.write("==== Make of %(name)s %(OK)s \n" %
- { "name" : p_name , "OK" : src.printcolors.printcInfo("OK")}, 4)
+ logger.write(
+ "==== Make of %(name)s %(OK)s \n"
+ % {"name": p_name, "OK": src.printcolors.printcInfo("OK")},
+ 4,
+ )
logger.flush()
logger.write("\n", 3, False)
return res
+
def get_nb_proc(product_info, config, make_option):
-
+
opt_nb_proc = None
new_make_option = make_option
if "-j" in make_option:
oExpr = re.compile("-j[0-9]+")
found = oExpr.search(make_option)
- opt_nb_proc = int(re.findall('\d+', found.group())[0])
+ opt_nb_proc = int(re.findall("\d+", found.group())[0])
new_make_option = make_option.replace(found.group(), "")
-
+
nbproc = -1
if "nb_proc" in product_info:
# nb proc is specified in module definition
nbproc = opt_nb_proc
else:
nbproc = config.VARS.nb_proc
-
+
assert nbproc > 0
return nbproc, new_make_option
+
def description():
- '''method that is called when salomeTools is called with --help option.
-
+ """method that is called when salomeTools is called with --help option.
+
:return: The text to display for the make command description.
:rtype: str
- '''
- return _("The make command executes the \"make\" command in"
- " the build directory.\nexample:\nsat make SALOME-master "
- "--products Python,KERNEL,GUI")
-
+ """
+ return _(
+ 'The make command executes the "make" command in'
+ " the build directory.\nexample:\nsat make SALOME-master "
+ "--products Python,KERNEL,GUI"
+ )
+
+
def run(args, runner, logger):
- '''method that is called when salomeTools is called with make parameter.
- '''
-
+ """method that is called when salomeTools is called with make parameter."""
+
# Parse the options
(options, args) = parser.parse_args(args)
# check that the command has been called with an application
- src.check_config_has_application( runner.cfg )
+ src.check_config_has_application(runner.cfg)
# Get the list of products to treat
products_infos = src.product.get_products_list(options, runner.cfg, logger)
-
+
# Print some informations
- logger.write(_('Executing the make command in the build '
- 'directories of the application %s\n') %
- src.printcolors.printcLabel(runner.cfg.VARS.application), 1)
-
- info = [(_("BUILD directory"),
- os.path.join(runner.cfg.APPLICATION.workdir, 'BUILD'))]
+ logger.write(
+ _(
+ "Executing the make command in the build "
+ "directories of the application %s\n"
+ )
+ % src.printcolors.printcLabel(runner.cfg.VARS.application),
+ 1,
+ )
+
+ info = [
+ (_("BUILD directory"), os.path.join(runner.cfg.APPLICATION.workdir, "BUILD"))
+ ]
src.print_info(logger, info)
-
+
# Call the function that will loop over all the products and execute
# the right command(s)
if options.option is None:
options.option = ""
res = make_all_products(runner.cfg, products_infos, options.option, logger)
-
+
# Print the final state
nb_products = len(products_infos)
if res == 0:
final_status = "OK"
else:
final_status = "KO"
-
- logger.write(_("\nMake: %(status)s (%(valid_result)d/%(nb_products)d)\n") % \
- { 'status': src.printcolors.printc(final_status),
- 'valid_result': nb_products - res,
- 'nb_products': nb_products }, 1)
-
- return res
+
+ logger.write(
+ _("\nMake: %(status)s (%(valid_result)d/%(nb_products)d)\n")
+ % {
+ "status": src.printcolors.printc(final_status),
+ "valid_result": nb_products - res,
+ "nb_products": nb_products,
+ },
+ 1,
+ )
+
+ return res
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2012 CEA/DEN
#
# This library is free software; you can redistribute it and/or
# Define all possible option for the makeinstall command : sat makeinstall <options>
parser = src.options.Options()
-parser.add_option('p', 'products', 'list2', 'products',
- _('Optional: products to install. This option accepts a comma separated list.'))
+parser.add_option(
+ "p",
+ "products",
+ "list2",
+ "products",
+ _("Optional: products to install. This option accepts a comma separated list."),
+)
def log_step(logger, header, step):
logger.write("\n==== %s \n" % src.printcolors.printcInfo(step), 4)
logger.flush()
+
def log_res_step(logger, res):
if res == 0:
logger.write("%s \n" % src.printcolors.printcSuccess("OK"), 4)
logger.write("%s \n" % src.printcolors.printcError("KO"), 4)
logger.flush()
+
def makeinstall_all_products(config, products_infos, logger):
- '''Execute the proper configuration commands
+ """Execute the proper configuration commands
in each product build directory.
:param config Config: The global configuration
- :param products_info list: List of
+ :param products_info list: List of
(str, Config) => (product_name, product_info)
:param logger Logger: The logger instance to use for the display and logging
:return: the number of failing commands.
:rtype: int
- '''
+ """
res = 0
for p_name_info in products_infos:
res_prod = makeinstall_product(p_name_info, config, logger)
if res_prod != 0:
- res += 1
+ res += 1
return res
+
def makeinstall_product(p_name_info, config, logger):
- '''Execute the proper configuration command(s)
+ """Execute the proper configuration command(s)
in the product build directory.
-
+
:param p_name_info tuple: (str, Config) => (product_name, product_info)
:param config Config: The global configuration
- :param logger Logger: The logger instance to use for the display
+ :param logger Logger: The logger instance to use for the display
and logging
:return: 1 if it fails, else 0.
:rtype: int
- '''
-
+ """
+
p_name, p_info = p_name_info
-
+
# Logging
logger.write("\n", 4, False)
logger.write("################ ", 4)
logger.flush()
# Do nothing if he product is not compilable
- if ("properties" in p_info and "compilation" in p_info.properties and
- p_info.properties.compilation == "no"):
+ if (
+ "properties" in p_info
+ and "compilation" in p_info.properties
+ and p_info.properties.compilation == "no"
+ ):
log_step(logger, header, "ignored")
logger.write("\n", 3, False)
return 0
# Instantiate the class that manages all the construction commands
# like cmake, make, make install, make test, environment management, etc...
builder = src.compilation.Builder(config, logger, p_name, p_info)
-
+
# Prepare the environment
log_step(logger, header, "PREPARE ENV")
res_prepare = builder.prepare()
log_res_step(logger, res_prepare)
-
+
# Execute buildconfigure, configure if the product is autotools
# Execute cmake if the product is cmake
res = 0
res_m = builder.install()
log_res_step(logger, res_m)
res += res_m
-
+
# Log the result
if res > 0:
logger.write("\r%s%s" % (header, " " * 20), 3)
logger.write("\r" + header + src.printcolors.printcError("KO"))
- logger.write("==== %(KO)s in make install of %(name)s \n" %
- { "name" : p_name , "KO" : src.printcolors.printcInfo("ERROR")}, 4)
+ logger.write(
+ "==== %(KO)s in make install of %(name)s \n"
+ % {"name": p_name, "KO": src.printcolors.printcInfo("ERROR")},
+ 4,
+ )
logger.write("\n", 3, False)
logger.flush()
return res
if res > 0:
logger.write("\r%s%s" % (header, " " * len_end_line), 3)
logger.write("\r" + header + src.printcolors.printcError("KO"))
- logger.write("==== %(KO)s in post script execution of %(name)s \n" %
- { "name" : p_name , "KO" : src.printcolors.printcInfo("ERROR")}, 4)
+ logger.write(
+ "==== %(KO)s in post script execution of %(name)s \n"
+ % {"name": p_name, "KO": src.printcolors.printcInfo("ERROR")},
+ 4,
+ )
logger.write("\n", 3, False)
logger.flush()
return res
logger.write("\r%s%s" % (header, " " * 20), 3)
logger.write("\r" + header + src.printcolors.printcSuccess("OK"))
logger.write("==== %s \n" % src.printcolors.printcInfo("OK"), 4)
- logger.write("==== Make install of %(name)s %(OK)s \n" %
- { "name" : p_name , "OK" : src.printcolors.printcInfo("OK")}, 4)
+ logger.write(
+ "==== Make install of %(name)s %(OK)s \n"
+ % {"name": p_name, "OK": src.printcolors.printcInfo("OK")},
+ 4,
+ )
logger.flush()
logger.write("\n", 3, False)
return res
+
def description():
- '''method that is called when salomeTools is called with --help option.
-
+ """method that is called when salomeTools is called with --help option.
+
:return: The text to display for the makeinstall command description.
:rtype: str
- '''
- return _("The makeinstall command executes the \"make install\" command in"
- " the build directory.\nIn case of product that is constructed "
- "using a script (build_source : \"script\"), then the "
- "makeinstall command do nothing.\n\nexample:\nsat makeinstall "
- "SALOME-master --products KERNEL,GUI")
-
+ """
+ return _(
+ 'The makeinstall command executes the "make install" command in'
+ " the build directory.\nIn case of product that is constructed "
+ 'using a script (build_source : "script"), then the '
+ "makeinstall command do nothing.\n\nexample:\nsat makeinstall "
+ "SALOME-master --products KERNEL,GUI"
+ )
+
+
def run(args, runner, logger):
- '''method that is called when salomeTools is called with makeinstall parameter.
- '''
-
+ """method that is called when salomeTools is called with makeinstall parameter."""
+
# Parse the options
(options, args) = parser.parse_args(args)
# check that the command has been called with an application
- src.check_config_has_application( runner.cfg )
+ src.check_config_has_application(runner.cfg)
# Get the list of products to treat
products_infos = src.product.get_products_list(options, runner.cfg, logger)
# Print some informations
- logger.write(_('Executing the make install command in the build directories of the application %s\n') %
- src.printcolors.printcLabel(runner.cfg.VARS.application), 1)
-
- info = [(_("BUILD directory"),
- os.path.join(runner.cfg.APPLICATION.workdir, 'BUILD'))]
+ logger.write(
+ _(
+ "Executing the make install command in the build directories of the application %s\n"
+ )
+ % src.printcolors.printcLabel(runner.cfg.VARS.application),
+ 1,
+ )
+
+ info = [
+ (_("BUILD directory"), os.path.join(runner.cfg.APPLICATION.workdir, "BUILD"))
+ ]
src.print_info(logger, info)
-
+
# Call the function that will loop over all the products and execute
# the right command(s)
res = makeinstall_all_products(runner.cfg, products_infos, logger)
-
+
# Print the final state
nb_products = len(products_infos)
if res == 0:
final_status = "OK"
else:
final_status = "KO"
-
- logger.write(_("\nMake install: %(status)s (%(valid_result)d/%(nb_products)d)\n") % \
- { 'status': src.printcolors.printc(final_status),
- 'valid_result': nb_products - res,
- 'nb_products': nb_products }, 1)
-
- return res
+
+ logger.write(
+ _("\nMake install: %(status)s (%(valid_result)d/%(nb_products)d)\n")
+ % {
+ "status": src.printcolors.printc(final_status),
+ "valid_result": nb_products - res,
+ "nb_products": nb_products,
+ },
+ 1,
+ )
+
+ return res
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2012 CEA/DEN
#
# This library is free software; you can redistribute it and/or
import src
from application import get_SALOME_modules
-from src.versionMinorMajorPatch import MinorMajorPatch as MMP
+from src.versionMinorMajorPatch import MinorMajorPatch as MMP
import src.debug as DBG
old_python = sys.version_info[0] == 2 and sys.version_info[1] <= 6
IGNORED_DIRS = [".git", ".svn"]
IGNORED_EXTENSIONS = []
-PACKAGE_EXT=".tar.gz" # the extension we use for the packages
+PACKAGE_EXT = ".tar.gz" # the extension we use for the packages
if src.architecture.is_windows():
PROJECT_TEMPLATE = """#!/usr/bin/env python
"""
-LOCAL_TEMPLATE = ("""#!/usr/bin/env python
+LOCAL_TEMPLATE = (
+ """#!/usr/bin/env python
#-*- coding:utf-8 -*-
LOCAL :
{
project_file_paths :
[
-$LOCAL.workdir + $VARS.sep + \"""" + PROJECT_DIR + """\" + $VARS.sep + "project.pyconf"
+$LOCAL.workdir + $VARS.sep + \""""
+ + PROJECT_DIR
+ + """\" + $VARS.sep + "project.pyconf"
]
}
-""")
+"""
+)
# Define all possible option for the package command : sat package <options>
parser = src.options.Options()
-parser.add_option('b', 'binaries', 'boolean', 'binaries',
- _('Optional: Produce a binary package.'), False)
-parser.add_option('f', 'force_creation', 'boolean', 'force_creation',
- _('Optional: Only binary package: produce the archive even if '
- 'there are some missing products.'), False)
-parser.add_option('s', 'sources', 'boolean', 'sources',
- _('Optional: Produce a compilable archive of the sources of the '
- 'application.'), False)
-parser.add_option('', 'bin_products', 'boolean', 'bin_products',
- _('Optional: Create binary archives for all products.'), False)
-parser.add_option('', 'with_vcs', 'boolean', 'with_vcs',
- _('Optional: Do not make archive for products in VCS mode (git, cvs, svn). '
- 'Sat prepare will use VCS mode instead to retrieve them.'
- '\n Also, when combined with "--bin_products" option, restrict the building of product archives to VCS products.'),
- False)
-parser.add_option('', 'ftp', 'boolean', 'ftp',
- _('Optional: Do not embed archives for products in archive mode.'
- 'Sat prepare will use ftp instead to retrieve them'),
- False)
-parser.add_option('e', 'exe', 'string', 'exe',
- _('Optional: Produce an extra launcher based upon the exe given as argument.'), "")
-parser.add_option('p', 'project', 'string', 'project',
- _('Optional: Produce an archive that contains a project.'), "")
-parser.add_option('t', 'salometools', 'boolean', 'sat',
- _('Optional: Produce an archive that contains salomeTools.'), False)
-parser.add_option('n', 'name', 'string', 'name',
- _('Optional: The name or full path of the archive.'), None)
-parser.add_option('', 'add_files', 'list2', 'add_files',
- _('Optional: The list of additional files to add to the archive.'), [])
-parser.add_option('', 'without_properties', 'properties', 'without_properties',
- _('Optional: Filter the products by their properties.\n\tSyntax: '
- '--without_properties <property>:<value>'))
+parser.add_option(
+ "b",
+ "binaries",
+ "boolean",
+ "binaries",
+ _("Optional: Produce a binary package."),
+ False,
+)
+parser.add_option(
+ "f",
+ "force_creation",
+ "boolean",
+ "force_creation",
+ _(
+ "Optional: Only binary package: produce the archive even if "
+ "there are some missing products."
+ ),
+ False,
+)
+parser.add_option(
+ "s",
+ "sources",
+ "boolean",
+ "sources",
+ _("Optional: Produce a compilable archive of the sources of the " "application."),
+ False,
+)
+parser.add_option(
+ "",
+ "bin_products",
+ "boolean",
+ "bin_products",
+ _("Optional: Create binary archives for all products."),
+ False,
+)
+parser.add_option(
+ "",
+ "with_vcs",
+ "boolean",
+ "with_vcs",
+ _(
+ "Optional: Do not make archive for products in VCS mode (git, cvs, svn). "
+ "Sat prepare will use VCS mode instead to retrieve them."
+ '\n Also, when combined with "--bin_products" option, restrict the building of product archives to VCS products.'
+ ),
+ False,
+)
+parser.add_option(
+ "",
+ "ftp",
+ "boolean",
+ "ftp",
+ _(
+ "Optional: Do not embed archives for products in archive mode."
+ "Sat prepare will use ftp instead to retrieve them"
+ ),
+ False,
+)
+parser.add_option(
+ "e",
+ "exe",
+ "string",
+ "exe",
+ _("Optional: Produce an extra launcher based upon the exe given as argument."),
+ "",
+)
+parser.add_option(
+ "p",
+ "project",
+ "string",
+ "project",
+ _("Optional: Produce an archive that contains a project."),
+ "",
+)
+parser.add_option(
+ "t",
+ "salometools",
+ "boolean",
+ "sat",
+ _("Optional: Produce an archive that contains salomeTools."),
+ False,
+)
+parser.add_option(
+ "n",
+ "name",
+ "string",
+ "name",
+ _("Optional: The name or full path of the archive."),
+ None,
+)
+parser.add_option(
+ "",
+ "add_files",
+ "list2",
+ "add_files",
+ _("Optional: The list of additional files to add to the archive."),
+ [],
+)
+parser.add_option(
+ "",
+ "without_properties",
+ "properties",
+ "without_properties",
+ _(
+ "Optional: Filter the products by their properties.\n\tSyntax: "
+ "--without_properties <property>:<value>"
+ ),
+)
def add_files(tar, name_archive, d_content, logger, f_exclude=None):
- '''Create an archive containing all directories and files that are given in
+ """Create an archive containing all directories and files that are given in
the d_content argument.
:param tar tarfile: The tarfile instance used to make the archive.
:param f_exclude Function: the function that filters
:return: 0 if success, 1 if not.
:rtype: int
- '''
+ """
# get the max length of the messages in order to make the display
max_len = len(max(d_content.keys(), key=len))
DBG.write("add tar names", names)
# used to avoid duplications (for pip install in python, or single_install_dir cases)
- already_added=set()
+ already_added = set()
for name in names:
# display information
len_points = max_len - len(name) + 3
local_path, archive_path = d_content[name]
in_archive = os.path.join(name_archive, archive_path)
- logger.write(name + " " + len_points * "." + " "+ in_archive + " ", 3)
+ logger.write(name + " " + len_points * "." + " " + in_archive + " ", 3)
# Get the local path and the path in archive
# of the directory or file to add
# Add it in the archive
try:
- key=local_path+"->"+in_archive
+ key = local_path + "->" + in_archive
if key not in already_added:
if old_python:
- tar.add(local_path,
- arcname=in_archive,
- exclude=exclude_VCS_and_extensions_26)
+ tar.add(
+ local_path,
+ arcname=in_archive,
+ exclude=exclude_VCS_and_extensions_26,
+ )
else:
- tar.add(local_path,
- arcname=in_archive,
- filter=exclude_VCS_and_extensions)
+ tar.add(
+ local_path,
+ arcname=in_archive,
+ filter=exclude_VCS_and_extensions,
+ )
already_added.add(key)
logger.write(src.printcolors.printcSuccess(_("OK")), 3)
except Exception as e:
def exclude_VCS_and_extensions_26(filename):
- ''' The function that is used to exclude from package the link to the
+ """The function that is used to exclude from package the link to the
VCS repositories (like .git) (only for python 2.6)
:param filename Str: The filname to exclude (or not).
:return: True if the file has to be exclude
:rtype: Boolean
- '''
+ """
for dir_name in IGNORED_DIRS:
if dir_name in filename:
return True
return True
return False
+
def exclude_VCS_and_extensions(tarinfo):
- ''' The function that is used to exclude from package the link to the
+ """The function that is used to exclude from package the link to the
VCS repositories (like .git)
:param filename Str: The filname to exclude (or not).
:return: None if the file has to be exclude
:rtype: tarinfo or None
- '''
+ """
filename = tarinfo.name
for dir_name in IGNORED_DIRS:
if dir_name in filename:
return None
return tarinfo
-def produce_relative_launcher(config,
- logger,
- file_dir,
- file_name,
- binaries_dir_name):
- '''Create a specific SALOME launcher for the binary package. This launcher
+
+def produce_relative_launcher(config, logger, file_dir, file_name, binaries_dir_name):
+ """Create a specific SALOME launcher for the binary package. This launcher
uses relative paths.
:param config Config: The global configuration.
are, in the archive.
:return: the path of the produced launcher
:rtype: str
- '''
+ """
# set base mode to "no" for the archive - save current mode to restore it at the end
if "base" in config.APPLICATION:
- base_setting=config.APPLICATION.base
+ base_setting = config.APPLICATION.base
else:
- base_setting="maybe"
- config.APPLICATION.base="no"
+ base_setting = "maybe"
+ config.APPLICATION.base = "no"
# get KERNEL installation path
kernel_info = src.product.get_product_config(config, "KERNEL")
- kernel_base_name=os.path.basename(kernel_info.install_dir)
+ kernel_base_name = os.path.basename(kernel_info.install_dir)
if kernel_info.install_mode == "base":
# case of kernel installed in base. the kernel install dir name is different in the archive
- kernel_base_name=os.path.basename(os.path.dirname(kernel_info.install_dir))
+ kernel_base_name = os.path.basename(os.path.dirname(kernel_info.install_dir))
kernel_root_dir = os.path.join(binaries_dir_name, kernel_base_name)
# set kernel bin dir (considering fhs property)
kernel_cfg = src.product.get_product_config(config, "KERNEL")
if src.get_property_in_product_cfg(kernel_cfg, "fhs"):
- bin_kernel_install_dir = os.path.join(kernel_root_dir,"bin")
+ bin_kernel_install_dir = os.path.join(kernel_root_dir, "bin")
else:
- bin_kernel_install_dir = os.path.join(kernel_root_dir,"bin","salome")
+ bin_kernel_install_dir = os.path.join(kernel_root_dir, "bin", "salome")
# check if the application contains an application module
# check also if the application has a distene product,
# in this case get its licence file name
- l_product_info = src.product.get_products_infos(config.APPLICATION.products.keys(), config)
- salome_application_name="Not defined"
- distene_licence_file_name=False
+ l_product_info = src.product.get_products_infos(
+ config.APPLICATION.products.keys(), config
+ )
+ salome_application_name = "Not defined"
+ distene_licence_file_name = False
for prod_name, prod_info in l_product_info:
# look for a "salome application" and a distene product
if src.get_property_in_product_cfg(prod_info, "is_distene") == "yes":
- distene_licence_file_name = src.product.product_has_licence(prod_info,
- config.PATHS.LICENCEPATH)
+ distene_licence_file_name = src.product.product_has_licence(
+ prod_info, config.PATHS.LICENCEPATH
+ )
if src.get_property_in_product_cfg(prod_info, "is_salome_application") == "yes":
- salome_application_name=prod_info.name
+ salome_application_name = prod_info.name
# if the application contains an application module, we set ABSOLUTE_APPLI_PATH to it
# if not we set it to KERNEL_INSTALL_DIR, which is sufficient, except for salome test
if salome_application_name == "Not defined":
- app_root_dir=kernel_root_dir
+ app_root_dir = kernel_root_dir
else:
- app_root_dir=os.path.join(binaries_dir_name, salome_application_name)
+ app_root_dir = os.path.join(binaries_dir_name, salome_application_name)
- additional_env={}
- additional_env['sat_bin_kernel_install_dir'] = "out_dir_Path + " +\
- config.VARS.sep + bin_kernel_install_dir
+ additional_env = {}
+ additional_env["sat_bin_kernel_install_dir"] = (
+ "out_dir_Path + " + config.VARS.sep + bin_kernel_install_dir
+ )
if "python3" in config.APPLICATION and config.APPLICATION.python3 == "yes":
- additional_env['sat_python_version'] = 3
+ additional_env["sat_python_version"] = 3
else:
- additional_env['sat_python_version'] = 2
+ additional_env["sat_python_version"] = 2
- additional_env['ABSOLUTE_APPLI_PATH'] = "out_dir_Path" + config.VARS.sep + app_root_dir
+ additional_env["ABSOLUTE_APPLI_PATH"] = (
+ "out_dir_Path" + config.VARS.sep + app_root_dir
+ )
launcher_name = src.get_launcher_name(config)
- additional_env['APPLI'] = "out_dir_Path" + config.VARS.sep + file_name
+ additional_env["APPLI"] = "out_dir_Path" + config.VARS.sep + file_name
# create an environment file writer
- writer = src.environment.FileEnvWriter(config,
- logger,
- file_dir,
- src_root=None,
- env_info=None)
+ writer = src.environment.FileEnvWriter(
+ config, logger, file_dir, src_root=None, env_info=None
+ )
filepath = os.path.join(file_dir, file_name)
# Write
- writer.write_env_file(filepath,
- False, # for launch
- "cfgForPy",
- additional_env=additional_env,
- no_path_init=False,
- for_package = binaries_dir_name)
+ writer.write_env_file(
+ filepath,
+ False, # for launch
+ "cfgForPy",
+ additional_env=additional_env,
+ no_path_init=False,
+ for_package=binaries_dir_name,
+ )
# Little hack to put out_dir_Path outside the strings
- src.replace_in_file(filepath, 'r"out_dir_Path', 'out_dir_Path + r"' )
- src.replace_in_file(filepath, "r'out_dir_Path + ", "out_dir_Path + r'" )
+ src.replace_in_file(filepath, 'r"out_dir_Path', 'out_dir_Path + r"')
+ src.replace_in_file(filepath, "r'out_dir_Path + ", "out_dir_Path + r'")
# A hack to put a call to a file for distene licence.
# It does nothing to an application that has no distene product
if distene_licence_file_name:
- logger.write("Application has a distene licence file! We use it in package launcher", 5)
+ logger.write(
+ "Application has a distene licence file! We use it in package launcher", 5
+ )
hack_for_distene_licence(filepath, distene_licence_file_name)
# change the rights in order to make the file executable for everybody
- os.chmod(filepath,
- stat.S_IRUSR |
- stat.S_IRGRP |
- stat.S_IROTH |
- stat.S_IWUSR |
- stat.S_IXUSR |
- stat.S_IXGRP |
- stat.S_IXOTH)
+ os.chmod(
+ filepath,
+ stat.S_IRUSR
+ | stat.S_IRGRP
+ | stat.S_IROTH
+ | stat.S_IWUSR
+ | stat.S_IXUSR
+ | stat.S_IXGRP
+ | stat.S_IXOTH,
+ )
# restore modified setting by its initial value
- config.APPLICATION.base=base_setting
+ config.APPLICATION.base = base_setting
return filepath
+
def hack_for_distene_licence(filepath, licence_file):
- '''Replace the distene licence env variable by a call to a file.
+ """Replace the distene licence env variable by a call to a file.
:param filepath Str: The path to the launcher to modify.
- '''
+ """
shutil.move(filepath, filepath + "_old")
- fileout= filepath
+ fileout = filepath
filein = filepath + "_old"
fin = open(filein, "r")
fout = open(fileout, "w")
text = fin.readlines()
# Find the Distene section
num_line = -1
- for i,line in enumerate(text):
+ for i, line in enumerate(text):
if "# Set DISTENE License" in line:
num_line = i
break
fout.write(line)
fout.close()
return
- del text[num_line +1]
- del text[num_line +1]
- text_to_insert =""" try:
+ del text[num_line + 1]
+ del text[num_line + 1]
+ text_to_insert = (
+ """ try:
distene_licence_file=r"%s"
if sys.version_info[0] >= 3 and sys.version_info[1] >= 5:
import importlib.util
distene = imp.load_source('distene_licence', distene_licence_file)
distene.set_distene_variables(context)
except:
- pass\n""" % licence_file
+ pass\n"""
+ % licence_file
+ )
text.insert(num_line + 1, text_to_insert)
for line in text:
fout.write(line)
fout.close()
return
-def produce_relative_env_files(config,
- logger,
- file_dir,
- binaries_dir_name,
- exe_name=None):
- '''Create some specific environment files for the binary package. These
+
+def produce_relative_env_files(
+ config, logger, file_dir, binaries_dir_name, exe_name=None
+):
+ """Create some specific environment files for the binary package. These
files use relative paths.
:param config Config: The global configuration.
:param exe_name str: if given generate a launcher executing exe_name
:return: the list of path of the produced environment files
:rtype: List
- '''
+ """
# set base mode to "no" for the archive - save current mode to restore it at the end
if "base" in config.APPLICATION:
- base_setting=config.APPLICATION.base
+ base_setting = config.APPLICATION.base
else:
- base_setting="maybe"
- config.APPLICATION.base="no"
+ base_setting = "maybe"
+ config.APPLICATION.base = "no"
# create an environment file writer
- writer = src.environment.FileEnvWriter(config,
- logger,
- file_dir,
- src_root=None)
+ writer = src.environment.FileEnvWriter(config, logger, file_dir, src_root=None)
if src.architecture.is_windows():
- shell = "bat"
- filename = "env_launch.bat"
+ shell = "bat"
+ filename = "env_launch.bat"
else:
- shell = "bash"
- filename = "env_launch.sh"
+ shell = "bash"
+ filename = "env_launch.sh"
if exe_name:
- filename=os.path.basename(exe_name)
+ filename = os.path.basename(exe_name)
# Write
- filepath = writer.write_env_file(filename,
- False, # for launch
- shell,
- for_package = binaries_dir_name)
+ filepath = writer.write_env_file(
+ filename, False, shell, for_package=binaries_dir_name # for launch
+ )
# Little hack to put out_dir_Path as environment variable
- if src.architecture.is_windows() :
- src.replace_in_file(filepath, '"out_dir_Path', '"%out_dir_Path%' )
- src.replace_in_file(filepath, '=out_dir_Path', '=%out_dir_Path%' )
- src.replace_in_file(filepath, ';out_dir_Path', ';%out_dir_Path%' )
+ if src.architecture.is_windows():
+ src.replace_in_file(filepath, '"out_dir_Path', '"%out_dir_Path%')
+ src.replace_in_file(filepath, "=out_dir_Path", "=%out_dir_Path%")
+ src.replace_in_file(filepath, ";out_dir_Path", ";%out_dir_Path%")
else:
- src.replace_in_file(filepath, '"out_dir_Path', '"${out_dir_Path}' )
- src.replace_in_file(filepath, ':out_dir_Path', ':${out_dir_Path}' )
- src.replace_in_file(filepath, ';out_dir_Path', ';${out_dir_Path}' )
+ src.replace_in_file(filepath, '"out_dir_Path', '"${out_dir_Path}')
+ src.replace_in_file(filepath, ":out_dir_Path", ":${out_dir_Path}")
+ src.replace_in_file(filepath, ";out_dir_Path", ";${out_dir_Path}")
if exe_name:
if src.architecture.is_windows():
- cmd="\n\nrem Launch exe with user arguments\n%s " % exe_name + "%*"
+ cmd = "\n\nrem Launch exe with user arguments\n%s " % exe_name + "%*"
else:
- cmd='\n\n# Launch exe with user arguments\n%s "$*"' % exe_name
+ cmd = '\n\n# Launch exe with user arguments\n%s "$*"' % exe_name
with open(filepath, "a") as exe_launcher:
exe_launcher.write(cmd)
# change the rights in order to make the file executable for everybody
- os.chmod(filepath,
- stat.S_IRUSR |
- stat.S_IRGRP |
- stat.S_IROTH |
- stat.S_IWUSR |
- stat.S_IXUSR |
- stat.S_IXGRP |
- stat.S_IXOTH)
+ os.chmod(
+ filepath,
+ stat.S_IRUSR
+ | stat.S_IRGRP
+ | stat.S_IROTH
+ | stat.S_IWUSR
+ | stat.S_IXUSR
+ | stat.S_IXGRP
+ | stat.S_IXOTH,
+ )
# restore modified setting by its initial value
- config.APPLICATION.base=base_setting
+ config.APPLICATION.base = base_setting
return filepath
-def produce_install_bin_file(config,
- logger,
- file_dir,
- d_sub,
- file_name):
- '''Create a bash shell script which do substitutions in BIRARIES dir
+
+def produce_install_bin_file(config, logger, file_dir, d_sub, file_name):
+ """Create a bash shell script which do substitutions in BIRARIES dir
in order to use it for extra compilations.
:param config Config: The global configuration.
:param file_name str: the name of the install script file
:return: the produced file
:rtype: str
- '''
+ """
# Write
filepath = os.path.join(file_dir, file_name)
# open the file and write into it
# use codec utf-8 as sat variables are in unicode
- with codecs.open(filepath, "w", 'utf-8') as installbin_file:
- installbin_template_path = os.path.join(config.VARS.internal_dir,
- "INSTALL_BIN.template")
+ with codecs.open(filepath, "w", "utf-8") as installbin_file:
+ installbin_template_path = os.path.join(
+ config.VARS.internal_dir, "INSTALL_BIN.template"
+ )
# build the name of the directory that will contain the binaries
binaries_dir_name = config.INTERNAL.config.binary_dir + config.VARS.dist
# build the substitution loop
loop_cmd = "for f in $(grep -RIl"
for key in d_sub:
- loop_cmd += " -e "+ key
- loop_cmd += ' ' + config.INTERNAL.config.install_dir +\
- '); do\n sed -i "\n'
+ loop_cmd += " -e " + key
+ loop_cmd += " " + config.INTERNAL.config.install_dir + '); do\n sed -i "\n'
for key in d_sub:
loop_cmd += " s?" + key + "?$(pwd)/" + d_sub[key] + "?g\n"
loop_cmd += ' " $f\ndone'
- d={}
+ d = {}
d["BINARIES_DIR"] = binaries_dir_name
- d["SUBSTITUTION_LOOP"]=loop_cmd
- d["INSTALL_DIR"]=config.INTERNAL.config.install_dir
+ d["SUBSTITUTION_LOOP"] = loop_cmd
+ d["INSTALL_DIR"] = config.INTERNAL.config.install_dir
# substitute the template and write it in file
- content=src.template.substitute(installbin_template_path, d)
+ content = src.template.substitute(installbin_template_path, d)
installbin_file.write(content)
# change the rights in order to make the file executable for everybody
- os.chmod(filepath,
- stat.S_IRUSR |
- stat.S_IRGRP |
- stat.S_IROTH |
- stat.S_IWUSR |
- stat.S_IXUSR |
- stat.S_IXGRP |
- stat.S_IXOTH)
+ os.chmod(
+ filepath,
+ stat.S_IRUSR
+ | stat.S_IRGRP
+ | stat.S_IROTH
+ | stat.S_IWUSR
+ | stat.S_IXUSR
+ | stat.S_IXGRP
+ | stat.S_IXOTH,
+ )
return filepath
-def product_appli_creation_script(config,
- logger,
- file_dir,
- binaries_dir_name):
- '''Create a script that can produce an application (EDF style) in the binary
+
+def product_appli_creation_script(config, logger, file_dir, binaries_dir_name):
+ """Create a script that can produce an application (EDF style) in the binary
package.
:param config Config: The global configuration.
are, in the archive.
:return: the path of the produced script file
:rtype: Str
- '''
+ """
template_name = "create_appli.py.for_bin_packages.template"
template_path = os.path.join(config.VARS.internal_dir, template_name)
text_to_fill = open(template_path, "r").read()
- text_to_fill = text_to_fill.replace("TO BE FILLED 1",
- '"' + binaries_dir_name + '"')
+ text_to_fill = text_to_fill.replace("TO BE FILLED 1", '"' + binaries_dir_name + '"')
text_to_add = ""
for product_name in get_SALOME_modules(config):
if src.product.product_is_smesh_plugin(product_info):
continue
- if 'install_dir' in product_info and bool(product_info.install_dir):
+ if "install_dir" in product_info and bool(product_info.install_dir):
if src.product.product_is_cpp(product_info):
# cpp module
for cpp_name in src.product.get_product_components(product_info):
- line_to_add = ("<module name=\"" +
- cpp_name +
- "\" gui=\"yes\" path=\"''' + "
- "os.path.join(dir_bin_name, \"" +
- cpp_name + "\") + '''\"/>")
+ line_to_add = (
+ '<module name="' + cpp_name + '" gui="yes" path="\'\'\' + '
+ 'os.path.join(dir_bin_name, "' + cpp_name + "\") + '''\"/>"
+ )
else:
# regular module
- line_to_add = ("<module name=\"" +
- product_name +
- "\" gui=\"yes\" path=\"''' + "
- "os.path.join(dir_bin_name, \"" +
- product_name + "\") + '''\"/>")
+ line_to_add = (
+ '<module name="' + product_name + '" gui="yes" path="\'\'\' + '
+ 'os.path.join(dir_bin_name, "' + product_name + "\") + '''\"/>"
+ )
text_to_add += line_to_add + "\n"
filled_text = text_to_fill.replace("TO BE FILLED 2", text_to_add)
ff.close()
# change the rights in order to make the file executable for everybody
- os.chmod(tmp_file_path,
- stat.S_IRUSR |
- stat.S_IRGRP |
- stat.S_IROTH |
- stat.S_IWUSR |
- stat.S_IXUSR |
- stat.S_IXGRP |
- stat.S_IXOTH)
+ os.chmod(
+ tmp_file_path,
+ stat.S_IRUSR
+ | stat.S_IRGRP
+ | stat.S_IROTH
+ | stat.S_IWUSR
+ | stat.S_IXUSR
+ | stat.S_IXGRP
+ | stat.S_IXOTH,
+ )
return tmp_file_path
+
def bin_products_archives(config, logger, only_vcs):
- '''Prepare binary packages for all products
+ """Prepare binary packages for all products
:param config Config: The global configuration.
:return: the error status
:rtype: bool
- '''
+ """
logger.write("Make %s binary archives\n" % config.VARS.dist)
# Get the default directory where to put the packages
src.ensure_path_exists(binpackage_path)
# Get the list of product installation to add to the archive
l_products_name = sorted(config.APPLICATION.products.keys())
- l_product_info = src.product.get_products_infos(l_products_name,
- config)
+ l_product_info = src.product.get_products_infos(l_products_name, config)
# first loop on products : filter products, analyse properties,
# and store the information that will be used to create the archive in the second loop
- l_not_installed=[] # store not installed products for warning at the end
+ l_not_installed = [] # store not installed products for warning at the end
for prod_name, prod_info in l_product_info:
# ignore the native and fixed products for install directories
- if (src.get_property_in_product_cfg(prod_info, "not_in_package") == "yes"
- or src.product.product_is_native(prod_info)
- or src.product.product_is_fixed(prod_info)
- or not src.product.product_compiles(prod_info)):
+ if (
+ src.get_property_in_product_cfg(prod_info, "not_in_package") == "yes"
+ or src.product.product_is_native(prod_info)
+ or src.product.product_is_fixed(prod_info)
+ or not src.product.product_compiles(prod_info)
+ ):
continue
if only_vcs and not src.product.product_is_vcs(prod_info):
continue
l_not_installed.append(prod_name)
continue # product is not installed, we skip it
# prepare call to make_bin_archive
- path_targz_prod = os.path.join(binpackage_path, prod_name + '-' + prod_info.version.replace("/", "_") + "-" + config.VARS.dist + PACKAGE_EXT)
- targz_prod = tarfile.open(path_targz_prod, mode='w:gz')
+ path_targz_prod = os.path.join(
+ binpackage_path,
+ prod_name
+ + "-"
+ + prod_info.version.replace("/", "_")
+ + "-"
+ + config.VARS.dist
+ + PACKAGE_EXT,
+ )
+ targz_prod = tarfile.open(path_targz_prod, mode="w:gz")
bin_path = prod_info.install_dir
targz_prod.add(bin_path)
targz_prod.close()
# Python program to find MD5 hash value of a file
import hashlib
- with open(path_targz_prod,"rb") as f:
- bytes = f.read() # read file as bytes
- readable_hash = hashlib.md5(bytes).hexdigest();
- with open(path_targz_prod+".md5", "w") as md5sum:
- md5sum.write("%s %s" % (readable_hash, os.path.basename(path_targz_prod)))
- logger.write(" archive : %s (md5sum = %s)\n" % (path_targz_prod, readable_hash))
+
+ with open(path_targz_prod, "rb") as f:
+ bytes = f.read() # read file as bytes
+ readable_hash = hashlib.md5(bytes).hexdigest()
+ with open(path_targz_prod + ".md5", "w") as md5sum:
+ md5sum.write(
+ "%s %s" % (readable_hash, os.path.basename(path_targz_prod))
+ )
+ logger.write(
+ " archive : %s (md5sum = %s)\n" % (path_targz_prod, readable_hash)
+ )
return 0
+
def binary_package(config, logger, options, tmp_working_dir):
- '''Prepare a dictionary that stores all the needed directories and files to
+ """Prepare a dictionary that stores all the needed directories and files to
add in a binary package.
:param config Config: The global configuration.
add in a binary package.
{label : (path_on_local_machine, path_in_archive)}
:rtype: dict
- '''
+ """
# Get the list of product installation to add to the archive
l_products_name = sorted(config.APPLICATION.products.keys())
- l_product_info = src.product.get_products_infos(l_products_name,
- config)
+ l_product_info = src.product.get_products_infos(l_products_name, config)
# suppress compile time products for binaries-only archives
if not options.sources:
l_not_installed = []
l_sources_not_present = []
generate_mesa_launcher = False # a flag to know if we generate a mesa launcher
- if ("APPLICATION" in config and
- "properties" in config.APPLICATION and
- "mesa_launcher_in_package" in config.APPLICATION.properties and
- config.APPLICATION.properties.mesa_launcher_in_package == "yes") :
- generate_mesa_launcher=True
+ if (
+ "APPLICATION" in config
+ and "properties" in config.APPLICATION
+ and "mesa_launcher_in_package" in config.APPLICATION.properties
+ and config.APPLICATION.properties.mesa_launcher_in_package == "yes"
+ ):
+ generate_mesa_launcher = True
# first loop on products : filter products, analyse properties,
# and store the information that will be used to create the archive in the second loop
# Add the sources of the products that have the property
# sources_in_package : "yes"
- if src.get_property_in_product_cfg(prod_info,
- "sources_in_package") == "yes":
+ if src.get_property_in_product_cfg(prod_info, "sources_in_package") == "yes":
if os.path.exists(prod_info.source_dir):
l_source_dir.append((prod_name, prod_info.source_dir))
else:
l_sources_not_present.append(prod_name)
# ignore the native and fixed products for install directories
- if (src.product.product_is_native(prod_info)
- or src.product.product_is_fixed(prod_info)
- or not src.product.product_compiles(prod_info)):
+ if (
+ src.product.product_is_native(prod_info)
+ or src.product.product_is_fixed(prod_info)
+ or not src.product.product_compiles(prod_info)
+ ):
continue
#
# products with single_dir property will be installed in the PRODUCTS directory of the archive
- is_single_dir=(src.appli_test_property(config,"single_install_dir", "yes") and \
- src.product.product_test_property(prod_info,"single_install_dir", "yes"))
+ is_single_dir = src.appli_test_property(
+ config, "single_install_dir", "yes"
+ ) and src.product.product_test_property(prod_info, "single_install_dir", "yes")
if src.product.check_installation(config, prod_info):
- l_install_dir.append((prod_name, prod_info.name, prod_info.install_dir,
- is_single_dir, prod_info.install_mode))
+ l_install_dir.append(
+ (
+ prod_name,
+ prod_info.name,
+ prod_info.install_dir,
+ is_single_dir,
+ prod_info.install_mode,
+ )
+ )
else:
l_not_installed.append(prod_name)
if src.product.product_is_cpp(prod_info):
# cpp module
for name_cpp in src.product.get_product_components(prod_info):
- install_dir = os.path.join(config.APPLICATION.workdir,
- config.INTERNAL.config.install_dir,
- name_cpp)
+ install_dir = os.path.join(
+ config.APPLICATION.workdir,
+ config.INTERNAL.config.install_dir,
+ name_cpp,
+ )
if os.path.exists(install_dir):
- l_install_dir.append((name_cpp, name_cpp, install_dir, False, "value"))
+ l_install_dir.append(
+ (name_cpp, name_cpp, install_dir, False, "value")
+ )
else:
l_not_installed.append(name_cpp)
# check the name of the directory that (could) contains the binaries
# from previous detar
binaries_from_detar = os.path.join(
- config.APPLICATION.workdir,
- config.INTERNAL.config.binary_dir + config.VARS.dist)
+ config.APPLICATION.workdir, config.INTERNAL.config.binary_dir + config.VARS.dist
+ )
if os.path.exists(binaries_from_detar):
- logger.write("""
+ logger.write(
+ """
WARNING: existing binaries directory from previous detar installation:
%s
To make new package from this, you have to:
2) or recompile everything in INSTALL with "sat compile" command
this step is long, and requires some linux packages to be installed
on your system\n
-""" % binaries_from_detar)
+"""
+ % binaries_from_detar
+ )
# Print warning or error if there are some missing products
if len(l_not_installed) > 0:
text_missing_prods += " - " + p_name + "\n"
if not options.force_creation:
msg = _("ERROR: there are missing product installations:")
- logger.write("%s\n%s" % (src.printcolors.printcError(msg),
- text_missing_prods),
- 1)
+ logger.write(
+ "%s\n%s" % (src.printcolors.printcError(msg), text_missing_prods), 1
+ )
raise src.SatException(msg)
else:
msg = _("WARNING: there are missing products installations:")
- logger.write("%s\n%s" % (src.printcolors.printcWarning(msg),
- text_missing_prods),
- 1)
+ logger.write(
+ "%s\n%s" % (src.printcolors.printcWarning(msg), text_missing_prods), 1
+ )
# Do the same for sources
if len(l_sources_not_present) > 0:
text_missing_prods += "-" + p_name + "\n"
if not options.force_creation:
msg = _("ERROR: there are missing product sources:")
- logger.write("%s\n%s" % (src.printcolors.printcError(msg),
- text_missing_prods),
- 1)
+ logger.write(
+ "%s\n%s" % (src.printcolors.printcError(msg), text_missing_prods), 1
+ )
raise src.SatException(msg)
else:
msg = _("WARNING: there are missing products sources:")
- logger.write("%s\n%s" % (src.printcolors.printcWarning(msg),
- text_missing_prods),
- 1)
+ logger.write(
+ "%s\n%s" % (src.printcolors.printcWarning(msg), text_missing_prods), 1
+ )
# construct the name of the directory that will contain the binaries
if src.architecture.is_windows():
# construct the correlation table between the product names, there
# actual install directories and there install directory in archive
d_products = {}
- for prod_name, prod_info_name, install_dir, is_single_dir, install_mode in l_install_dir:
- prod_base_name=os.path.basename(install_dir)
+ for (
+ prod_name,
+ prod_info_name,
+ install_dir,
+ is_single_dir,
+ install_mode,
+ ) in l_install_dir:
+ prod_base_name = os.path.basename(install_dir)
if install_mode == "base":
# case of a products installed in base.
# because the archive is in base:no mode, the name of the install dir is different inside archive
# we set it to the product name or by PRODUCTS if single-dir
if is_single_dir:
- prod_base_name=config.INTERNAL.config.single_install_dir
+ prod_base_name = config.INTERNAL.config.single_install_dir
else:
- prod_base_name=prod_info_name
+ prod_base_name = prod_info_name
path_in_archive = os.path.join(binaries_dir_name, prod_base_name)
d_products[prod_name + " (bin)"] = (install_dir, path_in_archive)
path_in_archive = os.path.join("SOURCES", prod_name)
d_products[prod_name + " (sources)"] = (source_dir, path_in_archive)
- # create an archives of compilation logs, and insert it into the tarball
- logpath=os.path.join(config.APPLICATION.workdir, "LOGS")
+ # create an archives of compilation logs, and insert it into the tarball
+ logpath = os.path.join(config.APPLICATION.workdir, "LOGS")
path_targz_logs = os.path.join(tmp_working_dir, "logs.tgz")
- tar_log = tarfile.open(path_targz_logs, mode='w:gz')
+ tar_log = tarfile.open(path_targz_logs, mode="w:gz")
tar_log.add(logpath, arcname="LOGS")
tar_log.close()
d_products["LOGS"] = (path_targz_logs, "logs.tgz")
# for packages of SALOME applications including KERNEL,
# we produce a salome launcher or a virtual application (depending on salome version)
- if 'KERNEL' in config.APPLICATION.products:
+ if "KERNEL" in config.APPLICATION.products:
VersionSalome = src.get_salome_version(config)
# Case where SALOME has the launcher that uses the SalomeContext API
- if VersionSalome >= MMP([7,3,0]):
+ if VersionSalome >= MMP([7, 3, 0]):
# create the relative launcher and add it to the files to add
launcher_name = src.get_launcher_name(config)
- launcher_package = produce_relative_launcher(config,
- logger,
- tmp_working_dir,
- launcher_name,
- binaries_dir_name)
+ launcher_package = produce_relative_launcher(
+ config, logger, tmp_working_dir, launcher_name, binaries_dir_name
+ )
d_products["launcher"] = (launcher_package, launcher_name)
# if the application contains mesa products, we generate in addition to the
# classical salome launcher a launcher using mesa and called mesa_salome
# (the mesa launcher will be used for remote usage through ssh).
if generate_mesa_launcher:
- #if there is one : store the use_mesa property
- restore_use_mesa_option=None
- if ('properties' in config.APPLICATION and
- 'use_mesa' in config.APPLICATION.properties):
+ # if there is one : store the use_mesa property
+ restore_use_mesa_option = None
+ if (
+ "properties" in config.APPLICATION
+ and "use_mesa" in config.APPLICATION.properties
+ ):
restore_use_mesa_option = config.APPLICATION.properties.use_mesa
# activate mesa property, and generate a mesa launcher
- src.activate_mesa_property(config) #activate use_mesa property
- launcher_mesa_name="mesa_"+launcher_name
- launcher_package_mesa = produce_relative_launcher(config,
- logger,
- tmp_working_dir,
- launcher_mesa_name,
- binaries_dir_name)
- d_products["launcher (mesa)"] = (launcher_package_mesa, launcher_mesa_name)
+ src.activate_mesa_property(config) # activate use_mesa property
+ launcher_mesa_name = "mesa_" + launcher_name
+ launcher_package_mesa = produce_relative_launcher(
+ config,
+ logger,
+ tmp_working_dir,
+ launcher_mesa_name,
+ binaries_dir_name,
+ )
+ d_products["launcher (mesa)"] = (
+ launcher_package_mesa,
+ launcher_mesa_name,
+ )
# if there was a use_mesa value, we restore it
# else we set it to the default value "no"
if restore_use_mesa_option != None:
- config.APPLICATION.properties.use_mesa=restore_use_mesa_option
+ config.APPLICATION.properties.use_mesa = restore_use_mesa_option
else:
- config.APPLICATION.properties.use_mesa="no"
+ config.APPLICATION.properties.use_mesa = "no"
if options.sources:
# if we mix binaries and sources, we add a copy of the launcher,
# prefixed with "bin",in order to avoid clashes
- launcher_copy_name="bin"+launcher_name
- launcher_package_copy = produce_relative_launcher(config,
- logger,
- tmp_working_dir,
- launcher_copy_name,
- binaries_dir_name)
- d_products["launcher (copy)"] = (launcher_package_copy, launcher_copy_name)
+ launcher_copy_name = "bin" + launcher_name
+ launcher_package_copy = produce_relative_launcher(
+ config,
+ logger,
+ tmp_working_dir,
+ launcher_copy_name,
+ binaries_dir_name,
+ )
+ d_products["launcher (copy)"] = (
+ launcher_package_copy,
+ launcher_copy_name,
+ )
else:
# Provide a script for the creation of an application EDF style
- appli_script = product_appli_creation_script(config,
- logger,
- tmp_working_dir,
- binaries_dir_name)
+ appli_script = product_appli_creation_script(
+ config, logger, tmp_working_dir, binaries_dir_name
+ )
d_products["appli script"] = (appli_script, "create_appli.py")
# Put also the environment file
- env_file = produce_relative_env_files(config,
- logger,
- tmp_working_dir,
- binaries_dir_name)
+ env_file = produce_relative_env_files(
+ config, logger, tmp_working_dir, binaries_dir_name
+ )
if src.architecture.is_windows():
- filename = "env_launch.bat"
+ filename = "env_launch.bat"
else:
- filename = "env_launch.sh"
+ filename = "env_launch.sh"
d_products["environment file"] = (env_file, filename)
# If option exe, produce an extra launcher based on specified exe
if options.exe:
- exe_file = produce_relative_env_files(config,
- logger,
- tmp_working_dir,
- binaries_dir_name,
- options.exe)
+ exe_file = produce_relative_env_files(
+ config, logger, tmp_working_dir, binaries_dir_name, options.exe
+ )
if src.architecture.is_windows():
- filename = os.path.basename(options.exe) + ".bat"
+ filename = os.path.basename(options.exe) + ".bat"
else:
- filename = os.path.basename(options.exe) + ".sh"
+ filename = os.path.basename(options.exe) + ".sh"
d_products["exe file"] = (exe_file, filename)
-
return d_products
+
def source_package(sat, config, logger, options, tmp_working_dir):
- '''Prepare a dictionary that stores all the needed directories and files to
+ """Prepare a dictionary that stores all the needed directories and files to
add in a source package.
:param config Config: The global configuration.
add in a source package.
{label : (path_on_local_machine, path_in_archive)}
:rtype: dict
- '''
+ """
- d_archives={}
+ d_archives = {}
# Get all the products that are prepared using an archive
# unless ftp mode is specified (in this case the user of the
# archive will get the sources through the ftp mode of sat prepare
# Make archives with the products that are not prepared using an archive
# (git, cvs, svn, etc)
logger.write("Construct archives for vcs products ... ")
- d_archives_vcs = get_archives_vcs(l_pinfo_vcs,
- sat,
- config,
- logger,
- tmp_working_dir)
+ d_archives_vcs = get_archives_vcs(
+ l_pinfo_vcs, sat, config, logger, tmp_working_dir
+ )
logger.write("Done\n")
# Create a project
logger.write("Create the project ... ")
- d_project = create_project_for_src_package(config,
- tmp_working_dir,
- options.with_vcs,
- options.ftp)
+ d_project = create_project_for_src_package(
+ config, tmp_working_dir, options.with_vcs, options.ftp
+ )
logger.write("Done\n")
# Add salomeTools
tmp_sat = add_salomeTools(config, tmp_working_dir)
- d_sat = {"salomeTools" : (tmp_sat, "sat")}
+ d_sat = {"salomeTools": (tmp_sat, "sat")}
# Add a sat symbolic link if not win
if not src.architecture.is_windows():
os.symlink("../ARCHIVES", "ARCHIVES")
os.chdir(t)
- d_sat["sat archive link"] = (os.path.join(tmp_working_dir,"PROJECT", "ARCHIVES"),
- os.path.join("PROJECT", "ARCHIVES"))
+ d_sat["sat archive link"] = (
+ os.path.join(tmp_working_dir, "PROJECT", "ARCHIVES"),
+ os.path.join("PROJECT", "ARCHIVES"),
+ )
d_source = src.merge_dicts(d_archives, d_archives_vcs, d_project, d_sat)
return d_source
+
def get_archives(config, logger):
- '''Find all the products that are get using an archive and all the products
+ """Find all the products that are get using an archive and all the products
that are get using a vcs (git, cvs, svn) repository.
:param config Config: The global configuration.
and the list of specific configuration corresponding to the vcs
products
:rtype: (Dict, List)
- '''
+ """
# Get the list of product informations
l_products_name = config.APPLICATION.products.keys()
- l_product_info = src.product.get_products_infos(l_products_name,
- config)
+ l_product_info = src.product.get_products_infos(l_products_name, config)
d_archives = {}
l_pinfo_vcs = []
for p_name, p_info in l_product_info:
if src.get_property_in_product_cfg(p_info, "not_in_package") == "yes":
continue
# ignore the native and fixed products
- if (src.product.product_is_native(p_info)
- or src.product.product_is_fixed(p_info)):
+ if src.product.product_is_native(p_info) or src.product.product_is_fixed(
+ p_info
+ ):
continue
if p_info.get_source == "archive":
archive_path = p_info.archive_info.archive_name
archive_name = os.path.basename(archive_path)
- d_archives[p_name] = (archive_path,
- os.path.join(ARCHIVE_DIR, archive_name))
- if (src.appli_test_property(config,"pip", "yes") and
- src.product.product_test_property(p_info,"pip", "yes")):
+ d_archives[p_name] = (archive_path, os.path.join(ARCHIVE_DIR, archive_name))
+ if src.appli_test_property(
+ config, "pip", "yes"
+ ) and src.product.product_test_property(p_info, "pip", "yes"):
# if pip mode is activated, and product is managed by pip
- pip_wheels_dir=os.path.join(config.LOCAL.archive_dir,"wheels")
- if "archive_prefix" in p_info.archive_info and p_info.archive_info.archive_prefix:
- pip_wheel_pattern=os.path.join(pip_wheels_dir,
- "%s-%s*" % (p_info.archive_info.archive_prefix, p_info.version))
+ pip_wheels_dir = os.path.join(config.LOCAL.archive_dir, "wheels")
+ if (
+ "archive_prefix" in p_info.archive_info
+ and p_info.archive_info.archive_prefix
+ ):
+ pip_wheel_pattern = os.path.join(
+ pip_wheels_dir,
+ "%s-%s*" % (p_info.archive_info.archive_prefix, p_info.version),
+ )
else:
- pip_wheel_pattern=os.path.join(pip_wheels_dir,
- "%s-%s*" % (p_info.name, p_info.version))
- pip_wheel_path=glob.glob(pip_wheel_pattern)
- msg_pip_not_found="Error in get_archive, pip wheel for "\
- "product %s-%s was not found in %s directory"
- msg_pip_two_or_more="Error in get_archive, several pip wheels for "\
- "product %s-%s were found in %s directory"
- if len(pip_wheel_path)==0:
- raise src.SatException(msg_pip_not_found %\
- (p_info.name, p_info.version, pip_wheels_dir))
- if len(pip_wheel_path)>1:
- raise src.SatException(msg_pip_two_or_more %\
- (p_info.name, p_info.version, pip_wheels_dir))
-
- pip_wheel_name=os.path.basename(pip_wheel_path[0])
- d_archives[p_name+" (pip wheel)"]=(pip_wheel_path[0],
- os.path.join(ARCHIVE_DIR, "wheels", pip_wheel_name))
+ pip_wheel_pattern = os.path.join(
+ pip_wheels_dir, "%s-%s*" % (p_info.name, p_info.version)
+ )
+ pip_wheel_path = glob.glob(pip_wheel_pattern)
+ msg_pip_not_found = (
+ "Error in get_archive, pip wheel for "
+ "product %s-%s was not found in %s directory"
+ )
+ msg_pip_two_or_more = (
+ "Error in get_archive, several pip wheels for "
+ "product %s-%s were found in %s directory"
+ )
+ if len(pip_wheel_path) == 0:
+ raise src.SatException(
+ msg_pip_not_found
+ % (p_info.name, p_info.version, pip_wheels_dir)
+ )
+ if len(pip_wheel_path) > 1:
+ raise src.SatException(
+ msg_pip_two_or_more
+ % (p_info.name, p_info.version, pip_wheels_dir)
+ )
+
+ pip_wheel_name = os.path.basename(pip_wheel_path[0])
+ d_archives[p_name + " (pip wheel)"] = (
+ pip_wheel_path[0],
+ os.path.join(ARCHIVE_DIR, "wheels", pip_wheel_name),
+ )
else:
# this product is not managed by archive,
# an archive of the vcs directory will be created by get_archive_vcs
return d_archives, l_pinfo_vcs
+
def add_salomeTools(config, tmp_working_dir):
- '''Prepare a version of salomeTools that has a specific local.pyconf file
+ """Prepare a version of salomeTools that has a specific local.pyconf file
configured for a source package.
:param config Config: The global configuration.
source package
:return: The path to the local salomeTools directory to add in the package
:rtype: str
- '''
+ """
# Copy sat in the temporary working directory
sat_tmp_path = src.Path(os.path.join(tmp_working_dir, "salomeTools"))
sat_running_path = src.Path(config.VARS.salometoolsway)
files_or_dir_SAT = os.listdir(os.path.join(tmp_working_dir, "salomeTools"))
for file_or_dir in files_or_dir_SAT:
if file_or_dir.endswith(".pyconf") or file_or_dir.endswith(".txt"):
- file_path = os.path.join(tmp_working_dir,
- "salomeTools",
- file_or_dir)
+ file_path = os.path.join(tmp_working_dir, "salomeTools", file_or_dir)
os.remove(file_path)
ff = open(local_pyconf_file, "w")
return sat_tmp_path.path
+
def get_archives_vcs(l_pinfo_vcs, sat, config, logger, tmp_working_dir):
- '''For sources package that require that all products are get using an
+ """For sources package that require that all products are get using an
archive, one has to create some archive for the vcs products.
So this method calls the clean and source command of sat and then create
the archives.
:return: the dictionary that stores all the archives to add in the source
package. {label : (path_on_local_machine, path_in_archive)}
:rtype: dict
- '''
+ """
# clean the source directory of all the vcs products, then use the source
# command and thus construct an archive that will not contain the patches
l_prod_names = [pn for pn, __ in l_pinfo_vcs]
- if False: # clean is dangerous in user/SOURCES, fixed in tmp_local_working_dir
- logger.write(_("\nclean sources\n"))
- args_clean = config.VARS.application
- args_clean += " --sources --products "
- args_clean += ",".join(l_prod_names)
- logger.write("WARNING: get_archives_vcs clean\n '%s'\n" % args_clean, 1)
- sat.clean(args_clean, batch=True, verbose=0, logger_add_link = logger)
+ if False: # clean is dangerous in user/SOURCES, fixed in tmp_local_working_dir
+ logger.write(_("\nclean sources\n"))
+ args_clean = config.VARS.application
+ args_clean += " --sources --products "
+ args_clean += ",".join(l_prod_names)
+ logger.write("WARNING: get_archives_vcs clean\n '%s'\n" % args_clean, 1)
+ sat.clean(args_clean, batch=True, verbose=0, logger_add_link=logger)
if True:
- # source
- logger.write(_("get sources\n"))
- args_source = config.VARS.application
- args_source += " --products "
- args_source += ",".join(l_prod_names)
- svgDir = sat.cfg.APPLICATION.workdir
- tmp_local_working_dir = os.path.join(sat.cfg.APPLICATION.workdir, "tmp_package") # to avoid too much big files in /tmp
- sat.cfg.APPLICATION.workdir = tmp_local_working_dir
- # DBG.write("SSS sat config.APPLICATION.workdir", sat.cfg.APPLICATION, True)
- # DBG.write("sat config id", id(sat.cfg), True)
- # shit as config is not same id() as for sat.source()
- # sat.source(args_source, batch=True, verbose=5, logger_add_link = logger)
- import source
- source.run(args_source, sat, logger) #use this mode as runner.cfg reference
-
- # make the new archives
- d_archives_vcs = {}
- for pn, pinfo in l_pinfo_vcs:
- path_archive = make_archive(pn, pinfo, tmp_local_working_dir)
- logger.write("make archive vcs '%s'\n" % path_archive)
- d_archives_vcs[pn] = (path_archive,
- os.path.join(ARCHIVE_DIR, pn + ".tgz"))
- sat.cfg.APPLICATION.workdir = svgDir
- # DBG.write("END sat config", sat.cfg.APPLICATION, True)
+ # source
+ logger.write(_("get sources\n"))
+ args_source = config.VARS.application
+ args_source += " --products "
+ args_source += ",".join(l_prod_names)
+ svgDir = sat.cfg.APPLICATION.workdir
+ tmp_local_working_dir = os.path.join(
+ sat.cfg.APPLICATION.workdir, "tmp_package"
+ ) # to avoid too much big files in /tmp
+ sat.cfg.APPLICATION.workdir = tmp_local_working_dir
+ # DBG.write("SSS sat config.APPLICATION.workdir", sat.cfg.APPLICATION, True)
+ # DBG.write("sat config id", id(sat.cfg), True)
+ # shit as config is not same id() as for sat.source()
+ # sat.source(args_source, batch=True, verbose=5, logger_add_link = logger)
+ import source
+
+ source.run(args_source, sat, logger) # use this mode as runner.cfg reference
+
+ # make the new archives
+ d_archives_vcs = {}
+ for pn, pinfo in l_pinfo_vcs:
+ path_archive = make_archive(pn, pinfo, tmp_local_working_dir)
+ logger.write("make archive vcs '%s'\n" % path_archive)
+ d_archives_vcs[pn] = (path_archive, os.path.join(ARCHIVE_DIR, pn + ".tgz"))
+ sat.cfg.APPLICATION.workdir = svgDir
+ # DBG.write("END sat config", sat.cfg.APPLICATION, True)
return d_archives_vcs
+
def make_bin_archive(prod_name, prod_info, where):
- '''Create an archive of a product by searching its source directory.
+ """Create an archive of a product by searching its source directory.
:param prod_name str: The name of the product.
:param prod_info Config: The specific configuration corresponding to the
archive
:return: The path of the resulting archive
:rtype: str
- '''
+ """
path_targz_prod = os.path.join(where, prod_name + PACKAGE_EXT)
- tar_prod = tarfile.open(path_targz_prod, mode='w:gz')
+ tar_prod = tarfile.open(path_targz_prod, mode="w:gz")
bin_path = prod_info.install_dir
tar_prod.add(bin_path, arcname=path_targz_prod)
tar_prod.close()
return path_targz_prod
+
def make_archive(prod_name, prod_info, where):
- '''Create an archive of a product by searching its source directory.
+ """Create an archive of a product by searching its source directory.
:param prod_name str: The name of the product.
:param prod_info Config: The specific configuration corresponding to the
archive
:return: The path of the resulting archive
:rtype: str
- '''
+ """
path_targz_prod = os.path.join(where, prod_name + PACKAGE_EXT)
- tar_prod = tarfile.open(path_targz_prod, mode='w:gz')
+ tar_prod = tarfile.open(path_targz_prod, mode="w:gz")
local_path = prod_info.source_dir
if old_python:
- tar_prod.add(local_path,
- arcname=prod_name,
- exclude=exclude_VCS_and_extensions_26)
+ tar_prod.add(
+ local_path, arcname=prod_name, exclude=exclude_VCS_and_extensions_26
+ )
else:
- tar_prod.add(local_path,
- arcname=prod_name,
- filter=exclude_VCS_and_extensions)
+ tar_prod.add(local_path, arcname=prod_name, filter=exclude_VCS_and_extensions)
tar_prod.close()
return path_targz_prod
+
def create_project_for_src_package(config, tmp_working_dir, with_vcs, with_ftp):
- '''Create a specific project for a source package.
+ """Create a specific project for a source package.
:param config Config: The global configuration.
:param tmp_working_dir str: The temporary local directory containing some
:return: The dictionary
{"project" : (produced project, project path in the archive)}
:rtype: Dict
- '''
+ """
# Create in the working temporary directory the full project tree
project_tmp_dir = os.path.join(tmp_working_dir, PROJECT_DIR)
- products_pyconf_tmp_dir = os.path.join(project_tmp_dir,
- "products")
- compil_scripts_tmp_dir = os.path.join(project_tmp_dir,
- "products",
- "compil_scripts")
- post_scripts_tmp_dir = os.path.join(project_tmp_dir,
- "products",
- "post_scripts")
- env_scripts_tmp_dir = os.path.join(project_tmp_dir,
- "products",
- "env_scripts")
- patches_tmp_dir = os.path.join(project_tmp_dir,
- "products",
- "patches")
- application_tmp_dir = os.path.join(project_tmp_dir,
- "applications")
- for directory in [project_tmp_dir,
- compil_scripts_tmp_dir,
- env_scripts_tmp_dir,
- post_scripts_tmp_dir,
- patches_tmp_dir,
- application_tmp_dir]:
+ products_pyconf_tmp_dir = os.path.join(project_tmp_dir, "products")
+ compil_scripts_tmp_dir = os.path.join(project_tmp_dir, "products", "compil_scripts")
+ post_scripts_tmp_dir = os.path.join(project_tmp_dir, "products", "post_scripts")
+ env_scripts_tmp_dir = os.path.join(project_tmp_dir, "products", "env_scripts")
+ patches_tmp_dir = os.path.join(project_tmp_dir, "products", "patches")
+ application_tmp_dir = os.path.join(project_tmp_dir, "applications")
+ for directory in [
+ project_tmp_dir,
+ compil_scripts_tmp_dir,
+ env_scripts_tmp_dir,
+ post_scripts_tmp_dir,
+ patches_tmp_dir,
+ application_tmp_dir,
+ ]:
src.ensure_path_exists(directory)
# Create the pyconf that contains the information of the project
ff = open(project_pyconf_file, "w")
ff.write(PROJECT_TEMPLATE)
if with_ftp and len(config.PATHS.ARCHIVEFTP) > 0:
- ftp_path='ARCHIVEFTP : "'+config.PATHS.ARCHIVEFTP[0]
+ ftp_path = 'ARCHIVEFTP : "' + config.PATHS.ARCHIVEFTP[0]
for ftpserver in config.PATHS.ARCHIVEFTP[1:]:
- ftp_path=ftp_path+":"+ftpserver
- ftp_path+='"'
+ ftp_path = ftp_path + ":" + ftpserver
+ ftp_path += '"'
ff.write("# ftp servers where to search for prerequisite archives\n")
ff.write(ftp_path)
# add licence paths if any
if len(config.PATHS.LICENCEPATH) > 0:
- licence_path='LICENCEPATH : "'+config.PATHS.LICENCEPATH[0]
+ licence_path = 'LICENCEPATH : "' + config.PATHS.LICENCEPATH[0]
for path in config.PATHS.LICENCEPATH[1:]:
- licence_path=licence_path+":"+path
- licence_path+='"'
+ licence_path = licence_path + ":" + path
+ licence_path += '"'
ff.write("\n# Where to search for licences\n")
ff.write(licence_path)
-
ff.close()
# Loop over the products to get there pyconf and all the scripts
# skip product with property not_in_package set to yes
if src.get_property_in_product_cfg(p_info, "not_in_package") == "yes":
continue
- find_product_scripts_and_pyconf(p_name,
- p_info,
- config,
- with_vcs,
- compil_scripts_tmp_dir,
- env_scripts_tmp_dir,
- post_scripts_tmp_dir,
- patches_tmp_dir,
- products_pyconf_tmp_dir)
+ find_product_scripts_and_pyconf(
+ p_name,
+ p_info,
+ config,
+ with_vcs,
+ compil_scripts_tmp_dir,
+ env_scripts_tmp_dir,
+ post_scripts_tmp_dir,
+ patches_tmp_dir,
+ products_pyconf_tmp_dir,
+ )
# for the application pyconf, we write directly the config
# don't search for the original pyconf file
# to avoid problems with overwrite sections and rm_products key
write_application_pyconf(config, application_tmp_dir)
- d_project = {"project" : (project_tmp_dir, PROJECT_DIR )}
+ d_project = {"project": (project_tmp_dir, PROJECT_DIR)}
return d_project
-def find_product_scripts_and_pyconf(p_name,
- p_info,
- config,
- with_vcs,
- compil_scripts_tmp_dir,
- env_scripts_tmp_dir,
- post_scripts_tmp_dir,
- patches_tmp_dir,
- products_pyconf_tmp_dir):
- '''Create a specific pyconf file for a given product. Get its environment
+
+def find_product_scripts_and_pyconf(
+ p_name,
+ p_info,
+ config,
+ with_vcs,
+ compil_scripts_tmp_dir,
+ env_scripts_tmp_dir,
+ post_scripts_tmp_dir,
+ patches_tmp_dir,
+ products_pyconf_tmp_dir,
+):
+ """Create a specific pyconf file for a given product. Get its environment
script, its compilation script and patches and put it in the temporary
working directory. This method is used in the source package in order to
construct the specific project.
directory of the project.
:param products_pyconf_tmp_dir str: The path to the temporary product
scripts directory of the project.
- '''
+ """
# read the pyconf of the product
product_pyconf_cfg = src.pyconf.Config(p_info.from_file)
# in non vcs mode, if the product is not archive, then make it become archive.
# depending upon the incremental mode, select impacted sections
- if "properties" in p_info and "incremental" in p_info.properties and\
- p_info.properties.incremental == "yes":
- sections = ["default", "default_win", p_info.section, p_info.section+"_win"]
+ if (
+ "properties" in p_info
+ and "incremental" in p_info.properties
+ and p_info.properties.incremental == "yes"
+ ):
+ sections = [
+ "default",
+ "default_win",
+ p_info.section,
+ p_info.section + "_win",
+ ]
else:
sections = [p_info.section]
for section in sections:
- if section in product_pyconf_cfg and "get_source" in product_pyconf_cfg[section]:
- DBG.write("sat package set archive mode to archive for product %s and section %s" %\
- (p_name,section))
+ if (
+ section in product_pyconf_cfg
+ and "get_source" in product_pyconf_cfg[section]
+ ):
+ DBG.write(
+ "sat package set archive mode to archive for product %s and section %s"
+ % (p_name, section)
+ )
product_pyconf_cfg[section].get_source = "archive"
if not "archive_info" in product_pyconf_cfg[section]:
- product_pyconf_cfg[section].addMapping("archive_info",
- src.pyconf.Mapping(product_pyconf_cfg),
- "")
- product_pyconf_cfg[section].archive_info.archive_name =\
+ product_pyconf_cfg[section].addMapping(
+ "archive_info", src.pyconf.Mapping(product_pyconf_cfg), ""
+ )
+ product_pyconf_cfg[section].archive_info.archive_name = (
p_info.name + ".tgz"
+ )
# save git repositories for vcs products, even if archive is not in VCS mode
# in this case the user will be able to change get_source flag and work with git
if "git_info" in product_pyconf_cfg[section]:
for repo in product_pyconf_cfg[section].git_info:
if repo in p_info.git_info:
- product_pyconf_cfg[section].git_info[repo] = p_info.git_info[repo]
+ product_pyconf_cfg[section].git_info[repo] = p_info.git_info[
+ repo
+ ]
# write the pyconf file to the temporary project location
- product_tmp_pyconf_path = os.path.join(products_pyconf_tmp_dir,
- p_name + ".pyconf")
- ff = open(product_tmp_pyconf_path, 'w')
+ product_tmp_pyconf_path = os.path.join(products_pyconf_tmp_dir, p_name + ".pyconf")
+ ff = open(product_tmp_pyconf_path, "w")
ff.write("#!/usr/bin/env python\n#-*- coding:utf-8 -*-\n\n")
product_pyconf_cfg.__save__(ff, 1)
ff.close()
def write_application_pyconf(config, application_tmp_dir):
- '''Write the application pyconf file in the specific temporary
+ """Write the application pyconf file in the specific temporary
directory containing the specific project of a source package.
:param config Config: The global configuration.
:param application_tmp_dir str: The path to the temporary application
scripts directory of the project.
- '''
+ """
application_name = config.VARS.application
# write the pyconf file to the temporary application location
- application_tmp_pyconf_path = os.path.join(application_tmp_dir,
- application_name + ".pyconf")
- with open(application_tmp_pyconf_path, 'w') as f:
+ application_tmp_pyconf_path = os.path.join(
+ application_tmp_dir, application_name + ".pyconf"
+ )
+ with open(application_tmp_pyconf_path, "w") as f:
f.write("#!/usr/bin/env python\n#-*- coding:utf-8 -*-\n\n")
res = src.pyconf.Config()
app = src.pyconf.deepCopyMapping(config.APPLICATION)
app.base = "no"
# Change the workdir
- app.workdir = src.pyconf.Reference(
- app,
- src.pyconf.DOLLAR,
- 'LOCAL.workdir')
+ app.workdir = src.pyconf.Reference(app, src.pyconf.DOLLAR, "LOCAL.workdir")
res.addMapping("APPLICATION", app, "")
res.__save__(f, evaluated=False)
def sat_package(config, tmp_working_dir, options, logger):
- '''Prepare a dictionary that stores all the needed directories and files to
+ """Prepare a dictionary that stores all the needed directories and files to
add in a salomeTool package.
:param tmp_working_dir str: The temporary local working directory
add in a salomeTool package.
{label : (path_on_local_machine, path_in_archive)}
:rtype: dict
- '''
+ """
d_project = {}
# we include sat himself
- d_project["all_sat"]=(config.VARS.salometoolsway, "")
+ d_project["all_sat"] = (config.VARS.salometoolsway, "")
# and we overwrite local.pyconf with a clean wersion.
local_pyconf_tmp_path = os.path.join(tmp_working_dir, "local.pyconf")
local_file_path = os.path.join(config.VARS.datadir, "local.pyconf")
local_cfg = src.pyconf.Config(local_file_path)
- local_cfg.PROJECTS.project_file_paths=src.pyconf.Sequence(local_cfg.PROJECTS)
+ local_cfg.PROJECTS.project_file_paths = src.pyconf.Sequence(local_cfg.PROJECTS)
local_cfg.LOCAL["base"] = "default"
local_cfg.LOCAL["workdir"] = "default"
local_cfg.LOCAL["log_dir"] = "default"
# if the archive contains a project, we write its relative path in local.pyconf
if options.project:
- project_arch_path = os.path.join("projects", options.project,
- os.path.basename(options.project_file_path))
+ project_arch_path = os.path.join(
+ "projects", options.project, os.path.basename(options.project_file_path)
+ )
local_cfg.PROJECTS.project_file_paths.append(project_arch_path, "")
- ff = open(local_pyconf_tmp_path, 'w')
+ ff = open(local_pyconf_tmp_path, "w")
local_cfg.__save__(ff, 1)
ff.close()
- d_project["local.pyconf"]=(local_pyconf_tmp_path, "data/local.pyconf")
+ d_project["local.pyconf"] = (local_pyconf_tmp_path, "data/local.pyconf")
return d_project
-def project_package(config, name_project, project_file_path, ftp_mode, tmp_working_dir, embedded_in_sat, logger):
- '''Prepare a dictionary that stores all the needed directories and files to
+def project_package(
+ config,
+ name_project,
+ project_file_path,
+ ftp_mode,
+ tmp_working_dir,
+ embedded_in_sat,
+ logger,
+):
+ """Prepare a dictionary that stores all the needed directories and files to
add in a project package.
:param project_file_path str: The path to the local project.
add in a project package.
{label : (path_on_local_machine, path_in_archive)}
:rtype: dict
- '''
+ """
d_project = {}
# Read the project file and get the directories to add to the package
try:
- project_pyconf_cfg = config.PROJECTS.projects.__getattr__(name_project)
+ project_pyconf_cfg = config.PROJECTS.projects.__getattr__(name_project)
except:
- logger.write("""
-WARNING: inexisting config.PROJECTS.projects.%s, try to read now from:\n%s\n""" % (name_project, project_file_path))
- project_pyconf_cfg = src.pyconf.Config(project_file_path)
- project_pyconf_cfg.PWD = os.path.dirname(project_file_path)
-
- paths = {"APPLICATIONPATH" : "applications",
- "PRODUCTPATH" : "products",
- "JOBPATH" : "jobs",
- "MACHINEPATH" : "machines"}
+ logger.write(
+ """
+WARNING: inexisting config.PROJECTS.projects.%s, try to read now from:\n%s\n"""
+ % (name_project, project_file_path)
+ )
+ project_pyconf_cfg = src.pyconf.Config(project_file_path)
+ project_pyconf_cfg.PWD = os.path.dirname(project_file_path)
+
+ paths = {
+ "APPLICATIONPATH": "applications",
+ "PRODUCTPATH": "products",
+ "JOBPATH": "jobs",
+ "MACHINEPATH": "machines",
+ }
if not ftp_mode:
paths["ARCHIVEPATH"] = "archives"
continue
if embedded_in_sat:
dest_path = os.path.join("projects", name_project, paths[path])
- project_file_dest = os.path.join("projects", name_project, project_file_name)
+ project_file_dest = os.path.join(
+ "projects", name_project, project_file_name
+ )
else:
dest_path = paths[path]
project_file_dest = project_file_name
# Modify the value of the path in the package
project_pyconf_cfg[path] = src.pyconf.Reference(
- project_pyconf_cfg,
- src.pyconf.DOLLAR,
- 'project_path + "/' + paths[path] + '"')
+ project_pyconf_cfg,
+ src.pyconf.DOLLAR,
+ 'project_path + "/' + paths[path] + '"',
+ )
# Modify some values
if "project_path" not in project_pyconf_cfg:
- project_pyconf_cfg.addMapping("project_path",
- src.pyconf.Mapping(project_pyconf_cfg),
- "")
- project_pyconf_cfg.project_path = src.pyconf.Reference(project_pyconf_cfg,
- src.pyconf.DOLLAR,
- 'PWD')
+ project_pyconf_cfg.addMapping(
+ "project_path", src.pyconf.Mapping(project_pyconf_cfg), ""
+ )
+ project_pyconf_cfg.project_path = src.pyconf.Reference(
+ project_pyconf_cfg, src.pyconf.DOLLAR, "PWD"
+ )
# we don't want to export these two fields
project_pyconf_cfg.__delitem__("file_path")
project_pyconf_cfg.__delitem__("PWD")
# Write the project pyconf file
project_pyconf_tmp_path = os.path.join(tmp_working_dir, project_file_name)
- ff = open(project_pyconf_tmp_path, 'w')
+ ff = open(project_pyconf_tmp_path, "w")
ff.write("#!/usr/bin/env python\n#-*- coding:utf-8 -*-\n\n")
project_pyconf_cfg.__save__(ff, 1)
ff.close()
return d_project
+
def add_readme(config, options, where):
readme_path = os.path.join(where, "README")
- with codecs.open(readme_path, "w", 'utf-8') as f:
+ with codecs.open(readme_path, "w", "utf-8") as f:
- # templates for building the header
- readme_header="""
+ # templates for building the header
+ readme_header = """
# This package was generated with sat $version
# Date: $date
# User: $user
"""
if src.architecture.is_windows():
- readme_header = readme_header.replace('$$ROOT','%ROOT%')
- readme_compilation_with_binaries="""
+ readme_header = readme_header.replace("$$ROOT", "%ROOT%")
+ readme_compilation_with_binaries = """
compilation based on the binaries used as prerequisites
=======================================================
modules you need to (with -p option)
"""
- readme_header_tpl=string.Template(readme_header)
- readme_template_path_bin = os.path.join(config.VARS.internal_dir,
- "README_BIN.template")
- readme_template_path_bin_launcher = os.path.join(config.VARS.internal_dir,
- "README_LAUNCHER.template")
- readme_template_path_bin_virtapp = os.path.join(config.VARS.internal_dir,
- "README_BIN_VIRTUAL_APP.template")
- readme_template_path_src = os.path.join(config.VARS.internal_dir,
- "README_SRC.template")
- readme_template_path_pro = os.path.join(config.VARS.internal_dir,
- "README_PROJECT.template")
- readme_template_path_sat = os.path.join(config.VARS.internal_dir,
- "README_SAT.template")
+ readme_header_tpl = string.Template(readme_header)
+ readme_template_path_bin = os.path.join(
+ config.VARS.internal_dir, "README_BIN.template"
+ )
+ readme_template_path_bin_launcher = os.path.join(
+ config.VARS.internal_dir, "README_LAUNCHER.template"
+ )
+ readme_template_path_bin_virtapp = os.path.join(
+ config.VARS.internal_dir, "README_BIN_VIRTUAL_APP.template"
+ )
+ readme_template_path_src = os.path.join(
+ config.VARS.internal_dir, "README_SRC.template"
+ )
+ readme_template_path_pro = os.path.join(
+ config.VARS.internal_dir, "README_PROJECT.template"
+ )
+ readme_template_path_sat = os.path.join(
+ config.VARS.internal_dir, "README_SAT.template"
+ )
# prepare substitution dictionary
d = dict()
- d['user'] = config.VARS.user
- d['date'] = datetime.datetime.now().strftime("%Y-%m-%d %H:%M")
- d['version'] = src.get_salometool_version(config)
- d['dist'] = config.VARS.dist
- f.write(readme_header_tpl.substitute(d)) # write the general header (common)
+ d["user"] = config.VARS.user
+ d["date"] = datetime.datetime.now().strftime("%Y-%m-%d %H:%M")
+ d["version"] = src.get_salometool_version(config)
+ d["dist"] = config.VARS.dist
+ f.write(readme_header_tpl.substitute(d)) # write the general header (common)
if options.binaries or options.sources:
- d['application'] = config.VARS.application
- d['BINARIES'] = config.INTERNAL.config.binary_dir
- d['SEPARATOR'] = config.VARS.sep
+ d["application"] = config.VARS.application
+ d["BINARIES"] = config.INTERNAL.config.binary_dir
+ d["SEPARATOR"] = config.VARS.sep
if src.architecture.is_windows():
- d['operatingSystem'] = 'Windows'
- d['PYTHON3'] = 'python3'
- d['ROOT'] = '%ROOT%'
+ d["operatingSystem"] = "Windows"
+ d["PYTHON3"] = "python3"
+ d["ROOT"] = "%ROOT%"
else:
- d['operatingSystem'] = 'Linux'
- d['PYTHON3'] = ''
- d['ROOT'] = '$ROOT'
- f.write("# Application: " + d['application'] + "\n")
- if 'KERNEL' in config.APPLICATION.products:
+ d["operatingSystem"] = "Linux"
+ d["PYTHON3"] = ""
+ d["ROOT"] = "$ROOT"
+ f.write("# Application: " + d["application"] + "\n")
+ if "KERNEL" in config.APPLICATION.products:
VersionSalome = src.get_salome_version(config)
# Case where SALOME has the launcher that uses the SalomeContext API
- if VersionSalome >= MMP([7,3,0]):
- d['launcher'] = config.APPLICATION.profile.launcher_name
+ if VersionSalome >= MMP([7, 3, 0]):
+ d["launcher"] = config.APPLICATION.profile.launcher_name
else:
- d['virtual_app'] = 'runAppli' # this info is not used now)
+ d["virtual_app"] = "runAppli" # this info is not used now)
# write the specific sections
if options.binaries:
return readme_path
-def update_config(config, logger, prop, value):
- '''Remove from config.APPLICATION.products the products that have the property given as input.
+
+def update_config(config, logger, prop, value):
+ """Remove from config.APPLICATION.products the products that have the property given as input.
:param config Config: The global config.
:param prop str: The property to filter
:param value str: The value of the property to filter
- '''
+ """
# if there is no APPLICATION (ex sat package -t) : nothing to do
if "APPLICATION" in config:
l_product_to_remove = []
l_product_to_remove.append(product_name)
for product_name in l_product_to_remove:
config.APPLICATION.products.__delitem__(product_name)
- logger.write("Remove product %s with property %s\n" % (product_name, prop), 5)
+ logger.write(
+ "Remove product %s with property %s\n" % (product_name, prop), 5
+ )
+
def description():
- '''method that is called when salomeTools is called with --help option.
+ """method that is called when salomeTools is called with --help option.
:return: The text to display for the package command description.
:rtype: str
- '''
- return _("""
+ """
+ return _(
+ """
The package command creates a tar file archive of a product.
There are four kinds of archive, which can be mixed:
It contains code utility salomeTools.
example:
- >> sat package SALOME-master --binaries --sources""")
+ >> sat package SALOME-master --binaries --sources"""
+ )
+
def run(args, runner, logger):
- '''method that is called when salomeTools is called with package parameter.
- '''
+ """method that is called when salomeTools is called with package parameter."""
# Parse the options
(options, args) = parser.parse_args(args)
-
# Check that a type of package is called, and only one
- all_option_types = (options.binaries,
- options.sources,
- options.project not in ["", None],
- options.sat,
- options.bin_products)
+ all_option_types = (
+ options.binaries,
+ options.sources,
+ options.project not in ["", None],
+ options.sat,
+ options.bin_products,
+ )
# Check if no option for package type
if all_option_types.count(True) == 0:
- msg = _("Error: Precise a type for the package\nUse one of the "
- "following options: --binaries, --sources, --project or"
- " --salometools, --bin_products")
+ msg = _(
+ "Error: Precise a type for the package\nUse one of the "
+ "following options: --binaries, --sources, --project or"
+ " --salometools, --bin_products"
+ )
logger.write(src.printcolors.printcError(msg), 1)
logger.write("\n", 1)
return 1
- do_create_package = options.binaries or options.sources or options.project or options.sat
+ do_create_package = (
+ options.binaries or options.sources or options.project or options.sat
+ )
if options.bin_products:
ret = bin_products_archives(runner.cfg, logger, options.with_vcs)
- if ret!=0:
+ if ret != 0:
return ret
if not do_create_package:
return 0
src.check_config_has_application(runner.cfg)
# Display information
- logger.write(_("Packaging application %s\n") % src.printcolors.printcLabel(
- runner.cfg.VARS.application), 1)
+ logger.write(
+ _("Packaging application %s\n")
+ % src.printcolors.printcLabel(runner.cfg.VARS.application),
+ 1,
+ )
# Get the default directory where to put the packages
package_default_path = os.path.join(runner.cfg.APPLICATION.workdir, "PACKAGE")
break
if foundProject is None:
- local_path = os.path.join(runner.cfg.VARS.salometoolsway, "data", "local.pyconf")
- msg = _("""ERROR: the project %(1)s is not visible by salomeTools.
+ local_path = os.path.join(
+ runner.cfg.VARS.salometoolsway, "data", "local.pyconf"
+ )
+ msg = _(
+ """ERROR: the project %(1)s is not visible by salomeTools.
known projects are:
%(2)s
Please add it in file:
-%(3)s""" % \
- {"1": options.project, "2": "\n ".join(runner.cfg.PROJECTS.project_file_paths), "3": local_path})
+%(3)s"""
+ % {
+ "1": options.project,
+ "2": "\n ".join(runner.cfg.PROJECTS.project_file_paths),
+ "3": local_path,
+ }
+ )
logger.write(src.printcolors.printcError(msg), 1)
logger.write("\n", 1)
return 1
else:
options.project_file_path = foundProject
- src.printcolors.print_value(logger, "Project path", options.project_file_path, 2)
+ src.printcolors.print_value(
+ logger, "Project path", options.project_file_path, 2
+ )
# Remove the products that are filtered by the --without_properties option
if options.without_properties:
dir_name = os.path.dirname(options.name)
# suppress extension
- if archive_name[-len(".tgz"):] == ".tgz":
- archive_name = archive_name[:-len(".tgz")]
- if archive_name[-len(".tar.gz"):] == ".tar.gz":
- archive_name = archive_name[:-len(".tar.gz")]
+ if archive_name[-len(".tgz") :] == ".tgz":
+ archive_name = archive_name[: -len(".tgz")]
+ if archive_name[-len(".tar.gz") :] == ".tar.gz":
+ archive_name = archive_name[: -len(".tar.gz")]
else:
- archive_name=""
+ archive_name = ""
dir_name = package_default_path
if options.binaries or options.sources:
archive_name = runner.cfg.APPLICATION.name
if options.binaries:
- archive_name += "-"+runner.cfg.VARS.dist
+ archive_name += "-" + runner.cfg.VARS.dist
if options.sources:
archive_name += "-SRC"
archive_name += "-VCS"
if options.sat:
- archive_name += ("salomeTools_" + src.get_salometool_version(runner.cfg))
+ archive_name += "salomeTools_" + src.get_salometool_version(runner.cfg)
if options.project:
if options.sat:
archive_name += "_"
- archive_name += ("satproject_" + options.project)
-
- if len(archive_name)==0: # no option worked
- msg = _("Error: Cannot name the archive\n"
- " check if at least one of the following options was "
- "selected : --binaries, --sources, --project or"
- " --salometools")
+ archive_name += "satproject_" + options.project
+
+ if len(archive_name) == 0: # no option worked
+ msg = _(
+ "Error: Cannot name the archive\n"
+ " check if at least one of the following options was "
+ "selected : --binaries, --sources, --project or"
+ " --salometools"
+ )
logger.write(src.printcolors.printcError(msg), 1)
logger.write("\n", 1)
return 1
tmp_working_dir = os.path.join(runner.cfg.VARS.tmp_root, runner.cfg.VARS.datehour)
src.ensure_path_exists(tmp_working_dir)
logger.write("\n", 5)
- logger.write(_("The temporary working directory: %s\n" % tmp_working_dir),5)
+ logger.write(_("The temporary working directory: %s\n" % tmp_working_dir), 5)
logger.write("\n", 3)
logger.write(src.printcolors.printcLabel(msg), 2)
logger.write("\n", 2)
- d_files_to_add={} # content of the archive
+ d_files_to_add = {} # content of the archive
# a dict to hold paths that will need to be substitute for users recompilations
- d_paths_to_substitute={}
+ d_paths_to_substitute = {}
if options.binaries:
- d_bin_files_to_add = binary_package(runner.cfg,
- logger,
- options,
- tmp_working_dir)
+ d_bin_files_to_add = binary_package(
+ runner.cfg, logger, options, tmp_working_dir
+ )
# for all binaries dir, store the substitution that will be required
# for extra compilations
for key in d_bin_files_to_add:
if key.endswith("(bin)"):
source_dir = d_bin_files_to_add[key][0]
path_in_archive = d_bin_files_to_add[key][1].replace(
- runner.cfg.INTERNAL.config.binary_dir + runner.cfg.VARS.dist,
- runner.cfg.INTERNAL.config.install_dir)
- if os.path.basename(source_dir)==os.path.basename(path_in_archive):
+ runner.cfg.INTERNAL.config.binary_dir + runner.cfg.VARS.dist,
+ runner.cfg.INTERNAL.config.install_dir,
+ )
+ if os.path.basename(source_dir) == os.path.basename(path_in_archive):
# if basename is the same we will just substitute the dirname
- d_paths_to_substitute[os.path.dirname(source_dir)]=\
- os.path.dirname(path_in_archive)
+ d_paths_to_substitute[
+ os.path.dirname(source_dir)
+ ] = os.path.dirname(path_in_archive)
else:
- d_paths_to_substitute[source_dir]=path_in_archive
+ d_paths_to_substitute[source_dir] = path_in_archive
d_files_to_add.update(d_bin_files_to_add)
if options.sources:
- d_files_to_add.update(source_package(runner,
- runner.cfg,
- logger,
- options,
- tmp_working_dir))
+ d_files_to_add.update(
+ source_package(runner, runner.cfg, logger, options, tmp_working_dir)
+ )
if options.binaries:
# for archives with bin and sources we provide a shell script able to
# install binaries for compilation
- file_install_bin=produce_install_bin_file(runner.cfg,logger,
- tmp_working_dir,
- d_paths_to_substitute,
- "install_bin.sh")
- d_files_to_add.update({"install_bin" : (file_install_bin, "install_bin.sh")})
+ file_install_bin = produce_install_bin_file(
+ runner.cfg,
+ logger,
+ tmp_working_dir,
+ d_paths_to_substitute,
+ "install_bin.sh",
+ )
+ d_files_to_add.update({"install_bin": (file_install_bin, "install_bin.sh")})
logger.write("substitutions that need to be done later : \n", 5)
logger.write(str(d_paths_to_substitute), 5)
logger.write("\n", 5)
# --salomeTool option is not considered when --sources is selected, as this option
# already brings salomeTool!
if options.sat:
- d_files_to_add.update(sat_package(runner.cfg, tmp_working_dir,
- options, logger))
+ d_files_to_add.update(
+ sat_package(runner.cfg, tmp_working_dir, options, logger)
+ )
if options.project:
DBG.write("config for package %s" % options.project, runner.cfg)
- d_files_to_add.update(project_package(runner.cfg, options.project, options.project_file_path, options.ftp, tmp_working_dir, options.sat, logger))
-
- if not(d_files_to_add):
+ d_files_to_add.update(
+ project_package(
+ runner.cfg,
+ options.project,
+ options.project_file_path,
+ options.ftp,
+ tmp_working_dir,
+ options.sat,
+ logger,
+ )
+ )
+
+ if not (d_files_to_add):
msg = _("Error: Empty dictionnary to build the archive!\n")
logger.write(src.printcolors.printcError(msg), 1)
logger.write("\n", 1)
local_readme_tmp_path = add_readme(runner.cfg, options, tmp_working_dir)
d_files_to_add["README"] = (local_readme_tmp_path, "README")
- # Add the additional files of option add_files
+ # Add the additional files of option add_files
if options.add_files:
for file_path in options.add_files:
if not os.path.exists(file_path):
logger.write("\n", 2)
logger.write(src.printcolors.printcLabel(_("Actually do the package")), 2)
logger.write("\n", 2)
- logger.write("\nfiles and directories to add:\n%s\n\n" % PP.pformat(d_files_to_add), 5)
+ logger.write(
+ "\nfiles and directories to add:\n%s\n\n" % PP.pformat(d_files_to_add), 5
+ )
res = 0
try:
# Creating the object tarfile
- tar = tarfile.open(path_targz, mode='w:gz')
+ tar = tarfile.open(path_targz, mode="w:gz")
# get the filtering function if needed
if old_python:
filter_function = exclude_VCS_and_extensions
# Add the files to the tarfile object
- res = add_files(tar, archive_name, d_files_to_add, logger, f_exclude=filter_function)
+ res = add_files(
+ tar, archive_name, d_files_to_add, logger, f_exclude=filter_function
+ )
tar.close()
except KeyboardInterrupt:
logger.write(src.printcolors.printcError("\nERROR: forced interruption\n"), 1)
- logger.write(_("Removing the temporary working directory '%s'... ") % tmp_working_dir, 1)
+ logger.write(
+ _("Removing the temporary working directory '%s'... ") % tmp_working_dir, 1
+ )
# remove the working directory
shutil.rmtree(tmp_working_dir)
logger.write(_("OK"), 1)
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2012 CEA/DEN
#
# This library is free software; you can redistribute it and/or
# Define all possible option for patch command : sat patch <options>
parser = src.options.Options()
-parser.add_option('p', 'products', 'list2', 'products',
- _('Optional: products to get the sources. This option accepts a comma separated list.'))
+parser.add_option(
+ "p",
+ "products",
+ "list2",
+ "products",
+ _(
+ "Optional: products to get the sources. This option accepts a comma separated list."
+ ),
+)
+
def apply_patch(config, product_info, max_product_name_len, logger):
- '''The method called to apply patches on a product
+ """The method called to apply patches on a product
:param config Config: The global configuration
- :param product_info Config: The configuration specific to
+ :param product_info Config: The configuration specific to
the product to be patched
:param logger Logger: The logger instance to use for the display and logging
:return: (True if it succeed, else False, message to display)
:rtype: (boolean, str)
- '''
+ """
# if the product is native, do not apply patch
if src.product.product_is_native(product_info):
# display and log
- logger.write('%s: ' % src.printcolors.printcLabel(product_info.name), 4)
- logger.write(' ' * (max_product_name_len - len(product_info.name)), 4, False)
+ logger.write("%s: " % src.printcolors.printcLabel(product_info.name), 4)
+ logger.write(" " * (max_product_name_len - len(product_info.name)), 4, False)
logger.write("\n", 4, False)
- msg = _("The %s product is native. Do not apply "
- "any patch.") % product_info.name
+ msg = (
+ _("The %s product is native. Do not apply " "any patch.")
+ % product_info.name
+ )
logger.write(msg, 4)
logger.write("\n", 4)
- return True, ""
+ return True, ""
if not "patches" in product_info or len(product_info.patches) == 0:
# display and log
- logger.write('%s: ' % src.printcolors.printcLabel(product_info.name), 4)
- logger.write(' ' * (max_product_name_len - len(product_info.name)), 4, False)
+ logger.write("%s: " % src.printcolors.printcLabel(product_info.name), 4)
+ logger.write(" " * (max_product_name_len - len(product_info.name)), 4, False)
logger.write("\n", 4, False)
msg = _("No patch for the %s product") % product_info.name
logger.write(msg, 4)
return True, ""
else:
# display and log
- logger.write('%s: ' % src.printcolors.printcLabel(product_info.name), 3)
- logger.write(' ' * (max_product_name_len - len(product_info.name)), 3, False)
+ logger.write("%s: " % src.printcolors.printcLabel(product_info.name), 3)
+ logger.write(" " * (max_product_name_len - len(product_info.name)), 3, False)
logger.write("\n", 4, False)
if not os.path.exists(product_info.source_dir):
# Loop on all the patches of the product
for patch in product_info.patches:
details = []
-
+
# Check the existence and apply the patch
if os.path.isfile(patch):
patch_cmd = "patch -p1 < %s" % patch
-
+
# Write the command in the terminal if verbose level is at 5
- logger.write((" >%s\n" % patch_cmd),5)
-
+ logger.write((" >%s\n" % patch_cmd), 5)
+
# Write the command in the log file (can be seen using 'sat log')
logger.logTxtFile.write("\n >%s\n" % patch_cmd)
logger.logTxtFile.flush()
-
+
# Call the command
- res_cmd = (subprocess.call(patch_cmd,
- shell=True,
- cwd=product_info.source_dir,
- stdout=logger.logTxtFile,
- stderr=subprocess.STDOUT) == 0)
+ res_cmd = (
+ subprocess.call(
+ patch_cmd,
+ shell=True,
+ cwd=product_info.source_dir,
+ stdout=logger.logTxtFile,
+ stderr=subprocess.STDOUT,
+ )
+ == 0
+ )
else:
res_cmd = False
- details.append(" " +
- src.printcolors.printcError(_("Not a valid patch: %s") % patch))
+ details.append(
+ " " + src.printcolors.printcError(_("Not a valid patch: %s") % patch)
+ )
res.append(res_cmd)
-
+
if res_cmd:
- message = (_("Apply patch %s") %
- src.printcolors.printcHighlight(patch))
+ message = _("Apply patch %s") % src.printcolors.printcHighlight(patch)
else:
message = src.printcolors.printcWarning(
- _("Failed to apply patch %s") % patch)
+ _("Failed to apply patch %s") % patch
+ )
if config.USER.output_verbose_level >= 3:
retcode.append(" %s" % message)
else:
retcode.append("%s: %s" % (product_info.name, message))
-
+
if len(details) > 0:
retcode.extend(details)
res = not (False in res)
-
+
return res, "\n".join(retcode) + "\n"
+
def description():
- '''method that is called when salomeTools is called with --help option.
-
+ """method that is called when salomeTools is called with --help option.
+
:return: The text to display for the patch command description.
:rtype: str
- '''
- return _("The patch command apply the patches on the sources of "
- "the application products if there is any.\n\nexample:\nsat "
- "patch SALOME-master --products qt,boost")
-
+ """
+ return _(
+ "The patch command apply the patches on the sources of "
+ "the application products if there is any.\n\nexample:\nsat "
+ "patch SALOME-master --products qt,boost"
+ )
+
+
def run(args, runner, logger):
- '''method that is called when salomeTools is called with patch parameter.
- '''
+ """method that is called when salomeTools is called with patch parameter."""
# Parse the options
(options, args) = parser.parse_args(args)
-
+
# check that the command has been called with an application
- src.check_config_has_application( runner.cfg )
+ src.check_config_has_application(runner.cfg)
# Print some informations
- logger.write('Patching sources of the application %s\n' %
- src.printcolors.printcLabel(runner.cfg.VARS.application), 1)
+ logger.write(
+ "Patching sources of the application %s\n"
+ % src.printcolors.printcLabel(runner.cfg.VARS.application),
+ 1,
+ )
- src.printcolors.print_value(logger, 'workdir',
- runner.cfg.APPLICATION.workdir, 2)
+ src.printcolors.print_value(logger, "workdir", runner.cfg.APPLICATION.workdir, 2)
logger.write("\n", 2, False)
# Get the products list with products informations regarding the options
products_infos = src.product.get_products_list(options, runner.cfg, logger)
-
+
# Get the maximum name length in order to format the terminal display
max_product_name_len = 1
if len(products_infos) > 0:
max_product_name_len = max(map(lambda l: len(l), products_infos[0])) + 4
-
+
# The loop on all the products on which to apply the patches
good_result = 0
for __, product_info in products_infos:
# Apply the patch
- return_code, patch_res = apply_patch(runner.cfg,
- product_info,
- max_product_name_len,
- logger)
+ return_code, patch_res = apply_patch(
+ runner.cfg, product_info, max_product_name_len, logger
+ )
logger.write(patch_res, 1, False)
if return_code:
good_result += 1
-
+
# Display the results (how much passed, how much failed, etc...)
logger.write("\n", 2, False)
else:
status = src.KO_STATUS
res_count = "%d / %d" % (good_result, len(products_infos))
-
+
# write results
logger.write("Patching sources of the application:", 1)
logger.write(" " + src.printcolors.printc(status), 1, False)
logger.write(" (%s)\n" % res_count, 1, False)
-
+
return len(products_infos) - good_result
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2012 CEA/DEN
#
# This library is free software; you can redistribute it and/or
# Define all possible option for prepare command : sat prepare <options>
parser = src.options.Options()
-parser.add_option('p', 'products', 'list2', 'products',
- _('Optional: products to prepare. This option accepts a comma separated list.'))
-parser.add_option('f', 'force', 'boolean', 'force',
- _("Optional: force to prepare the products in development mode."))
-parser.add_option('', 'force_patch', 'boolean', 'force_patch',
- _("Optional: force to apply patch to the products in development mode."))
-parser.add_option('c', 'complete', 'boolean', 'complete',
+parser.add_option(
+ "p",
+ "products",
+ "list2",
+ "products",
+ _("Optional: products to prepare. This option accepts a comma separated list."),
+)
+parser.add_option(
+ "f",
+ "force",
+ "boolean",
+ "force",
+ _("Optional: force to prepare the products in development mode."),
+)
+parser.add_option(
+ "",
+ "force_patch",
+ "boolean",
+ "force_patch",
+ _("Optional: force to apply patch to the products in development mode."),
+)
+parser.add_option(
+ "c",
+ "complete",
+ "boolean",
+ "complete",
_("Optional: completion mode, only prepare products not present in SOURCES dir."),
- False)
+ False,
+)
def find_products_already_prepared(l_products):
- '''function that returns the list of products that have an existing source
+ """function that returns the list of products that have an existing source
directory.
-
+
:param l_products List: The list of products to check
- :return: The list of product configurations that have an existing source
+ :return: The list of product configurations that have an existing source
directory.
:rtype: List
- '''
+ """
l_res = []
for p_name_p_cfg in l_products:
__, prod_cfg = p_name_p_cfg
l_res.append(p_name_p_cfg)
return l_res
+
def find_products_with_patchs(l_products):
- '''function that returns the list of products that have one or more patches.
-
+ """function that returns the list of products that have one or more patches.
+
:param l_products List: The list of products to check
:return: The list of product configurations that have one or more patches.
:rtype: List
- '''
+ """
l_res = []
for p_name_p_cfg in l_products:
__, prod_cfg = p_name_p_cfg
l_patchs = src.get_cfg_param(prod_cfg, "patches", [])
- if len(l_patchs)>0:
+ if len(l_patchs) > 0:
l_res.append(p_name_p_cfg)
return l_res
+
def description():
- '''method that is called when salomeTools is called with --help option.
-
+ """method that is called when salomeTools is called with --help option.
+
:return: The text to display for the prepare command description.
:rtype: str
- '''
- return _("The prepare command gets the sources of "
- "the application products and apply the patches if there is any."
- "\n\nexample:\nsat prepare SALOME-master --products KERNEL,GUI")
-
+ """
+ return _(
+ "The prepare command gets the sources of "
+ "the application products and apply the patches if there is any."
+ "\n\nexample:\nsat prepare SALOME-master --products KERNEL,GUI"
+ )
+
+
def run(args, runner, logger):
- '''method that is called when salomeTools is called with prepare parameter.
- '''
-
+ """method that is called when salomeTools is called with prepare parameter."""
+
# Parse the options
(options, args) = parser.parse_args(args)
# check that the command has been called with an application
- src.check_config_has_application( runner.cfg )
+ src.check_config_has_application(runner.cfg)
# write warning if platform is not declared as supported
- src.check_platform_is_supported( runner.cfg, logger )
+ src.check_platform_is_supported(runner.cfg, logger)
products_infos = src.product.get_products_list(options, runner.cfg, logger)
args_appli = runner.cfg.VARS.application + " " # useful whitespace
if options.products:
listProd = list(options.products)
- else: # no product interpeted as all products
+ else: # no product interpeted as all products
listProd = [name for name, tmp in products_infos]
if options.complete:
# remove products that are already prepared 'completion mode)
- pi_already_prepared=find_products_already_prepared(products_infos)
+ pi_already_prepared = find_products_already_prepared(products_infos)
l_already_prepared = [i for i, tmp in pi_already_prepared]
newList, removedList = removeInList(listProd, l_already_prepared)
listProd = newList
- if len(newList) == 0 and len(removedList) > 0 :
+ if len(newList) == 0 and len(removedList) > 0:
msg = "\nAll the products are already installed, do nothing!\n"
logger.write(src.printcolors.printcWarning(msg), 1)
return 0
- if len(removedList) > 0 :
- msg = "\nList of already prepared products that are skipped : %s\n" % ",".join(removedList)
+ if len(removedList) > 0:
+ msg = (
+ "\nList of already prepared products that are skipped : %s\n"
+ % ",".join(removedList)
+ )
logger.write(msg, 3)
-
-
- args_product_opt = '--products ' + ",".join(listProd)
- do_source = (len(listProd) > 0)
+ args_product_opt = "--products " + ",".join(listProd)
+ do_source = len(listProd) > 0
ldev_products = [p for p in products_infos if src.product.product_is_dev(p[1])]
- newList = listProd # default
+ newList = listProd # default
if not options.force and len(ldev_products) > 0:
l_products_not_getted = find_products_already_prepared(ldev_products)
listNot = [i for i, tmp in l_products_not_getted]
newList, removedList = removeInList(listProd, listNot)
if len(removedList) > 0:
- msg = _("""\
+ msg = _(
+ """\
Do not get the source of the following products in development mode.
Use the --force option to overwrite it.
-""")
+"""
+ )
msg += "\n%s\n" % ",".join(removedList)
logger.write(src.printcolors.printcWarning(msg), 1)
- args_product_opt_clean = '--products ' + ",".join(newList)
- do_clean = (len(newList) > 0)
-
- newList = listProd # default
+ args_product_opt_clean = "--products " + ",".join(newList)
+ do_clean = len(newList) > 0
+
+ newList = listProd # default
if not options.force_patch and len(ldev_products) > 0:
l_products_with_patchs = find_products_with_patchs(ldev_products)
listNot = [i for i, tmp in l_products_with_patchs]
newList, removedList = removeInList(listProd, listNot)
if len(removedList) > 0:
- msg = _("""\
+ msg = _(
+ """\
Do not patch the following products in development mode.
Use the --force_patch option to overwrite it.
-""")
+"""
+ )
msg += "\n%s\n" % ",".join(removedList)
logger.write(src.printcolors.printcWarning(msg), 1)
-
- args_product_opt_patch = '--products ' + ",".join(newList)
- do_patch = (len(newList) > 0)
-
+
+ args_product_opt_patch = "--products " + ",".join(newList)
+ do_patch = len(newList) > 0
+
# Construct the final commands arguments
args_clean = args_appli + args_product_opt_clean + " --sources"
- args_source = args_appli + args_product_opt
+ args_source = args_appli + args_product_opt
args_patch = args_appli + args_product_opt_patch
-
+
# Initialize the results to a running status
res_clean = 0
res_source = 0
res_patch = 0
-
+
# Call the commands using the API
if do_clean:
msg = _("Clean the source directories ...")
logger.write(msg, 3)
logger.flush()
- res_clean = runner.clean(args_clean, batch=True, verbose = 0, logger_add_link = logger)
+ res_clean = runner.clean(
+ args_clean, batch=True, verbose=0, logger_add_link=logger
+ )
if res_clean == 0:
- logger.write('%s\n' % src.printcolors.printc(src.OK_STATUS), 3)
+ logger.write("%s\n" % src.printcolors.printc(src.OK_STATUS), 3)
else:
- logger.write('%s\n' % src.printcolors.printc(src.KO_STATUS), 3)
+ logger.write("%s\n" % src.printcolors.printc(src.KO_STATUS), 3)
if do_source:
msg = _("Get the sources of the products ...")
logger.write(msg, 5)
- res_source = runner.source(args_source, logger_add_link = logger)
+ res_source = runner.source(args_source, logger_add_link=logger)
if res_source == 0:
- logger.write('%s\n' % src.printcolors.printc(src.OK_STATUS), 5)
+ logger.write("%s\n" % src.printcolors.printc(src.OK_STATUS), 5)
else:
- logger.write('%s\n' % src.printcolors.printc(src.KO_STATUS), 5)
+ logger.write("%s\n" % src.printcolors.printc(src.KO_STATUS), 5)
if do_patch:
msg = _("Patch the product sources (if any) ...")
logger.write(msg, 5)
- res_patch = runner.patch(args_patch, logger_add_link = logger)
+ res_patch = runner.patch(args_patch, logger_add_link=logger)
if res_patch == 0:
- logger.write('%s\n' % src.printcolors.printc(src.OK_STATUS), 5)
+ logger.write("%s\n" % src.printcolors.printc(src.OK_STATUS), 5)
else:
- logger.write('%s\n' % src.printcolors.printc(src.KO_STATUS), 5)
-
+ logger.write("%s\n" % src.printcolors.printc(src.KO_STATUS), 5)
+
return res_clean + res_source + res_patch
def removeInList(aList, removeList):
"""Removes elements of removeList list from aList
-
+
:param aList: (list) The list from which to remove elements
:param removeList: (list) The list which contains elements to remove
- :return: (list, list) (list with elements removed, list of elements removed)
+ :return: (list, list) (list with elements removed, list of elements removed)
"""
res1 = [i for i in aList if i not in removeList]
res2 = [i for i in aList if i in removeList]
return (res1, res2)
-
-
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2013 CEA/DEN
#
# This library is free software; you can redistribute it and/or
parser = src.options.Options()
# no option more than -h as generic default
+
def description():
- '''method that is called when salomeTools is called with --help option.
-
+ """method that is called when salomeTools is called with --help option.
+
:return: The text to display for the run command description.
:rtype: str
- '''
- return _("""\
+ """
+ return _(
+ """\
The run command runs the application launcher with the given arguments.
example:
>> sat run SALOME-master
-""")
+"""
+ )
+
def run(args, runner, logger):
- '''method that is called when salomeTools is called with run parameter.
- '''
+ """method that is called when salomeTools is called with run parameter."""
# check for product
src.check_config_has_application(runner.cfg)
- # Determine launcher path
+ # Determine launcher path
launcher_name = src.get_launcher_name(runner.cfg)
launcher_dir = runner.cfg.APPLICATION.workdir
-
+
# Check the launcher existence
- if launcher_name not in os.listdir(launcher_dir):
- message = _("The launcher %s was not found in directory %s!\nDid you run the"
- " command 'sat launcher' ?\n") % (launcher_name, launcher_dir)
+ if launcher_name not in os.listdir(launcher_dir):
+ message = _(
+ "The launcher %s was not found in directory %s!\nDid you run the"
+ " command 'sat launcher' ?\n"
+ ) % (launcher_name, launcher_dir)
raise src.SatException(message)
-
+
launcher_path = os.path.join(launcher_dir, launcher_name)
if not os.path.exists(launcher_path):
- message = _("The launcher at path %s is missing.\nDid you run the"
- " command 'sat launcher' ?\n") % launcher_path
+ message = (
+ _(
+ "The launcher at path %s is missing.\nDid you run the"
+ " command 'sat launcher' ?\n"
+ )
+ % launcher_path
+ )
raise src.SatException(message)
# Determine the command to launch (add the additional arguments)
src.printcolors.print_value(logger, _("Executed command"), command, 2)
logger.write(_("Launching ...\n"))
logger.flush()
-
+
# Run the launcher
- subprocess.call(command,
- shell=True,
- stdout=logger.logTxtFile,
- stderr=subprocess.STDOUT)
-
+ subprocess.call(
+ command, shell=True, stdout=logger.logTxtFile, stderr=subprocess.STDOUT
+ )
+
# Display information : how to get the logs
- messageFirstPart = _("\nEnd of execution. To see the traces, "
- "please tap the following command :\n")
+ messageFirstPart = _(
+ "\nEnd of execution. To see the traces, " "please tap the following command :\n"
+ )
messageSecondPart = src.printcolors.printcLabel(
- runner.cfg.VARS.salometoolsway +
- os.sep +
- "sat log " +
- runner.cfg.VARS.application + "\n")
- logger.write(" %s\n" %(messageFirstPart + messageSecondPart), 2)
-
+ runner.cfg.VARS.salometoolsway
+ + os.sep
+ + "sat log "
+ + runner.cfg.VARS.application
+ + "\n"
+ )
+ logger.write(" %s\n" % (messageFirstPart + messageSecondPart), 2)
+
return 0
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2012 CEA/DEN
#
# This library is free software; you can redistribute it and/or
# Define all possible option for the script command : sat script <options>
parser = src.options.Options()
-parser.add_option('p', 'products', 'list2', 'products',
- _('Optional: products to configure. This option accepts a comma separated list.'))
-parser.add_option('', 'nb_proc', 'int', 'nb_proc',
- _("""Optional: The number of processors to use in the script if the make command is used in it.
+parser.add_option(
+ "p",
+ "products",
+ "list2",
+ "products",
+ _("Optional: products to configure. This option accepts a comma separated list."),
+)
+parser.add_option(
+ "",
+ "nb_proc",
+ "int",
+ "nb_proc",
+ _(
+ """Optional: The number of processors to use in the script if the make command is used in it.
Warning: the script has to be correctly written if you want this option to work.
- The $MAKE_OPTIONS has to be used."""), 0)
+ The $MAKE_OPTIONS has to be used."""
+ ),
+ 0,
+)
def log_step(logger, header, step):
logger.write("\n==== %s \n" % src.printcolors.printcInfo(step), 4)
logger.flush()
+
def log_res_step(logger, res):
if res == 0:
logger.write("%s \n" % src.printcolors.printcSuccess("OK"), 4)
logger.write("%s \n" % src.printcolors.printcError("KO"), 4)
logger.flush()
+
def run_script_all_products(config, products_infos, nb_proc, logger):
- '''Execute the script in each product build directory.
+ """Execute the script in each product build directory.
:param config Config: The global configuration
- :param products_info list: List of
+ :param products_info list: List of
(str, Config) => (product_name, product_info)
:param nb_proc int: The number of processors to use
:param logger Logger: The logger instance to use for the display and logging
:return: the number of failing commands.
:rtype: int
- '''
+ """
res = 0
for p_name_info in products_infos:
- res_prod = run_script_of_product(p_name_info,
- nb_proc,
- config,
- logger)
+ res_prod = run_script_of_product(p_name_info, nb_proc, config, logger)
if res_prod != 0:
- res += 1
+ res += 1
return res
+
def run_script_of_product(p_name_info, nb_proc, config, logger):
- '''Execute the proper configuration command(s)
+ """Execute the proper configuration command(s)
in the product build directory.
-
+
:param p_name_info tuple: (str, Config) => (product_name, product_info)
:param nb_proc int: The number of processors to use
:param config Config: The global configuration
- :param logger Logger: The logger instance to use for the display
+ :param logger Logger: The logger instance to use for the display
and logging
:return: 1 if it fails, else 0.
:rtype: int
- '''
-
+ """
+
p_name, p_info = p_name_info
-
+
# Logging
logger.write("\n", 4, False)
logger.write("################ ", 4)
logger.flush()
# Do nothing if he product is not compilable or has no compilation script
- if (("properties" in p_info and "compilation" in p_info.properties and
- p_info.properties.compilation == "no") or
- (not src.product.product_has_script(p_info))):
+ if (
+ "properties" in p_info
+ and "compilation" in p_info.properties
+ and p_info.properties.compilation == "no"
+ ) or (not src.product.product_has_script(p_info)):
log_step(logger, header, "ignored")
logger.write("\n", 3, False)
return 0
if not os.path.isfile(p_info.compil_script):
- msg_err="\n\nError : The compilation script file do not exists!"+\
- "\n It was not found by sat!"+\
- "\n Please check your salomeTool configuration\n"
+ msg_err = (
+ "\n\nError : The compilation script file do not exists!"
+ + "\n It was not found by sat!"
+ + "\n Please check your salomeTool configuration\n"
+ )
logger.error(msg_err)
return 1
# Instantiate the class that manages all the construction commands
# like cmake, make, make install, make test, environment management, etc...
builder = src.compilation.Builder(config, logger, p_name, p_info)
-
+
# Prepare the environment
log_step(logger, header, "PREPARE ENV")
res_prepare = builder.prepare()
log_res_step(logger, res_prepare)
-
+
# Execute the script
len_end_line = 20
script_path_display = src.printcolors.printcLabel(p_info.compil_script)
len_end_line += len(script_path_display)
res = builder.do_script_build(p_info.compil_script, number_of_proc=nb_proc)
log_res_step(logger, res)
-
+
# Log the result
if res > 0:
logger.write("\r%s%s" % (header, " " * len_end_line), 3)
logger.write("\r" + header + src.printcolors.printcError("KO"))
- logger.write("==== %(KO)s in script execution of %(name)s \n" %
- { "name" : p_name , "KO" : src.printcolors.printcInfo("ERROR")}, 4)
+ logger.write(
+ "==== %(KO)s in script execution of %(name)s \n"
+ % {"name": p_name, "KO": src.printcolors.printcInfo("ERROR")},
+ 4,
+ )
logger.write("\n", 3, False)
logger.flush()
return res
if src.product.product_has_post_script(p_info):
# the product has a post install script we run
- #script_path_display = src.printcolors.printcLabel(p_info.p_info.post_script)
- #log_step(logger, header, "POST SCRIPT " + script_path_display)
+ # script_path_display = src.printcolors.printcLabel(p_info.p_info.post_script)
+ # log_step(logger, header, "POST SCRIPT " + script_path_display)
res = builder.do_script_build(p_info.post_script)
- #log_res_step(logger, res)
+ # log_res_step(logger, res)
if res > 0:
logger.write("\r%s%s" % (header, " " * len_end_line), 3)
logger.write("\r" + header + src.printcolors.printcError("KO"))
- logger.write("==== %(KO)s in post script execution of %(name)s \n" %
- { "name" : p_name , "KO" : src.printcolors.printcInfo("ERROR")}, 4)
+ logger.write(
+ "==== %(KO)s in post script execution of %(name)s \n"
+ % {"name": p_name, "KO": src.printcolors.printcInfo("ERROR")},
+ 4,
+ )
logger.write("\n", 3, False)
logger.flush()
return res
-
+
logger.write("\r%s%s" % (header, " " * len_end_line), 3)
logger.write("\r" + header + src.printcolors.printcSuccess("OK"))
logger.write("==== %s \n" % src.printcolors.printcInfo("OK"), 4)
- logger.write("==== Script execution of %(name)s %(OK)s \n" %
- { "name" : p_name , "OK" : src.printcolors.printcInfo("OK")}, 4)
+ logger.write(
+ "==== Script execution of %(name)s %(OK)s \n"
+ % {"name": p_name, "OK": src.printcolors.printcInfo("OK")},
+ 4,
+ )
logger.write("\n", 3, False)
logger.flush()
return res
+
def description():
- '''method that is called when salomeTools is called with --help option.
-
+ """method that is called when salomeTools is called with --help option.
+
:return: The text to display for the script command description.
:rtype: str
- '''
- return _("The script command executes the script(s) of the the given "
- "products in the build directory.\nThis is done only for the "
- "products that are constructed using a script (build_source "
- ": \"script\").\nOtherwise, nothing is done."
- "\n\nexample:\nsat script SALOME-master --products Python,numpy")
-
+ """
+ return _(
+ "The script command executes the script(s) of the the given "
+ "products in the build directory.\nThis is done only for the "
+ "products that are constructed using a script (build_source "
+ ': "script").\nOtherwise, nothing is done.'
+ "\n\nexample:\nsat script SALOME-master --products Python,numpy"
+ )
+
+
def run(args, runner, logger):
- '''method that is called when salomeTools is called with make parameter.
- '''
-
+ """method that is called when salomeTools is called with make parameter."""
+
# Parse the options
(options, args) = parser.parse_args(args)
# check that the command has been called with an application
- src.check_config_has_application( runner.cfg )
+ src.check_config_has_application(runner.cfg)
# Get the list of products to treat
products_infos = src.product.get_products_list(options, runner.cfg, logger)
- products_infos = [pi for pi in products_infos if not(
- src.product.product_is_native(pi[1]) or
- src.product.product_is_fixed(pi[1]))]
-
-
+ products_infos = [
+ pi
+ for pi in products_infos
+ if not (
+ src.product.product_is_native(pi[1]) or src.product.product_is_fixed(pi[1])
+ )
+ ]
+
# Print some informations
- logger.write(_('Executing the script in the build '
- 'directories of the application %s\n') %
- src.printcolors.printcLabel(runner.cfg.VARS.application), 1)
-
- info = [(_("BUILD directory"),
- os.path.join(runner.cfg.APPLICATION.workdir, 'BUILD'))]
+ logger.write(
+ _("Executing the script in the build " "directories of the application %s\n")
+ % src.printcolors.printcLabel(runner.cfg.VARS.application),
+ 1,
+ )
+
+ info = [
+ (_("BUILD directory"), os.path.join(runner.cfg.APPLICATION.workdir, "BUILD"))
+ ]
src.print_info(logger, info)
-
+
# Call the function that will loop over all the products and execute
# the right command(s)
if options.nb_proc is None:
options.nb_proc = 0
- res = run_script_all_products(runner.cfg,
- products_infos,
- options.nb_proc,
- logger)
-
+ res = run_script_all_products(runner.cfg, products_infos, options.nb_proc, logger)
+
# Print the final state
nb_products = len(products_infos)
if res == 0:
final_status = "OK"
else:
final_status = "KO"
-
- logger.write(_("\nScript: %(status)s "
- "(%(valid_result)d/%(nb_products)d)\n") % \
- { 'status': src.printcolors.printc(final_status),
- 'valid_result': nb_products - res,
- 'nb_products': nb_products }, 1)
-
- return res
+
+ logger.write(
+ _("\nScript: %(status)s " "(%(valid_result)d/%(nb_products)d)\n")
+ % {
+ "status": src.printcolors.printc(final_status),
+ "valid_result": nb_products - res,
+ "nb_products": nb_products,
+ },
+ 1,
+ )
+
+ return res
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2012 CEA/DEN
#
# This library is free software; you can redistribute it and/or
# Define all possible option for the shell command : sat shell <options>
parser = src.options.Options()
-parser.add_option('c', 'command', 'string', 'command',
- _('Mandatory: The shell command to execute.'), "")
+parser.add_option(
+ "c",
+ "command",
+ "string",
+ "command",
+ _("Mandatory: The shell command to execute."),
+ "",
+)
+
def description():
- '''method that is called when salomeTools is called with --help option.
-
+ """method that is called when salomeTools is called with --help option.
+
:return: The text to display for the shell command description.
:rtype: str
- '''
- return _("""\
+ """
+ return _(
+ """\
The shell command executes the shell commands passed as argument.
example:
->> sat shell --command "ls -l /tmp" """)
-
+>> sat shell --command "ls -l /tmp" """
+ )
+
+
def run(args, runner, logger):
- '''method that is called when salomeTools is called with shell parameter.
- '''
-
+ """method that is called when salomeTools is called with shell parameter."""
+
# Parse the options
(options, args) = parser.parse_args(args)
# Make sure the command option has been called
if not options.command:
- message = _("The option --command is required\n")
+ message = _("The option --command is required\n")
logger.write(src.printcolors.printcError(message))
return 1
-
+
# Print the input command
msg = _("Command to execute:\n%s\nExecution ... " % options.command)
logger.write(msg, 3)
-
+
# Call the input command
- res = subprocess.call(options.command,
- shell=True,
- stdout=logger.logTxtFile,
- stderr=subprocess.STDOUT)
-
+ res = subprocess.call(
+ options.command, shell=True, stdout=logger.logTxtFile, stderr=subprocess.STDOUT
+ )
+
# Format the result to be 0 (success) or 1 (fail)
if res != 0:
res = 1
logger.write(src.printcolors.printc("KO"), 3)
else:
logger.write(src.printcolors.printc("OK"), 3)
-
- logger.write("\n",3)
-
- return res
\ No newline at end of file
+
+ logger.write("\n", 3)
+
+ return res
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2012 CEA/DEN
#
# This library is free software; you can redistribute it and/or
# Define all possible option for patch command : sat patch <options>
parser = src.options.Options()
-parser.add_option('p', 'products', 'list2', 'products',
- _('Optional: products from which to get the sources. This option accepts a comma separated list.'))
+parser.add_option(
+ "p",
+ "products",
+ "list2",
+ "products",
+ _(
+ "Optional: products from which to get the sources. This option accepts a comma separated list."
+ ),
+)
+
def get_source_for_dev(config, product_info, source_dir, logger, pad):
- '''The method called if the product is in development mode
-
+ """The method called if the product is in development mode
+
:param config Config: The global configuration
- :param product_info Config: The configuration specific to
+ :param product_info Config: The configuration specific to
the product to be prepared
- :param source_dir Path: The Path instance corresponding to the
+ :param source_dir Path: The Path instance corresponding to the
directory where to put the sources
:param logger Logger: The logger instance to use for the display and logging
:param pad int: The gap to apply for the terminal display
:return: True if it succeed, else False
:rtype: boolean
- '''
-
+ """
+
# Call the function corresponding to get the sources with True checkout
- retcode = get_product_sources(config,
- product_info,
- True,
- source_dir,
- logger,
- pad,
- checkout=True)
+ retcode = get_product_sources(
+ config, product_info, True, source_dir, logger, pad, checkout=True
+ )
logger.write("\n", 3, False)
# +2 because product name is followed by ': '
- logger.write(" " * (pad+2), 3, False)
-
- logger.write('dev: %s ... ' %
- src.printcolors.printcInfo(product_info.source_dir), 3, False)
+ logger.write(" " * (pad + 2), 3, False)
+
+ logger.write(
+ "dev: %s ... " % src.printcolors.printcInfo(product_info.source_dir), 3, False
+ )
logger.flush()
-
+
return retcode
-def get_source_from_git(config,
- product_info,
- source_dir,
- logger,
- pad,
- is_dev=False,
- environ = None):
- '''The method called if the product is to be get in git mode
-
- :param product_info Config: The configuration specific to
+
+def get_source_from_git(
+ config, product_info, source_dir, logger, pad, is_dev=False, environ=None
+):
+ """The method called if the product is to be get in git mode
+
+ :param product_info Config: The configuration specific to
the product to be prepared
- :param source_dir Path: The Path instance corresponding to the
+ :param source_dir Path: The Path instance corresponding to the
directory where to put the sources
:param logger Logger: The logger instance to use for the display and logging
:param pad int: The gap to apply for the terminal display
extracting.
:return: True if it succeed, else False
:rtype: boolean
- '''
+ """
# The str to display
- coflag = 'git'
+ coflag = "git"
- use_repo_dev=False
- if ("APPLICATION" in config and
- "properties" in config.APPLICATION and
- "repo_dev" in config.APPLICATION.properties and
- config.APPLICATION.properties.repo_dev == "yes") :
- use_repo_dev=True
+ use_repo_dev = False
+ if (
+ "APPLICATION" in config
+ and "properties" in config.APPLICATION
+ and "repo_dev" in config.APPLICATION.properties
+ and config.APPLICATION.properties.repo_dev == "yes"
+ ):
+ use_repo_dev = True
# Get the repository address.
# If the application has the repo_dev property
# Or if the product is in dev mode
# Then we use repo_dev if the key exists
- if (is_dev or use_repo_dev) and 'repo_dev' in product_info.git_info:
+ if (is_dev or use_repo_dev) and "repo_dev" in product_info.git_info:
coflag = src.printcolors.printcHighlight(coflag.upper())
- repo_git = product_info.git_info.repo_dev
+ repo_git = product_info.git_info.repo_dev
else:
- repo_git = product_info.git_info.repo
-
+ repo_git = product_info.git_info.repo
# Display informations
- logger.write('%s:%s' % (coflag, src.printcolors.printcInfo(repo_git)), 3,
- False)
- logger.write(' ' * (pad + 50 - len(repo_git)), 3, False)
- logger.write(' tag:%s' % src.printcolors.printcInfo(
- product_info.git_info.tag),
- 3,
- False)
- logger.write(' %s. ' % ('.' * (10 - len(product_info.git_info.tag))), 3,
- False)
+ logger.write("%s:%s" % (coflag, src.printcolors.printcInfo(repo_git)), 3, False)
+ logger.write(" " * (pad + 50 - len(repo_git)), 3, False)
+ logger.write(
+ " tag:%s" % src.printcolors.printcInfo(product_info.git_info.tag), 3, False
+ )
+ logger.write(" %s. " % ("." * (10 - len(product_info.git_info.tag))), 3, False)
logger.flush()
- logger.write('\n', 5, False)
+ logger.write("\n", 5, False)
- git_options= ''
+ git_options = ""
if "git_options" in product_info.git_info:
git_options = product_info.git_info.git_options
sub_dir = product_info.git_info.sub_dir
if sub_dir is None:
- # Call the system function that do the extraction in git mode
- retcode = src.system.git_extract(repo_git,
- product_info.git_info.tag, git_options,
- source_dir, logger, environ)
+ # Call the system function that do the extraction in git mode
+ retcode = src.system.git_extract(
+ repo_git,
+ product_info.git_info.tag,
+ git_options,
+ source_dir,
+ logger,
+ environ,
+ )
else:
- # Call the system function that do the extraction of a sub_dir in git mode
- logger.write("sub_dir:%s " % sub_dir, 3)
- retcode = src.system.git_extract_sub_dir(repo_git,
- product_info.git_info.tag,git_options,
- source_dir, sub_dir, logger, environ)
-
+ # Call the system function that do the extraction of a sub_dir in git mode
+ logger.write("sub_dir:%s " % sub_dir, 3)
+ retcode = src.system.git_extract_sub_dir(
+ repo_git,
+ product_info.git_info.tag,
+ git_options,
+ source_dir,
+ sub_dir,
+ logger,
+ environ,
+ )
return retcode
+
def get_source_from_archive(config, product_info, source_dir, logger):
- '''The method called if the product is to be get in archive mode
-
+ """The method called if the product is to be get in archive mode
+
:param config Config: The global configuration
- :param product_info Config: The configuration specific to
+ :param product_info Config: The configuration specific to
the product to be prepared
- :param source_dir Path: The Path instance corresponding to the
+ :param source_dir Path: The Path instance corresponding to the
directory where to put the sources
:param logger Logger: The logger instance to use for the display and logging
:return: True if it succeed, else False
:rtype: boolean
- '''
+ """
# check if pip should be used : pip mode id activated if the application and product have pip property
- if (src.appli_test_property(config,"pip", "yes") and
- src.product.product_test_property(product_info,"pip", "yes")):
+ if src.appli_test_property(
+ config, "pip", "yes"
+ ) and src.product.product_test_property(product_info, "pip", "yes"):
pip_msg = "PIP : do nothing, product will be downloaded later at compile time "
- logger.write(pip_msg, 3)
+ logger.write(pip_msg, 3)
return True
# check archive exists
if not os.path.exists(product_info.archive_info.archive_name):
# The archive is not found on local file system (ARCHIVEPATH)
# We try ftp!
- logger.write("\n The archive is not found on local file system, we try ftp\n", 3)
- ret=src.find_file_in_ftppath(product_info.archive_info.archive_name,
- config.PATHS.ARCHIVEFTP, config.LOCAL.archive_dir, logger)
+ logger.write(
+ "\n The archive is not found on local file system, we try ftp\n", 3
+ )
+ ret = src.find_file_in_ftppath(
+ product_info.archive_info.archive_name,
+ config.PATHS.ARCHIVEFTP,
+ config.LOCAL.archive_dir,
+ logger,
+ )
if ret:
# archive was found on ftp and stored in ret
- product_info.archive_info.archive_name=ret
+ product_info.archive_info.archive_name = ret
else:
- raise src.SatException(_("Archive not found in ARCHIVEPATH, nor on ARCHIVEFTP: '%s'") %
- product_info.archive_info.archive_name)
-
- logger.write('arc:%s ... ' %
- src.printcolors.printcInfo(product_info.archive_info.archive_name),
- 3,
- False)
+ raise src.SatException(
+ _("Archive not found in ARCHIVEPATH, nor on ARCHIVEFTP: '%s'")
+ % product_info.archive_info.archive_name
+ )
+
+ logger.write(
+ "arc:%s ... "
+ % src.printcolors.printcInfo(product_info.archive_info.archive_name),
+ 3,
+ False,
+ )
logger.flush()
# Call the system function that do the extraction in archive mode
retcode, NameExtractedDirectory = src.system.archive_extract(
- product_info.archive_info.archive_name,
- source_dir.dir(), logger)
-
- # Rename the source directory if
+ product_info.archive_info.archive_name, source_dir.dir(), logger
+ )
+
+ # Rename the source directory if
# it does not match with product_info.source_dir
- if (NameExtractedDirectory.replace('/', '') !=
- os.path.basename(product_info.source_dir)):
- shutil.move(os.path.join(os.path.dirname(product_info.source_dir),
- NameExtractedDirectory),
- product_info.source_dir)
-
+ if NameExtractedDirectory.replace("/", "") != os.path.basename(
+ product_info.source_dir
+ ):
+ shutil.move(
+ os.path.join(
+ os.path.dirname(product_info.source_dir), NameExtractedDirectory
+ ),
+ product_info.source_dir,
+ )
+
return retcode
+
def get_source_from_dir(product_info, source_dir, logger):
-
+
if "dir_info" not in product_info:
- msg = _("Error: you must put a dir_info section"
- " in the file %s.pyconf" % product_info.name)
+ msg = _(
+ "Error: you must put a dir_info section"
+ " in the file %s.pyconf" % product_info.name
+ )
logger.write("\n%s\n" % src.printcolors.printcError(msg), 1)
return False
if "dir" not in product_info.dir_info:
- msg = _("Error: you must put a dir in the dir_info section"
- " in the file %s.pyconf" % product_info.name)
+ msg = _(
+ "Error: you must put a dir in the dir_info section"
+ " in the file %s.pyconf" % product_info.name
+ )
logger.write("\n%s\n" % src.printcolors.printcError(msg), 1)
return False
# check that source exists
if not os.path.exists(product_info.dir_info.dir):
- msg = _("Error: the dir %s defined in the file"
- " %s.pyconf does not exists" % (product_info.dir_info.dir,
- product_info.name))
+ msg = _(
+ "Error: the dir %s defined in the file"
+ " %s.pyconf does not exists"
+ % (product_info.dir_info.dir, product_info.name)
+ )
logger.write("\n%s\n" % src.printcolors.printcError(msg), 1)
return False
-
- logger.write('DIR: %s ... ' % src.printcolors.printcInfo(
- product_info.dir_info.dir), 3)
+
+ logger.write(
+ "DIR: %s ... " % src.printcolors.printcInfo(product_info.dir_info.dir), 3
+ )
logger.flush()
retcode = src.Path(product_info.dir_info.dir).copy(source_dir)
-
+
return retcode
-
-def get_source_from_cvs(user,
- product_info,
- source_dir,
- checkout,
- logger,
- pad,
- environ = None):
- '''The method called if the product is to be get in cvs mode
-
+
+
+def get_source_from_cvs(
+ user, product_info, source_dir, checkout, logger, pad, environ=None
+):
+ """The method called if the product is to be get in cvs mode
+
:param user str: The user to use in for the cvs command
- :param product_info Config: The configuration specific to
+ :param product_info Config: The configuration specific to
the product to be prepared
- :param source_dir Path: The Path instance corresponding to the
+ :param source_dir Path: The Path instance corresponding to the
directory where to put the sources
:param checkout boolean: If True, get the source in checkout mode
:param logger Logger: The logger instance to use for the display and logging
extracting.
:return: True if it succeed, else False
:rtype: boolean
- '''
+ """
# Get the protocol to use in the command
if "protocol" in product_info.cvs_info:
protocol = product_info.cvs_info.protocol
else:
protocol = "pserver"
-
+
# Construct the line to display
if "protocol" in product_info.cvs_info:
- cvs_line = "%s:%s@%s:%s" % \
- (protocol, user, product_info.cvs_info.server,
- product_info.cvs_info.product_base)
+ cvs_line = "%s:%s@%s:%s" % (
+ protocol,
+ user,
+ product_info.cvs_info.server,
+ product_info.cvs_info.product_base,
+ )
else:
- cvs_line = "%s / %s" % (product_info.cvs_info.server,
- product_info.cvs_info.product_base)
-
- coflag = 'cvs'
- if checkout: coflag = src.printcolors.printcHighlight(coflag.upper())
-
- logger.write('%s:%s' % (coflag, src.printcolors.printcInfo(cvs_line)),
- 3,
- False)
- logger.write(' ' * (pad + 50 - len(cvs_line)), 3, False)
- logger.write(' src:%s' %
- src.printcolors.printcInfo(product_info.cvs_info.source),
- 3,
- False)
- logger.write(' ' * (pad + 1 - len(product_info.cvs_info.source)), 3, False)
- logger.write(' tag:%s' %
- src.printcolors.printcInfo(product_info.cvs_info.tag),
- 3,
- False)
+ cvs_line = "%s / %s" % (
+ product_info.cvs_info.server,
+ product_info.cvs_info.product_base,
+ )
+
+ coflag = "cvs"
+ if checkout:
+ coflag = src.printcolors.printcHighlight(coflag.upper())
+
+ logger.write("%s:%s" % (coflag, src.printcolors.printcInfo(cvs_line)), 3, False)
+ logger.write(" " * (pad + 50 - len(cvs_line)), 3, False)
+ logger.write(
+ " src:%s" % src.printcolors.printcInfo(product_info.cvs_info.source), 3, False
+ )
+ logger.write(" " * (pad + 1 - len(product_info.cvs_info.source)), 3, False)
+ logger.write(
+ " tag:%s" % src.printcolors.printcInfo(product_info.cvs_info.tag), 3, False
+ )
# at least one '.' is visible
- logger.write(' %s. ' % ('.' * (10 - len(product_info.cvs_info.tag))),
- 3,
- False)
+ logger.write(" %s. " % ("." * (10 - len(product_info.cvs_info.tag))), 3, False)
logger.flush()
- logger.write('\n', 5, False)
+ logger.write("\n", 5, False)
# Call the system function that do the extraction in cvs mode
- retcode = src.system.cvs_extract(protocol, user,
- product_info.cvs_info.server,
- product_info.cvs_info.product_base,
- product_info.cvs_info.tag,
- product_info.cvs_info.source,
- source_dir, logger, checkout, environ)
+ retcode = src.system.cvs_extract(
+ protocol,
+ user,
+ product_info.cvs_info.server,
+ product_info.cvs_info.product_base,
+ product_info.cvs_info.tag,
+ product_info.cvs_info.source,
+ source_dir,
+ logger,
+ checkout,
+ environ,
+ )
return retcode
-def get_source_from_svn(user,
- product_info,
- source_dir,
- checkout,
- logger,
- environ = None):
- '''The method called if the product is to be get in svn mode
-
+
+def get_source_from_svn(user, product_info, source_dir, checkout, logger, environ=None):
+ """The method called if the product is to be get in svn mode
+
:param user str: The user to use in for the svn command
- :param product_info Config: The configuration specific to
+ :param product_info Config: The configuration specific to
the product to be prepared
- :param source_dir Path: The Path instance corresponding to the
+ :param source_dir Path: The Path instance corresponding to the
directory where to put the sources
:param checkout boolean: If True, get the source in checkout mode
:param logger Logger: The logger instance to use for the display and logging
extracting.
:return: True if it succeed, else False
:rtype: boolean
- '''
- coflag = 'svn'
- if checkout: coflag = src.printcolors.printcHighlight(coflag.upper())
-
- logger.write('%s:%s ... ' % (coflag,
- src.printcolors.printcInfo(
- product_info.svn_info.repo)),
- 3,
- False)
+ """
+ coflag = "svn"
+ if checkout:
+ coflag = src.printcolors.printcHighlight(coflag.upper())
+
+ logger.write(
+ "%s:%s ... " % (coflag, src.printcolors.printcInfo(product_info.svn_info.repo)),
+ 3,
+ False,
+ )
logger.flush()
- logger.write('\n', 5, False)
+ logger.write("\n", 5, False)
# Call the system function that do the extraction in svn mode
- retcode = src.system.svn_extract(user,
- product_info.svn_info.repo,
- product_info.svn_info.tag,
- source_dir,
- logger,
- checkout,
- environ)
+ retcode = src.system.svn_extract(
+ user,
+ product_info.svn_info.repo,
+ product_info.svn_info.tag,
+ source_dir,
+ logger,
+ checkout,
+ environ,
+ )
return retcode
-def get_product_sources(config,
- product_info,
- is_dev,
- source_dir,
- logger,
- pad,
- checkout=False):
- '''Get the product sources.
-
+
+def get_product_sources(
+ config, product_info, is_dev, source_dir, logger, pad, checkout=False
+):
+ """Get the product sources.
+
:param config Config: The global configuration
- :param product_info Config: The configuration specific to
+ :param product_info Config: The configuration specific to
the product to be prepared
:param is_dev boolean: True if the product is in development mode
- :param source_dir Path: The Path instance corresponding to the
+ :param source_dir Path: The Path instance corresponding to the
directory where to put the sources
:param logger Logger: The logger instance to use for the display and logging
:param pad int: The gap to apply for the terminal display
:param checkout boolean: If True, get the source in checkout mode
:return: True if it succeed, else False
:rtype: boolean
- '''
-
+ """
+
# Get the application environment
logger.write(_("Set the application environment\n"), 5)
- env_appli = src.environment.SalomeEnviron(config,
- src.environment.Environ(dict(os.environ)))
+ env_appli = src.environment.SalomeEnviron(
+ config, src.environment.Environ(dict(os.environ))
+ )
env_appli.set_application_env(logger)
-
+
# Call the right function to get sources regarding the product settings
if not checkout and is_dev:
- return get_source_for_dev(config,
- product_info,
- source_dir,
- logger,
- pad)
+ return get_source_for_dev(config, product_info, source_dir, logger, pad)
if product_info.get_source == "git":
- return get_source_from_git(config, product_info, source_dir, logger, pad,
- is_dev, env_appli)
+ return get_source_from_git(
+ config, product_info, source_dir, logger, pad, is_dev, env_appli
+ )
if product_info.get_source == "archive":
return get_source_from_archive(config, product_info, source_dir, logger)
if product_info.get_source == "dir":
return get_source_from_dir(product_info, source_dir, logger)
-
+
if product_info.get_source == "cvs":
cvs_user = config.USER.cvs_user
- return get_source_from_cvs(cvs_user, product_info, source_dir,
- checkout, logger, pad, env_appli)
+ return get_source_from_cvs(
+ cvs_user, product_info, source_dir, checkout, logger, pad, env_appli
+ )
if product_info.get_source == "svn":
svn_user = config.USER.svn_user
- return get_source_from_svn(svn_user, product_info, source_dir,
- checkout, logger, env_appli)
+ return get_source_from_svn(
+ svn_user, product_info, source_dir, checkout, logger, env_appli
+ )
if product_info.get_source == "native":
# for native products we check the corresponding system packages are installed
- logger.write("Native : Checking system packages are installed\n" , 3)
- check_cmd=src.system.get_pkg_check_cmd(config.VARS.dist_name) # (either rmp or apt)
- run_pkg,build_pkg=src.product.check_system_dep(config.VARS.dist, check_cmd, product_info)
- result=True
+ logger.write("Native : Checking system packages are installed\n", 3)
+ check_cmd = src.system.get_pkg_check_cmd(
+ config.VARS.dist_name
+ ) # (either rmp or apt)
+ run_pkg, build_pkg = src.product.check_system_dep(
+ config.VARS.dist, check_cmd, product_info
+ )
+ result = True
for pkg in run_pkg:
- logger.write(" - " + pkg + " : " + run_pkg[pkg] + '\n', 1)
+ logger.write(" - " + pkg + " : " + run_pkg[pkg] + "\n", 1)
if "KO" in run_pkg[pkg]:
- result=False
+ result = False
for pkg in build_pkg:
- logger.write(" - " + pkg + " : " + build_pkg[pkg] + '\n', 1)
+ logger.write(" - " + pkg + " : " + build_pkg[pkg] + "\n", 1)
if "KO" in build_pkg[pkg]:
- result=False
- if result==False:
- logger.error("some system dependencies are missing, please install them with "+\
- check_cmd[0])
- return result
+ result = False
+ if result == False:
+ logger.error(
+ "some system dependencies are missing, please install them with "
+ + check_cmd[0]
+ )
+ return result
if product_info.get_source == "fixed":
# skip
- logger.write('%s ' % src.printcolors.printc(src.OK_STATUS),
- 3,
- False)
+ logger.write("%s " % src.printcolors.printc(src.OK_STATUS), 3, False)
msg = "FIXED : %s\n" % product_info.install_dir
if not os.path.isdir(product_info.install_dir):
- logger.warning("The fixed path do not exixts!! Please check it : %s\n" % product_info.install_dir)
+ logger.warning(
+ "The fixed path do not exixts!! Please check it : %s\n"
+ % product_info.install_dir
+ )
else:
logger.write(msg, 3)
- return True
+ return True
# if the get_source is not in [git, archive, cvs, svn, fixed, native]
- logger.write(_("Unknown get source method \"%(get)s\" for product %(product)s") % \
- { 'get': product_info.get_source, 'product': product_info.name }, 3, False)
+ logger.write(
+ _('Unknown get source method "%(get)s" for product %(product)s')
+ % {"get": product_info.get_source, "product": product_info.name},
+ 3,
+ False,
+ )
logger.write(" ... ", 3, False)
logger.flush()
return False
+
def get_all_product_sources(config, products, logger):
- '''Get all the product sources.
-
+ """Get all the product sources.
+
:param config Config: The global configuration
:param products List: The list of tuples (product name, product informations)
:param logger Logger: The logger instance to be used for the logging
:return: the tuple (number of success, dictionary product_name/success_fail)
:rtype: (int,dict)
- '''
+ """
# Initialize the variables that will count the fails and success
results = dict()
max_product_name_len = 1
if len(products) > 0:
max_product_name_len = max(map(lambda l: len(l), products[0])) + 4
-
+
# The loop on all the products from which to get the sources
# DBG.write("source.get_all_product_sources config id", id(config), True)
for product_name, product_info in products:
# get product name, product informations and the directory where to put
# the sources
- if (not (src.product.product_is_fixed(product_info) or
- src.product.product_is_native(product_info))):
+ if not (
+ src.product.product_is_fixed(product_info)
+ or src.product.product_is_native(product_info)
+ ):
source_dir = src.Path(product_info.source_dir)
else:
- source_dir = src.Path('')
+ source_dir = src.Path("")
# display and log
- logger.write('%s: ' % src.printcolors.printcLabel(product_name), 3)
- logger.write(' ' * (max_product_name_len - len(product_name)), 3, False)
+ logger.write("%s: " % src.printcolors.printcLabel(product_name), 3)
+ logger.write(" " * (max_product_name_len - len(product_name)), 3, False)
logger.write("\n", 4, False)
-
- # Remove the existing source directory if
+
+ # Remove the existing source directory if
# the product is not in development mode
is_dev = src.product.product_is_dev(product_info)
if source_dir.exists():
- logger.write('%s ' % src.printcolors.printc(src.OK_STATUS), 3, False)
- msg = _("INFO : Not doing anything because the source directory already exists:\n %s\n") % source_dir
+ logger.write("%s " % src.printcolors.printc(src.OK_STATUS), 3, False)
+ msg = (
+ _(
+ "INFO : Not doing anything because the source directory already exists:\n %s\n"
+ )
+ % source_dir
+ )
logger.write(msg, 3)
good_result = good_result + 1
# Do not get the sources and go to next product
continue
# Call to the function that get the sources for one product
- retcode = get_product_sources(config, product_info, is_dev,
- source_dir, logger, max_product_name_len,
- checkout=False)
-
- '''
+ retcode = get_product_sources(
+ config,
+ product_info,
+ is_dev,
+ source_dir,
+ logger,
+ max_product_name_len,
+ checkout=False,
+ )
+
+ """
if 'no_rpath' in product_info.keys():
if product_info.no_rpath:
hack_no_rpath(config, product_info, logger)
- '''
-
+ """
+
# Check that the sources are correctly get using the files to be tested
# in product information
if retcode:
else:
# The case where it failed
res = src.KO_STATUS
-
+
# print the result
- if not(src.product.product_is_fixed(product_info) or
- src.product.product_is_native(product_info)):
- logger.write('%s\n' % src.printcolors.printc(res), 3, False)
+ if not (
+ src.product.product_is_fixed(product_info)
+ or src.product.product_is_native(product_info)
+ ):
+ logger.write("%s\n" % src.printcolors.printc(res), 3, False)
return good_result, results
+
def check_sources(product_info, logger):
- '''Check that the sources are correctly get, using the files to be tested
+ """Check that the sources are correctly get, using the files to be tested
in product information
-
- :param product_info Config: The configuration specific to
+
+ :param product_info Config: The configuration specific to
the product to be prepared
:return: True if the files exists (or no files to test is provided).
:rtype: boolean
- '''
+ """
# Get the files to test if there is any
- if ("present_files" in product_info and
- "source" in product_info.present_files):
+ if "present_files" in product_info and "source" in product_info.present_files:
l_files_to_be_tested = product_info.present_files.source
for file_path in l_files_to_be_tested:
- # The path to test is the source directory
+ # The path to test is the source directory
# of the product joined the file path provided
path_to_test = os.path.join(product_info.source_dir, file_path)
logger.write(_("\nTesting existence of file: \n"), 5)
logger.write(src.printcolors.printcSuccess(" OK\n"), 5)
return True, ""
+
def description():
- '''method that is called when salomeTools is called with --help option.
-
+ """method that is called when salomeTools is called with --help option.
+
:return: The text to display for the source command description.
:rtype: str
- '''
- return _("The source command gets the sources of the application products "
- "from cvs, git or an archive.\n\nexample:"
- "\nsat source SALOME-master --products KERNEL,GUI")
-
+ """
+ return _(
+ "The source command gets the sources of the application products "
+ "from cvs, git or an archive.\n\nexample:"
+ "\nsat source SALOME-master --products KERNEL,GUI"
+ )
+
+
def run(args, runner, logger):
- '''method that is called when salomeTools is called with source parameter.
- '''
+ """method that is called when salomeTools is called with source parameter."""
DBG.write("source.run()", args)
# Parse the options
(options, args) = parser.parse_args(args)
-
+
# check that the command has been called with an application
- src.check_config_has_application( runner.cfg )
+ src.check_config_has_application(runner.cfg)
# Print some informations
- logger.write(_('Getting sources of the application %s\n') %
- src.printcolors.printcLabel(runner.cfg.VARS.application), 1)
- src.printcolors.print_value(logger, 'workdir',
- runner.cfg.APPLICATION.workdir, 2)
+ logger.write(
+ _("Getting sources of the application %s\n")
+ % src.printcolors.printcLabel(runner.cfg.VARS.application),
+ 1,
+ )
+ src.printcolors.print_value(logger, "workdir", runner.cfg.APPLICATION.workdir, 2)
logger.write("\n", 2, False)
-
+
# Get the products list with products informations regarding the options
products_infos = src.product.get_products_list(options, runner.cfg, logger)
-
+
# Call to the function that gets all the sources
good_result, results = get_all_product_sources(runner.cfg, products_infos, logger)
products_infos = src.product.get_products_list(options, runner.cfg, logger)
# Call to the function that gets all the sources
- good_result, results = update_all_product_sources(runner.cfg, products_infos, logger)
+ good_result, results = update_all_product_sources(
+ runner.cfg, products_infos, logger
+ )
# Display the results (how much passed, how much failed, etc...)
status = src.OK_STATUS
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2013 CEA/DEN
#
# This library is free software; you can redistribute it and/or
# Compatibility python 2/3 for input function
# input stays input for python 3 and input = raw_input for python 2
-try:
+try:
input = raw_input
-except NameError:
+except NameError:
pass
# Python 2/3 compatibility for execfile function
try:
execfile
except:
+
def execfile(somefile, global_vars, local_vars):
with open(somefile) as f:
- code = compile(f.read(), somefile, 'exec')
+ code = compile(f.read(), somefile, "exec")
exec(code, global_vars, local_vars)
+
parser = src.options.Options()
-parser.add_option('n', 'name', 'string', 'name',
- _("""REQUIRED: the name of the module to create.
+parser.add_option(
+ "n",
+ "name",
+ "string",
+ "name",
+ _(
+ """REQUIRED: the name of the module to create.
\tThe name must be a single word in upper case with only alphanumeric characters.
\tWhen generating a c++ component the module's """
-"""name must be suffixed with 'CPP'."""))
-parser.add_option('t', 'template', 'string', 'template',
- _('REQUIRED: the template to use.'))
-parser.add_option('', 'target', 'string', 'target',
- _('REQUIRED: where to create the module.'))
-parser.add_option('', 'param', 'string', 'param',
- _('''Optional: dictionary to generate the configuration for salomeTools.
+ """name must be suffixed with 'CPP'."""
+ ),
+)
+parser.add_option(
+ "t", "template", "string", "template", _("REQUIRED: the template to use.")
+)
+parser.add_option(
+ "", "target", "string", "target", _("REQUIRED: where to create the module.")
+)
+parser.add_option(
+ "",
+ "param",
+ "string",
+ "param",
+ _(
+ """Optional: dictionary to generate the configuration for salomeTools.
\tFormat is: --param param1=value1,param2=value2... without spaces
-\tNote that when using this option you must supply all the '''
-'''values otherwise an error will be raised.'''))
-parser.add_option('', 'info', 'boolean', 'info',
- _('Optional: Get information on the template.'), False)
+\tNote that when using this option you must supply all the """
+ """values otherwise an error will be raised."""
+ ),
+)
+parser.add_option(
+ "",
+ "info",
+ "boolean",
+ "info",
+ _("Optional: Get information on the template."),
+ False,
+)
+
class TParam:
def __init__(self, param_def, compo_name, dico=None):
self.default = ""
self.prompt = ""
self.check_method = None
-
+
if isinstance(param_def, str):
self.name = param_def
elif isinstance(param_def, tuple):
self.name = param_def[0]
if len(param_def) > 1:
- if dico is not None: self.default = param_def[1] % dico
- else: self.default = param_def[1]
- if len(param_def) > 2: self.prompt = param_def[2]
- if len(param_def) > 3: self.check_method = param_def[3]
+ if dico is not None:
+ self.default = param_def[1] % dico
+ else:
+ self.default = param_def[1]
+ if len(param_def) > 2:
+ self.prompt = param_def[2]
+ if len(param_def) > 3:
+ self.check_method = param_def[3]
else:
raise src.SatException(_("ERROR in template parameter definition"))
return len(val) > 0
return len(val) > 0 and self.check_method(val)
+
def get_dico_param(dico, key, default):
if key in dico:
return dico[key]
return default
+
class TemplateSettings:
def __init__(self, compo_name, settings_file, target):
self.compo_name = compo_name
# check required parameters in template.info
missing = []
for pp in ["file_subst", "parameters"]:
- if not (pp in ldic): missing.append("'%s'" % pp)
+ if not (pp in ldic):
+ missing.append("'%s'" % pp)
if len(missing) > 0:
- raise src.SatException(_(
- "Bad format in settings file! %s not defined.") % ", ".join(
- missing))
-
+ raise src.SatException(
+ _("Bad format in settings file! %s not defined.") % ", ".join(missing)
+ )
+
self.file_subst = ldic["file_subst"]
- self.parameters = ldic['parameters']
+ self.parameters = ldic["parameters"]
self.info = get_dico_param(ldic, "info", "").strip()
self.pyconf = get_dico_param(ldic, "pyconf", "")
self.post_command = get_dico_param(ldic, "post_command", "")
self.delimiter_char = get_dico_param(ldic, "delimiter", ":sat:")
# get the ignore filter
- self.ignore_filters = [l.strip() for l in ldic["ignore_filters"].split(',')]
+ self.ignore_filters = [l.strip() for l in ldic["ignore_filters"].split(",")]
def has_pyconf(self):
return len(self.pyconf) > 0
def check_user_values(self, values):
if values is None:
return
-
+
# create a list of all parameters (pyconf + list))
pnames = self.get_pyconf_parameters()
for p in self.parameters:
tp = TParam(p, self.compo_name)
pnames.append(tp.name)
-
+
# reduce the list
- pnames = list(set(pnames)) # remove duplicates
+ pnames = list(set(pnames)) # remove duplicates
known_values = ["name", "Name", "NAME", "target", self.file_subst]
known_values.extend(values.keys())
for p in pnames:
if p not in known_values:
missing.append(p)
-
+
if len(missing) > 0:
- raise src.SatException(_(
- "Missing parameters: %s") % ", ".join(missing))
+ raise src.SatException(_("Missing parameters: %s") % ", ".join(missing))
def get_parameters(self, conf_values=None):
if self.dico is not None:
tp = TParam(p, self.compo_name, dico)
if tp.name in dico:
continue
-
+
val = ""
while not tp.check_value(val):
val = input(tp.prompt)
self.dico = dico
return self.dico
+
def search_template(config, template):
# search template
template_src_dir = ""
raise src.SatException(_("Template not found: %s") % template)
return template_src_dir
+
+
##
# Prepares a module from a template.
-def prepare_from_template(config,
- name,
- template,
- target_dir,
- conf_values,
- logger):
+def prepare_from_template(config, name, template, target_dir, conf_values, logger):
template_src_dir = search_template(config, template)
res = 0
# copy the template
if os.path.isfile(template_src_dir):
- logger.write(" " + _(
- "Extract template %s\n") % src.printcolors.printcInfo(
- template), 4)
+ logger.write(
+ " " + _("Extract template %s\n") % src.printcolors.printcInfo(template), 4
+ )
src.system.archive_extract(template_src_dir, target_dir)
else:
- logger.write(" " + _(
- "Copy template %s\n") % src.printcolors.printcInfo(
- template), 4)
+ logger.write(
+ " " + _("Copy template %s\n") % src.printcolors.printcInfo(template), 4
+ )
shutil.copytree(template_src_dir, target_dir)
logger.write("\n", 5)
ff = fic.replace(tsettings.file_subst, compo_name)
if ff != fic:
if os.path.exists(os.path.join(root, ff)):
- raise src.SatException(_(
- "Destination file already exists: %s") % os.path.join(
- root, ff))
+ raise src.SatException(
+ _("Destination file already exists: %s")
+ % os.path.join(root, ff)
+ )
logger.write(" %s -> %s\n" % (fic, ff), 5)
os.rename(os.path.join(root, fic), os.path.join(root, ff))
# rename the directories
logger.write("\n", 5)
- logger.write(" " + src.printcolors.printcLabel(_("Rename directories\n")),
- 4)
+ logger.write(" " + src.printcolors.printcLabel(_("Rename directories\n")), 4)
for root, dirs, files in os.walk(target_dir, topdown=False):
for rep in dirs:
dd = rep.replace(tsettings.file_subst, compo_name)
if dd != rep:
if os.path.exists(os.path.join(root, dd)):
- raise src.SatException(_(
- "Destination directory "
- "already exists: %s") % os.path.join(root, dd))
+ raise src.SatException(
+ _("Destination directory " "already exists: %s")
+ % os.path.join(root, dd)
+ )
logger.write(" %s -> %s\n" % (rep, dd), 5)
os.rename(os.path.join(root, rep), os.path.join(root, dd))
# ask for missing parameters
logger.write("\n", 5)
- logger.write(" " + src.printcolors.printcLabel(
- _("Make substitution in files\n")), 4)
- logger.write(" " + _("Delimiter =") + " %s\n" % tsettings.delimiter_char,
- 5)
- logger.write(" " + _("Ignore Filters =") + " %s\n" % ', '.join(
- tsettings.ignore_filters), 5)
+ logger.write(
+ " " + src.printcolors.printcLabel(_("Make substitution in files\n")), 4
+ )
+ logger.write(" " + _("Delimiter =") + " %s\n" % tsettings.delimiter_char, 5)
+ logger.write(
+ " " + _("Ignore Filters =") + " %s\n" % ", ".join(tsettings.ignore_filters),
+ 5,
+ )
dico = tsettings.get_parameters(conf_values)
logger.write("\n", 3)
logger.write(" - %s\n" % fpath[pathlen:], 5)
continue
# read the file
- with open(fpath, 'r') as f:
+ with open(fpath, "r") as f:
m = f.read()
# make the substitution
template = CompoTemplate(m)
d = template.safe_substitute(dico)
-
+
changed = " "
if d != m:
changed = "*"
- with open(fpath, 'w') as f:
+ with open(fpath, "w") as f:
f.write(d)
logger.write(" %s %s\n" % (changed, fpath[pathlen:]), 5)
if not tsettings.has_pyconf:
- logger.write(src.printcolors.printcWarning(_(
- "Definition for sat not found in settings file.")) + "\n", 2)
+ logger.write(
+ src.printcolors.printcWarning(
+ _("Definition for sat not found in settings file.")
+ )
+ + "\n",
+ 2,
+ )
else:
definition = tsettings.pyconf % dico
- pyconf_file = os.path.join(target_dir, name + '.pyconf')
- f = open(pyconf_file, 'w')
+ pyconf_file = os.path.join(target_dir, name + ".pyconf")
+ f = open(pyconf_file, "w")
f.write(definition)
f.close
- logger.write(_(
- "Create configuration file: ") + src.printcolors.printcInfo(
- pyconf_file) + "\n", 2)
+ logger.write(
+ _("Create configuration file: ")
+ + src.printcolors.printcInfo(pyconf_file)
+ + "\n",
+ 2,
+ )
if len(tsettings.post_command) > 0:
cmd = tsettings.post_command % dico
logger.write("\n", 5, True)
- logger.write(_(
- "Run post command: ") + src.printcolors.printcInfo(cmd) + "\n", 3)
-
+ logger.write(
+ _("Run post command: ") + src.printcolors.printcInfo(cmd) + "\n", 3
+ )
+
p = subprocess.Popen(cmd, shell=True, cwd=target_dir)
p.wait()
res = p.returncode
return res
+
def get_template_info(config, template_name, logger):
sources = search_template(config, template_name)
src.printcolors.print_value(logger, _("Template"), sources)
if not os.path.exists(settings_file):
raise src.SatException(_("Settings file not found"))
tsettings = TemplateSettings("NAME", settings_file, "target")
-
+
logger.write("\n", 3)
if len(tsettings.info) == 0:
- logger.write(src.printcolors.printcWarning(_(
- "No information for this template.")), 3)
+ logger.write(
+ src.printcolors.printcWarning(_("No information for this template.")), 3
+ )
else:
logger.write(tsettings.info, 3)
logger.write("\n", 3)
logger.write("= Configuration", 3)
- src.printcolors.print_value(logger,
- "file substitution key",
- tsettings.file_subst)
- src.printcolors.print_value(logger,
- "subsitution key",
- tsettings.delimiter_char)
+ src.printcolors.print_value(logger, "file substitution key", tsettings.file_subst)
+ src.printcolors.print_value(logger, "subsitution key", tsettings.delimiter_char)
if len(tsettings.ignore_filters) > 0:
- src.printcolors.print_value(logger,
- "Ignore Filter",
- ', '.join(tsettings.ignore_filters))
+ src.printcolors.print_value(
+ logger, "Ignore Filter", ", ".join(tsettings.ignore_filters)
+ )
logger.write("\n", 3)
logger.write("= Parameters", 3)
logger.write("= Verification\n", 3)
if tsettings.file_subst not in pnames:
logger.write(
- "file substitution key not defined as a "
- "parameter: %s" % tsettings.file_subst, 3)
+ "file substitution key not defined as a "
+ "parameter: %s" % tsettings.file_subst,
+ 3,
+ )
retcode = 1
-
+
reexp = tsettings.delimiter_char.replace("$", "\$") + "{(?P<name>\S[^}]*)"
pathlen = len(tmpdir) + 1
for root, __, files in os.walk(tmpdir):
if not tsettings.check_file_for_substitution(fpath[pathlen:]):
continue
# read the file
- with open(fpath, 'r') as f:
+ with open(fpath, "r") as f:
m = f.read()
zz = re.findall(reexp, m)
- zz = list(set(zz)) # reduce
+ zz = list(set(zz)) # reduce
zz = filter(lambda l: l not in pnames, zz)
if len(zz) > 0:
- logger.write("Missing definition in %s: %s" % (
- src.printcolors.printcLabel(
- fpath[pathlen:]), ", ".join(zz)), 3)
+ logger.write(
+ "Missing definition in %s: %s"
+ % (src.printcolors.printcLabel(fpath[pathlen:]), ", ".join(zz)),
+ 3,
+ )
retcode = 1
if retcode == 0:
return retcode
+
##
# Describes the command
def description():
- return _("The template command creates the sources for a SALOME "
- "module from a template.\n\nexample\nsat template "
- "--name my_product_name --template PythonComponent --target /tmp")
+ return _(
+ "The template command creates the sources for a SALOME "
+ "module from a template.\n\nexample\nsat template "
+ "--name my_product_name --template PythonComponent --target /tmp"
+ )
+
def run(args, runner, logger):
- '''method that is called when salomeTools is called with template parameter.
- '''
+ """method that is called when salomeTools is called with template parameter."""
(options, args) = parser.parse_args(args)
if options.template is None:
logger.write("\n", 1)
return 1
- if not options.name.replace('_', '').isalnum():
- msg = _("Error: component name must contains only alphanumeric "
- "characters and no spaces\n")
+ if not options.name.replace("_", "").isalnum():
+ msg = _(
+ "Error: component name must contains only alphanumeric "
+ "characters and no spaces\n"
+ )
logger.write(src.printcolors.printcError(msg), 1)
logger.write("\n", 1)
return 1
logger.write("\n", 1)
return 1
-
- logger.write(_('Create sources from template\n'), 1)
- src.printcolors.print_value(logger, 'destination', target_dir, 2)
- src.printcolors.print_value(logger, 'name', options.name, 2)
- src.printcolors.print_value(logger, 'template', options.template, 2)
+ logger.write(_("Create sources from template\n"), 1)
+ src.printcolors.print_value(logger, "destination", target_dir, 2)
+ src.printcolors.print_value(logger, "name", options.name, 2)
+ src.printcolors.print_value(logger, "template", options.template, 2)
logger.write("\n", 3, False)
-
+
conf_values = None
if options.param is not None:
conf_values = {}
for elt in options.param.split(","):
- param_def = elt.strip().split('=')
+ param_def = elt.strip().split("=")
if len(param_def) != 2:
msg = _("Error: bad parameter definition")
logger.write(src.printcolors.printcError(msg), 1)
logger.write("\n", 1)
return 1
conf_values[param_def[0].strip()] = param_def[1].strip()
-
- retcode = prepare_from_template(runner.cfg, options.name, options.template,
- target_dir, conf_values, logger)
+
+ retcode = prepare_from_template(
+ runner.cfg, options.name, options.template, target_dir, conf_values, logger
+ )
if retcode == 0:
- logger.write(_(
- "The sources were created in %s") % src.printcolors.printcInfo(
- target_dir), 3)
- logger.write(src.printcolors.printcWarning(_("\nDo not forget to put "
- "them in your version control system.")), 3)
-
+ logger.write(
+ _("The sources were created in %s")
+ % src.printcolors.printcInfo(target_dir),
+ 3,
+ )
+ logger.write(
+ src.printcolors.printcWarning(
+ _("\nDo not forget to put " "them in your version control system.")
+ ),
+ 3,
+ )
+
logger.write("\n", 3)
-
+
return retcode
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2012 CEA/DEN
#
# This library is free software; you can redistribute it and/or
# Define all possible option for the test command : sat test <options>
parser = src.options.Options()
-parser.add_option('b', 'base', 'string', 'base',
- _("""Optional: The name of the test base to use."
+parser.add_option(
+ "b",
+ "base",
+ "string",
+ "base",
+ _(
+ """Optional: The name of the test base to use."
This name has to be registered in your application and in a project.
- A path to a test base can also be used."""))
-parser.add_option('l', 'launcher', 'string', 'launcher',
- _("""Optional: Specify the path to a SALOME launcher
- used to launch the test scripts of the test base."""))
-parser.add_option('g', 'grid', 'list', 'grids',
- _('Optional: Which grid(s) to test (subdirectory of the test base).'))
-parser.add_option('s', 'session', 'list2', 'sessions',
- _('Optional: Which session(s) to test (subdirectory of the grid).'))
-parser.add_option('', 'display', 'string', 'display',
- _("""Optional: Set the display where to launch SALOME.
- If value is NO then option --show-desktop=0 will be used to launch SALOME."""))
-parser.add_option('', 'keep', 'boolean', 'keeptempdir',
- _('Optional: keep temporary big tests directories.'))
+ A path to a test base can also be used."""
+ ),
+)
+parser.add_option(
+ "l",
+ "launcher",
+ "string",
+ "launcher",
+ _(
+ """Optional: Specify the path to a SALOME launcher
+ used to launch the test scripts of the test base."""
+ ),
+)
+parser.add_option(
+ "g",
+ "grid",
+ "list",
+ "grids",
+ _("Optional: Which grid(s) to test (subdirectory of the test base)."),
+)
+parser.add_option(
+ "s",
+ "session",
+ "list2",
+ "sessions",
+ _("Optional: Which session(s) to test (subdirectory of the grid)."),
+)
+parser.add_option(
+ "",
+ "display",
+ "string",
+ "display",
+ _(
+ """Optional: Set the display where to launch SALOME.
+ If value is NO then option --show-desktop=0 will be used to launch SALOME."""
+ ),
+)
+parser.add_option(
+ "",
+ "keep",
+ "boolean",
+ "keeptempdir",
+ _("Optional: keep temporary big tests directories."),
+)
+
+
def description():
- '''method that is called when salomeTools is called with --help option.
-
+ """method that is called when salomeTools is called with --help option.
+
:return: The text to display for the test command description.
:rtype: str
- '''
- return _("The test command runs a test base on a SALOME installation.\n\n"
- "example:\nsat test SALOME-master --grid GEOM --session light")
+ """
+ return _(
+ "The test command runs a test base on a SALOME installation.\n\n"
+ "example:\nsat test SALOME-master --grid GEOM --session light"
+ )
+
def parse_option_old(args, config):
- """ Parse the options and do some verifications about it
-
+ """Parse the options and do some verifications about it
+
:param args List: The list of arguments of the command
:param config Config: The global configuration
:return: the options of the current command launch and the full arguments
options.launcher = ""
elif not os.path.isabs(options.launcher):
if not src.config_has_application(config):
- msg = _("An application is required to use a relative path with option --appli")
+ msg = _(
+ "An application is required to use a relative path with option --appli"
+ )
raise src.SatException(msg)
- options.launcher = os.path.join(config.APPLICATION.workdir,
- options.launcher)
+ options.launcher = os.path.join(config.APPLICATION.workdir, options.launcher)
if not os.path.exists(options.launcher):
- raise src.SatException(_("Launcher not found: %s") %
- options.launcher)
+ raise src.SatException(_("Launcher not found: %s") % options.launcher)
return (options, args)
def parse_option(args, config):
- """ Parse the options and do some verifications about it
+ """Parse the options and do some verifications about it
:param args List: The list of arguments of the command
:param config Config: The global configuration
if not os.path.isabs(options.launcher):
if not src.config_has_application(config):
- msg = _("An application is required to use a relative path with option --appli")
+ msg = _(
+ "An application is required to use a relative path with option --appli"
+ )
raise src.SatException(msg)
else:
- options.launcher = os.path.join(config.APPLICATION.workdir, options.launcher)
+ options.launcher = os.path.join(
+ config.APPLICATION.workdir, options.launcher
+ )
if not os.path.exists(options.launcher):
- raise src.SatException(_("Launcher not found: %s") % options.launcher)
+ raise src.SatException(_("Launcher not found: %s") % options.launcher)
# absolute path
launcher = os.path.realpath(os.path.expandvars(options.launcher))
options.launcher = launcher
return (options, args)
- raise src.SatException(_("Launcher not found: %s") % options.launcher)
+ raise src.SatException(_("Launcher not found: %s") % options.launcher)
def ask_a_path():
- """
- """
+ """ """
path = input("enter a path where to save the result: ")
if path == "":
- result = input("the result will be not save. Are you sure to "
- "continue ? [y/n] ")
+ result = input(
+ "the result will be not save. Are you sure to " "continue ? [y/n] "
+ )
if result == "y":
return path
else:
return ask_a_path()
elif os.path.exists(path):
- result = input("Warning, the content of %s will be deleted. Are you"
- " sure to continue ? [y/n] " % path)
+ result = input(
+ "Warning, the content of %s will be deleted. Are you"
+ " sure to continue ? [y/n] " % path
+ )
if result == "y":
return path
else:
else:
return path
+
def save_file(filename, base):
- f = open(filename, 'r')
+ f = open(filename, "r")
content = f.read()
f.close()
objectname = sha1(content).hexdigest()
- f = gzip.open(os.path.join(base, '.objects', objectname), 'w')
+ f = gzip.open(os.path.join(base, ".objects", objectname), "w")
f.write(content)
f.close()
return objectname
+
def move_test_results(in_dir, what, out_dir, logger):
if out_dir == in_dir:
return
while not pathIsOk:
try:
# create test results directory if necessary
- #logger.write("FINAL = %s\n" % finalPath, 5)
+ # logger.write("FINAL = %s\n" % finalPath, 5)
if not os.access(finalPath, os.F_OK):
- #shutil.rmtree(finalPath)
+ # shutil.rmtree(finalPath)
os.makedirs(finalPath)
pathIsOk = True
except:
finalPath = ask_a_path()
if finalPath != "":
- os.makedirs(os.path.join(finalPath, what, 'BASES'))
+ os.makedirs(os.path.join(finalPath, what, "BASES"))
# check if .objects directory exists
- if not os.access(os.path.join(finalPath, '.objects'), os.F_OK):
- os.makedirs(os.path.join(finalPath, '.objects'))
+ if not os.access(os.path.join(finalPath, ".objects"), os.F_OK):
+ os.makedirs(os.path.join(finalPath, ".objects"))
- logger.write(_('copy tests results to %s ... ') % finalPath, 3)
+ logger.write(_("copy tests results to %s ... ") % finalPath, 3)
logger.flush()
- #logger.write("\n", 5)
+ # logger.write("\n", 5)
# copy env_info.py
- shutil.copy2(os.path.join(in_dir, what, 'env_info.py'),
- os.path.join(finalPath, what, 'env_info.py'))
+ shutil.copy2(
+ os.path.join(in_dir, what, "env_info.py"),
+ os.path.join(finalPath, what, "env_info.py"),
+ )
# for all sub directory (ie testbase) in the BASES directory
- for testbase in os.listdir(os.path.join(in_dir, what, 'BASES')):
- outtestbase = os.path.join(finalPath, what, 'BASES', testbase)
- intestbase = os.path.join(in_dir, what, 'BASES', testbase)
+ for testbase in os.listdir(os.path.join(in_dir, what, "BASES")):
+ outtestbase = os.path.join(finalPath, what, "BASES", testbase)
+ intestbase = os.path.join(in_dir, what, "BASES", testbase)
# ignore files in root dir
if not os.path.isdir(intestbase):
continue
os.makedirs(outtestbase)
- #logger.write(" copy testbase %s\n" % testbase, 5)
+ # logger.write(" copy testbase %s\n" % testbase, 5)
- for grid_ in [m for m in os.listdir(intestbase) \
- if os.path.isdir(os.path.join(intestbase, m))]:
+ for grid_ in [
+ m
+ for m in os.listdir(intestbase)
+ if os.path.isdir(os.path.join(intestbase, m))
+ ]:
# ignore source configuration directories
- if grid_[:4] == '.git' or grid_ == 'CVS':
+ if grid_[:4] == ".git" or grid_ == "CVS":
continue
outgrid = os.path.join(outtestbase, grid_)
ingrid = os.path.join(intestbase, grid_)
os.makedirs(outgrid)
- #logger.write(" copy grid %s\n" % grid_, 5)
+ # logger.write(" copy grid %s\n" % grid_, 5)
- if grid_ == 'RESSOURCES':
+ if grid_ == "RESSOURCES":
for file_name in os.listdir(ingrid):
- if not os.path.isfile(os.path.join(ingrid,
- file_name)):
+ if not os.path.isfile(os.path.join(ingrid, file_name)):
continue
f = open(os.path.join(outgrid, file_name), "w")
- f.write(save_file(os.path.join(ingrid, file_name),
- finalPath))
+ f.write(save_file(os.path.join(ingrid, file_name), finalPath))
f.close()
else:
- for session_name in [t for t in os.listdir(ingrid) if
- os.path.isdir(os.path.join(ingrid, t))]:
+ for session_name in [
+ t
+ for t in os.listdir(ingrid)
+ if os.path.isdir(os.path.join(ingrid, t))
+ ]:
outsession = os.path.join(outgrid, session_name)
insession = os.path.join(ingrid, session_name)
os.makedirs(outsession)
-
+
for file_name in os.listdir(insession):
- if not os.path.isfile(os.path.join(insession,
- file_name)):
+ if not os.path.isfile(os.path.join(insession, file_name)):
continue
- if file_name.endswith('result.py'):
- shutil.copy2(os.path.join(insession, file_name),
- os.path.join(outsession, file_name))
+ if file_name.endswith("result.py"):
+ shutil.copy2(
+ os.path.join(insession, file_name),
+ os.path.join(outsession, file_name),
+ )
else:
f = open(os.path.join(outsession, file_name), "w")
- f.write(save_file(os.path.join(insession,
- file_name),
- finalPath))
+ f.write(
+ save_file(
+ os.path.join(insession, file_name), finalPath
+ )
+ )
f.close()
logger.write(src.printcolors.printc("OK"), 3, False)
logger.write("\n", 3, False)
+
def check_remote_machine(machine_name, logger):
logger.write(_("\ncheck the display on %s\n" % machine_name), 4)
ssh_cmd = 'ssh -o "StrictHostKeyChecking no" %s "ls"' % machine_name
logger.write(_("Executing the command : %s " % ssh_cmd), 4)
- p = subprocess.Popen(ssh_cmd,
- shell=True,
- stdin =subprocess.PIPE,
- stdout=subprocess.PIPE,
- stderr=subprocess.PIPE)
+ p = subprocess.Popen(
+ ssh_cmd,
+ shell=True,
+ stdin=subprocess.PIPE,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE,
+ )
p.wait()
if p.returncode != 0:
logger.write(src.printcolors.printc(src.KO_STATUS) + "\n", 1)
logger.write(" " + src.printcolors.printcError(p.stderr.read()), 2)
- logger.write(src.printcolors.printcWarning((
- "No ssh access to the display machine.")),1)
+ logger.write(
+ src.printcolors.printcWarning(("No ssh access to the display machine.")), 1
+ )
else:
logger.write(src.printcolors.printcSuccess(src.OK_STATUS) + "\n\n", 4)
+
def findOrCreateNode(parentNode, nameNodeToFind):
found = parentNode.find(nameNodeToFind)
if found is None:
- created = add_simple_node(parentNode, nameNodeToFind)
- return created
+ created = add_simple_node(parentNode, nameNodeToFind)
+ return created
else:
- return found
+ return found
+
def purgeEmptyNodes(root):
"""
text = root.text
tail = root.tail
if text is not None:
- if text.replace(" ", "").replace("\n", "") == "":
- # print("purgeEmptyNodes text %s" % root.tag)
- root.text = None
+ if text.replace(" ", "").replace("\n", "") == "":
+ # print("purgeEmptyNodes text %s" % root.tag)
+ root.text = None
if tail is not None:
- if tail.replace(" ", "").replace("\n", "") == "":
- # print("purgeEmptyNodes tail %s" % root.tag)
- root.tail = None
+ if tail.replace(" ", "").replace("\n", "") == "":
+ # print("purgeEmptyNodes tail %s" % root.tag)
+ root.tail = None
for node in root:
- purgeEmptyNodes(node)
+ purgeEmptyNodes(node)
return
+
##
# Creates the XML report for a product.
-def create_test_report(config,
- xml_history_path,
- dest_path,
- retcode,
- xmlname=""):
+def create_test_report(config, xml_history_path, dest_path, retcode, xmlname=""):
# get the date and hour of the launching of the command, in order to keep
# history
date_hour = config.VARS.datehour
-
+
# Get some information to put in the xml file
application_name = config.VARS.application
withappli = src.config_has_application(config)
-
+
first_time = False
if not os.path.exists(xml_history_path):
print("Log file creation %s" % xml_history_path)
purgeEmptyNodes(root)
prod_node = root.find("product")
-
prod_node.attrib["history_file"] = os.path.basename(xml_history_path)
prod_node.attrib["global_res"] = str(retcode)
if withappli:
if not first_time:
- for node in (prod_node.findall("version_to_download") +
- prod_node.findall("out_dir")):
+ for node in prod_node.findall("version_to_download") + prod_node.findall(
+ "out_dir"
+ ):
prod_node.remove(node)
-
+
add_simple_node(prod_node, "version_to_download", config.APPLICATION.name)
add_simple_node(prod_node, "out_dir", config.APPLICATION.workdir)
if not first_time:
for node in prod_node.findall("exec"):
prod_node.remove(node)
-
+
exec_node = add_simple_node(prod_node, "exec")
exec_node.append(etree.Element("env", name="Host", value=config.VARS.node))
exec_node.append(etree.Element("env", name="Architecture", value=config.VARS.dist))
- exec_node.append(etree.Element("env", name="Number of processors", value=str(config.VARS.nb_proc)))
- exec_node.append(etree.Element("env", name="Begin date", value=src.parse_date(date_hour)))
+ exec_node.append(
+ etree.Element(
+ "env", name="Number of processors", value=str(config.VARS.nb_proc)
+ )
+ )
+ exec_node.append(
+ etree.Element("env", name="Begin date", value=src.parse_date(date_hour))
+ )
exec_node.append(etree.Element("env", name="Command", value=config.VARS.command))
- exec_node.append(etree.Element("env", name="sat version", value=config.INTERNAL.sat_version))
+ exec_node.append(
+ etree.Element("env", name="sat version", value=config.INTERNAL.sat_version)
+ )
- if 'TESTS' in config:
+ if "TESTS" in config:
tests = findOrCreateNode(prod_node, "tests")
known_errors = findOrCreateNode(prod_node, "known_errors")
new_errors = findOrCreateNode(prod_node, "new_errors")
amend = findOrCreateNode(prod_node, "amend")
-
+
tt = {}
for test in config.TESTS:
if not test.testbase in tt:
tt[test.testbase] = [test]
else:
tt[test.testbase].append(test)
-
+
for testbase in tt.keys():
- if verbose: print("---- create_test_report %s %s" % (testbase, first_time))
+ if verbose:
+ print("---- create_test_report %s %s" % (testbase, first_time))
gn = findOrCreateNode(tests, "testbase")
# initialize all grids and session to "not executed"
mn.attrib["executed_last_time"] = "no"
for tyn in mn.findall("session"):
tyn.attrib["executed_last_time"] = "no"
- for test_node in tyn.findall('test'):
+ for test_node in tyn.findall("test"):
for node in test_node.getchildren():
if node.tag != "history":
test_node.remove(node)
attribs_to_pop = []
for attribute in test_node.attrib:
- if (attribute != "script" and
- attribute != "res"):
+ if attribute != "script" and attribute != "res":
attribs_to_pop.append(attribute)
for attribute in attribs_to_pop:
test_node.attrib.pop(attribute)
-
- gn.attrib['name'] = testbase
+
+ gn.attrib["name"] = testbase
nb, nb_pass, nb_failed, nb_timeout, nb_not_run = 0, 0, 0, 0, 0
grids = {}
sessions = {}
if not (test.grid in grids):
if first_time:
mn = add_simple_node(gn, "grid")
- mn.attrib['name'] = test.grid
+ mn.attrib["name"] = test.grid
else:
l_mn = gn.findall("grid")
mn = None
for grid_node in l_mn:
- if grid_node.attrib['name'] == test.grid:
+ if grid_node.attrib["name"] == test.grid:
mn = grid_node
break
if mn == None:
mn = add_simple_node(gn, "grid")
- mn.attrib['name'] = test.grid
-
+ mn.attrib["name"] = test.grid
+
grids[test.grid] = mn
-
+
mn.attrib["executed_last_time"] = "yes"
-
+
if not "%s/%s" % (test.grid, test.session) in sessions:
if first_time:
tyn = add_simple_node(mn, "session")
- tyn.attrib['name'] = test.session
+ tyn.attrib["name"] = test.session
else:
l_tyn = mn.findall("session")
tyn = None
for session_node in l_tyn:
- if session_node.attrib['name'] == test.session:
+ if session_node.attrib["name"] == test.session:
tyn = session_node
break
if tyn == None:
tyn = add_simple_node(mn, "session")
- tyn.attrib['name'] = test.session
-
+ tyn.attrib["name"] = test.session
+
sessions["%s/%s" % (test.grid, test.session)] = tyn
tyn.attrib["executed_last_time"] = "yes"
for script in test.script:
if first_time:
- tn = add_simple_node(sessions[
- "%s/%s" % (test.grid, test.session)],
- "test")
- tn.attrib['session'] = test.session
- tn.attrib['script'] = script.name
+ tn = add_simple_node(
+ sessions["%s/%s" % (test.grid, test.session)], "test"
+ )
+ tn.attrib["session"] = test.session
+ tn.attrib["script"] = script.name
hn = add_simple_node(tn, "history")
else:
l_tn = sessions["%s/%s" % (test.grid, test.session)].findall(
- "test")
+ "test"
+ )
tn = None
for test_node in l_tn:
- if test_node.attrib['script'] == script['name']:
+ if test_node.attrib["script"] == script["name"]:
tn = test_node
break
-
+
if tn == None:
- tn = add_simple_node(sessions[
- "%s/%s" % (test.grid, test.session)],
- "test")
- tn.attrib['session'] = test.session
- tn.attrib['script'] = script.name
+ tn = add_simple_node(
+ sessions["%s/%s" % (test.grid, test.session)], "test"
+ )
+ tn.attrib["session"] = test.session
+ tn.attrib["script"] = script.name
hn = add_simple_node(tn, "history")
else:
# Get or create the history node for the current test
else:
hn = tn.find("history")
# Put the last test data into the history
- if 'res' in tn.attrib:
- attributes = {"date_hour" : date_hour,
- "res" : tn.attrib['res'] }
- add_simple_node(hn,
- "previous_test",
- attrib=attributes)
+ if "res" in tn.attrib:
+ attributes = {
+ "date_hour": date_hour,
+ "res": tn.attrib["res"],
+ }
+ add_simple_node(hn, "previous_test", attrib=attributes)
for node in tn:
if node.tag != "history":
tn.remove(node)
-
- if 'callback' in script:
+
+ if "callback" in script:
try:
cnode = add_simple_node(tn, "callback")
- if True: # bug xml mal forme colorisation src.architecture.is_windows():
+ if (
+ True
+ ): # bug xml mal forme colorisation src.architecture.is_windows():
import string
+
cnode.text = filter(
- lambda x: x in string.printable,
- script.callback)
+ lambda x: x in string.printable, script.callback
+ )
else:
- cnode.text = script.callback.decode(
- 'string_escape')
+ cnode.text = script.callback.decode("string_escape")
except UnicodeDecodeError as exc:
- zz = (script.callback[:exc.start] +
- '?' +
- script.callback[exc.end-2:])
+ zz = (
+ script.callback[: exc.start]
+ + "?"
+ + script.callback[exc.end - 2 :]
+ )
cnode = add_simple_node(tn, "callback")
cnode.text = zz.decode("UTF-8")
-
+
# Add the script content
cnode = add_simple_node(tn, "content")
cnode.text = script.content
-
+
# Add the script execution log
cnode = add_simple_node(tn, "out")
cnode.text = script.out
-
- if 'amend' in script:
+
+ if "amend" in script:
cnode = add_simple_node(tn, "amend")
cnode.text = script.amend.decode("UTF-8")
if script.time < 0:
- tn.attrib['exec_time'] = "?"
+ tn.attrib["exec_time"] = "?"
else:
- tn.attrib['exec_time'] = "%.3f" % script.time
- tn.attrib['res'] = script.res
+ tn.attrib["exec_time"] = "%.3f" % script.time
+ tn.attrib["res"] = script.res
if "amend" in script:
amend_test = add_simple_node(amend, "atest")
- amend_test.attrib['name'] = os.path.join(test.grid,
- test.session,
- script.name)
- amend_test.attrib['reason'] = script.amend.decode(
- "UTF-8")
+ amend_test.attrib["name"] = os.path.join(
+ test.grid, test.session, script.name
+ )
+ amend_test.attrib["reason"] = script.amend.decode("UTF-8")
# calculate status
nb += 1
- if script.res == src.OK_STATUS: nb_pass += 1
- elif script.res == src.TIMEOUT_STATUS: nb_timeout += 1
- elif script.res == src.KO_STATUS: nb_failed += 1
- else: nb_not_run += 1
+ if script.res == src.OK_STATUS:
+ nb_pass += 1
+ elif script.res == src.TIMEOUT_STATUS:
+ nb_timeout += 1
+ elif script.res == src.KO_STATUS:
+ nb_failed += 1
+ else:
+ nb_not_run += 1
if "known_error" in script:
kf_script = add_simple_node(known_errors, "error")
- kf_script.attrib['name'] = os.path.join(test.grid,
- test.session,
- script.name)
- kf_script.attrib['date'] = script.known_error.date
- kf_script.attrib[
- 'expected'] = script.known_error.expected
- kf_script.attrib[
- 'comment'] = script.known_error.comment.decode("UTF-8")
- kf_script.attrib['fixed'] = str(
- script.known_error.fixed)
- overdue = datetime.datetime.today().strftime("%Y-%m-"
- "%d") > script.known_error.expected
+ kf_script.attrib["name"] = os.path.join(
+ test.grid, test.session, script.name
+ )
+ kf_script.attrib["date"] = script.known_error.date
+ kf_script.attrib["expected"] = script.known_error.expected
+ kf_script.attrib["comment"] = script.known_error.comment.decode(
+ "UTF-8"
+ )
+ kf_script.attrib["fixed"] = str(script.known_error.fixed)
+ overdue = (
+ datetime.datetime.today().strftime("%Y-%m-" "%d")
+ > script.known_error.expected
+ )
if overdue:
- kf_script.attrib['overdue'] = str(overdue)
-
+ kf_script.attrib["overdue"] = str(overdue)
+
elif script.res == src.KO_STATUS:
new_err = add_simple_node(new_errors, "new_error")
- script_path = os.path.join(test.grid,
- test.session, script.name)
- new_err.attrib['name'] = script_path
- new_err.attrib['cmd'] = ("sat testerror %s -s %s -c 'my"
- " comment' -p %s" % \
- (application_name, script_path, config.VARS.dist))
-
-
- gn.attrib['total'] = str(nb)
- gn.attrib['pass'] = str(nb_pass)
- gn.attrib['failed'] = str(nb_failed)
- gn.attrib['timeout'] = str(nb_timeout)
- gn.attrib['not_run'] = str(nb_not_run)
-
- # Remove the res attribute of all tests that were not launched
- # this time
+ script_path = os.path.join(test.grid, test.session, script.name)
+ new_err.attrib["name"] = script_path
+ new_err.attrib[
+ "cmd"
+ ] = "sat testerror %s -s %s -c 'my" " comment' -p %s" % (
+ application_name,
+ script_path,
+ config.VARS.dist,
+ )
+
+ gn.attrib["total"] = str(nb)
+ gn.attrib["pass"] = str(nb_pass)
+ gn.attrib["failed"] = str(nb_failed)
+ gn.attrib["timeout"] = str(nb_timeout)
+ gn.attrib["not_run"] = str(nb_not_run)
+
+ # Remove the res attribute of all tests that were not launched
+ # this time
for mn in gn.findall("grid"):
if mn.attrib["executed_last_time"] == "no":
for tyn in mn.findall("session"):
if tyn.attrib["executed_last_time"] == "no":
- for test_node in tyn.findall('test'):
+ for test_node in tyn.findall("test"):
if "res" in test_node.attrib:
- test_node.attrib.pop("res")
-
+ test_node.attrib.pop("res")
+
if len(xmlname) == 0:
xmlname = application_name
if not xmlname.endswith(".xml"):
src.xmlManager.write_report(xml_history_path, root, "test_history.xsl")
return src.OK_STATUS
+
def generate_history_xml_path(config, test_base):
"""Generate the name of the xml file that contain the history of the tests
on the machine with the current APPLICATION and the current test base.
-
+
:param config Config: The global configuration
:param test_base Str: The test base name (or path)
:return: the full path of the history xml file
history_xml_name = ""
if "APPLICATION" in config:
history_xml_name += config.APPLICATION.name
- history_xml_name += "-"
+ history_xml_name += "-"
history_xml_name += config.VARS.dist
history_xml_name += "-"
test_base_name = test_base
log_dir = src.get_log_path(config)
return os.path.join(log_dir, "TEST", history_xml_name)
+
def run(args, runner, logger):
- '''method that is called when salomeTools is called with test parameter.
- '''
+ """method that is called when salomeTools is called with test parameter."""
(options, args) = parse_option(args, runner.cfg)
# the test base is specified either by the application, or by the --base option
with_application = False
- if runner.cfg.VARS.application != 'None':
- logger.write(_('Running tests on application %s\n') %
- src.printcolors.printcLabel(
- runner.cfg.VARS.application), 1)
+ if runner.cfg.VARS.application != "None":
+ logger.write(
+ _("Running tests on application %s\n")
+ % src.printcolors.printcLabel(runner.cfg.VARS.application),
+ 1,
+ )
with_application = True
elif not options.base:
- raise src.SatException(_('A test base is required. Use the --base '
- 'option'))
+ raise src.SatException(_("A test base is required. Use the --base " "option"))
# the launcher is specified either by the application, or by the --launcher option
if with_application:
# check if environment is loaded
- if 'KERNEL_ROOT_DIR' in os.environ:
- logger.write(src.printcolors.printcWarning(_("WARNING: "
- "SALOME environment already sourced")) + "\n", 1)
-
-
+ if "KERNEL_ROOT_DIR" in os.environ:
+ logger.write(
+ src.printcolors.printcWarning(
+ _("WARNING: " "SALOME environment already sourced")
+ )
+ + "\n",
+ 1,
+ )
+
elif options.launcher:
- logger.write(src.printcolors.printcWarning(_("Running SALOME "
- "application.")) + "\n\n", 1)
+ logger.write(
+ src.printcolors.printcWarning(_("Running SALOME " "application.")) + "\n\n",
+ 1,
+ )
else:
- msg = _("Impossible to find any launcher.\nPlease specify an "
- "application or a launcher")
+ msg = _(
+ "Impossible to find any launcher.\nPlease specify an "
+ "application or a launcher"
+ )
logger.write(src.printcolors.printcError(msg))
logger.write("\n")
return 1
# set the display
- show_desktop = (options.display and options.display.upper() == "NO")
+ show_desktop = options.display and options.display.upper() == "NO"
if options.display and options.display != "NO":
- remote_name = options.display.split(':')[0]
+ remote_name = options.display.split(":")[0]
if remote_name != "" and (not src.architecture.is_windows()):
check_remote_machine(remote_name, logger)
# if explicitly set use user choice
- os.environ['DISPLAY'] = options.display
- elif 'DISPLAY' not in os.environ:
+ os.environ["DISPLAY"] = options.display
+ elif "DISPLAY" not in os.environ:
# if no display set
- if ('test' in runner.cfg.LOCAL and
- 'display' in runner.cfg.LOCAL.test and
- len(runner.cfg.LOCAL.test.display) > 0):
+ if (
+ "test" in runner.cfg.LOCAL
+ and "display" in runner.cfg.LOCAL.test
+ and len(runner.cfg.LOCAL.test.display) > 0
+ ):
# use default value for test tool
- os.environ['DISPLAY'] = runner.cfg.LOCAL.test.display
+ os.environ["DISPLAY"] = runner.cfg.LOCAL.test.display
else:
- os.environ['DISPLAY'] = "localhost:0.0"
+ os.environ["DISPLAY"] = "localhost:0.0"
# initialization
#################
if with_application:
- tmp_dir = os.path.join(runner.cfg.VARS.tmp_root,
- runner.cfg.APPLICATION.name,
- "test")
+ tmp_dir = os.path.join(
+ runner.cfg.VARS.tmp_root, runner.cfg.APPLICATION.name, "test"
+ )
else:
- tmp_dir = os.path.join(runner.cfg.VARS.tmp_root,
- "test")
+ tmp_dir = os.path.join(runner.cfg.VARS.tmp_root, "test")
# remove previous tmp dir
if os.access(tmp_dir, os.F_OK):
try:
shutil.rmtree(tmp_dir)
except:
- logger.error(_("error removing TT_TMP_RESULT %s\n")
- % tmp_dir)
+ logger.error(_("error removing TT_TMP_RESULT %s\n") % tmp_dir)
lines = []
lines.append("date = '%s'" % runner.cfg.VARS.date)
lines.append("node = '%s'" % runner.cfg.VARS.node)
lines.append("arch = '%s'" % runner.cfg.VARS.dist)
- if 'APPLICATION' in runner.cfg:
+ if "APPLICATION" in runner.cfg:
lines.append("application_info = {}")
- lines.append("application_info['name'] = '%s'" %
- runner.cfg.APPLICATION.name)
- lines.append("application_info['tag'] = '%s'" %
- runner.cfg.APPLICATION.tag)
- lines.append("application_info['products'] = %s" %
- str(runner.cfg.APPLICATION.products))
+ lines.append("application_info['name'] = '%s'" % runner.cfg.APPLICATION.name)
+ lines.append("application_info['tag'] = '%s'" % runner.cfg.APPLICATION.tag)
+ lines.append(
+ "application_info['products'] = %s" % str(runner.cfg.APPLICATION.products)
+ )
content = "\n".join(lines)
# create hash from context information
# CVW TODO or not dirname = datetime.datetime.now().strftime("%y%m%d_%H%M%S_") + sha1(content.encode()).hexdigest()[0:8]
- dirname = sha1(content.encode()).hexdigest()[0:8] # only 8 firsts probably good
+ dirname = sha1(content.encode()).hexdigest()[0:8] # only 8 firsts probably good
base_dir = os.path.join(tmp_dir, dirname)
os.makedirs(base_dir)
- os.environ['TT_TMP_RESULT'] = base_dir
+ os.environ["TT_TMP_RESULT"] = base_dir
# create env_info file
- with open(os.path.join(base_dir, 'env_info.py'), "w") as f:
+ with open(os.path.join(base_dir, "env_info.py"), "w") as f:
f.write(content)
# create working dir and bases dir
- working_dir = os.path.join(base_dir, 'WORK')
+ working_dir = os.path.join(base_dir, "WORK")
os.makedirs(working_dir)
- os.makedirs(os.path.join(base_dir, 'BASES'))
+ os.makedirs(os.path.join(base_dir, "BASES"))
os.chdir(working_dir)
- if 'PYTHONPATH' not in os.environ:
- os.environ['PYTHONPATH'] = ''
+ if "PYTHONPATH" not in os.environ:
+ os.environ["PYTHONPATH"] = ""
else:
- for var in os.environ['PYTHONPATH'].split(':'):
+ for var in os.environ["PYTHONPATH"].split(":"):
if var not in sys.path:
sys.path.append(var)
elif with_application and "test_base" in runner.cfg.APPLICATION:
test_base = runner.cfg.APPLICATION.test_base.name
- src.printcolors.print_value(logger, _('Display'), os.environ['DISPLAY'], 2)
- src.printcolors.print_value(logger, _('Timeout'),
- src.test_module.DEFAULT_TIMEOUT, 2)
+ src.printcolors.print_value(logger, _("Display"), os.environ["DISPLAY"], 2)
+ src.printcolors.print_value(
+ logger, _("Timeout"), src.test_module.DEFAULT_TIMEOUT, 2
+ )
src.printcolors.print_value(logger, _("Working dir"), base_dir, 3)
# create the test object
- test_runner = src.test_module.Test(runner.cfg,
- logger,
- base_dir,
- testbase=test_base,
- grids=options.grids,
- sessions=options.sessions,
- launcher=options.launcher,
- show_desktop=show_desktop)
-
+ test_runner = src.test_module.Test(
+ runner.cfg,
+ logger,
+ base_dir,
+ testbase=test_base,
+ grids=options.grids,
+ sessions=options.sessions,
+ launcher=options.launcher,
+ show_desktop=show_desktop,
+ )
+
if not test_runner.test_base_found:
- # Fail
+ # Fail
return 1
-
+
# run the test
logger.allowPrintLevel = False
retcode = test_runner.run_all_tests()
logger.write(_("Tests finished"), 1)
logger.write("\n", 2, False)
-
+
logger.write(_("\nGenerate the specific test log\n"), 5)
log_dir = src.get_log_path(runner.cfg)
out_dir = os.path.join(log_dir, "TEST")
src.ensure_path_exists(out_dir)
name_xml_board = logger.logFileName.split(".")[0] + "_board.xml"
historic_xml_path = generate_history_xml_path(runner.cfg, test_base)
-
- create_test_report(runner.cfg,
- historic_xml_path,
- out_dir,
- retcode,
- xmlname = name_xml_board)
+
+ create_test_report(
+ runner.cfg, historic_xml_path, out_dir, retcode, xmlname=name_xml_board
+ )
xml_board_path = os.path.join(out_dir, name_xml_board)
logger.l_logFiles.append(xml_board_path)
- logger.add_link(os.path.join("TEST", name_xml_board),
- "board",
- retcode,
- "Click on the link to get the detailed test results")
+ logger.add_link(
+ os.path.join("TEST", name_xml_board),
+ "board",
+ retcode,
+ "Click on the link to get the detailed test results",
+ )
logger.write("\nTests board file %s\n" % xml_board_path, 1)
# Add the historic files into the log files list of the command
logger.l_logFiles.append(historic_xml_path)
if not options.keeptempdir:
- logger.write("Removing the temporary directory: rm -rf %s\n" % test_runner.tmp_working_dir, 5)
- if os.path.exists(test_runner.tmp_working_dir):
- shutil.rmtree(test_runner.tmp_working_dir)
+ logger.write(
+ "Removing the temporary directory: rm -rf %s\n"
+ % test_runner.tmp_working_dir,
+ 5,
+ )
+ if os.path.exists(test_runner.tmp_working_dir):
+ shutil.rmtree(test_runner.tmp_working_dir)
else:
- logger.write("NOT Removing the temporary directory: rm -rf %s\n" % test_runner.tmp_working_dir, 5)
+ logger.write(
+ "NOT Removing the temporary directory: rm -rf %s\n"
+ % test_runner.tmp_working_dir,
+ 5,
+ )
return retcode
-
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-import re
import os
-import pprint as PP
-
import src
-import src.debug as DBG
# Define all possible option for update command : sat update <options>
"products",
_("Optional: products to update. This option accepts a comma separated list."),
)
-parser.add_option('f', 'force', 'boolean', 'force',
- _("Optional: force to update the products in development mode."))
-parser.add_option('', 'force_patch', 'boolean', 'force_patch',
- _("Optional: force to apply patch to the products in development mode."))
+parser.add_option(
+ "f",
+ "force",
+ "boolean",
+ "force",
+ _("Optional: force to update the products in development mode."),
+)
+parser.add_option(
+ "",
+ "force_patch",
+ "boolean",
+ "force_patch",
+ _("Optional: force to apply patch to the products in development mode."),
+)
# parser.add_option('c', 'complete', 'boolean', 'complete',
# _("Optional: completion mode, only update products not present in SOURCES dir."),
# False)
"""
l_res = []
for p_name_p_cfg in l_products:
- __, prod_cfg = p_name_p_cfg
+ _, prod_cfg = p_name_p_cfg
if "source_dir" in prod_cfg and os.path.exists(prod_cfg.source_dir):
l_res.append(p_name_p_cfg)
return l_res
+
def find_git_products(l_products):
"""
function that returns the list of products that have an existing source
"""
l_res = []
for p_name_p_cfg in l_products:
- __, prod_cfg = p_name_p_cfg
+ _, prod_cfg = p_name_p_cfg
if "source_dir" in prod_cfg and os.path.exists(prod_cfg.source_dir):
if prod_cfg.get_source == "git":
l_res.append(p_name_p_cfg)
"""
l_res = []
for p_name_p_cfg in l_products:
- __, prod_cfg = p_name_p_cfg
+ _, prod_cfg = p_name_p_cfg
l_patchs = src.get_cfg_param(prod_cfg, "patches", [])
if len(l_patchs) > 0:
l_res.append(p_name_p_cfg)
"\n\nexample:\nsat update SALOME-master --products KERNEL,GUI"
)
+
class UpdateOp:
"""
This is an operation class. It is prepared though the init and launched
self.runner = runner
self.logger = logger
- self.products_infos = src.product.get_products_list(options, self.runner.cfg, self.logger)
+ self.products_infos = src.product.get_products_list(
+ options, self.runner.cfg, self.logger
+ )
# Construct the arguments to pass to the clean, source and patch commands
self.args_appli = runner.cfg.VARS.application + " " # useful whitespace
def products(self):
if self._list_of_products:
return list(self._list_of_products)
- return [name for name, tmp in self.products_infos]
+ return [name for name, _ in self.products_infos]
def getProductsToPrepare(self):
"""
that only new products (and not tracked ones) are prepared.
"""
pi_already_prepared = find_git_products(self.products_infos)
- l_already_prepared = [i for i, tmp in pi_already_prepared]
+ l_already_prepared = [i for i, _ in pi_already_prepared]
newList, removedList = removeInList(self.products, l_already_prepared)
if len(newList) == 0 and len(removedList) > 0:
msg = "\nAll the products are already installed, do nothing!\n"
def getProductsToUpdate(self):
pi_already_prepared = find_git_products(self.products_infos)
- productsToUpdate = [i for i, tmp in pi_already_prepared]
+ productsToUpdate = [i for i, _ in pi_already_prepared]
return productsToUpdate
def getProductsToClean(self, listProdToPrepare):
- ldev_products = [p for p in self.products_infos if src.product.product_is_dev(p[1])]
+ ldev_products = [
+ p for p in self.products_infos if src.product.product_is_dev(p[1])
+ ]
productsToClean = listProdToPrepare # default
if len(ldev_products) > 0:
l_products_not_getted = find_products_already_prepared(ldev_products)
- listNot = [i for i, tmp in l_products_not_getted]
+ listNot = [i for i, _ in l_products_not_getted]
productsToClean, removedList = removeInList(listProdToPrepare, listNot)
if len(removedList) > 0:
msg = _(
def getProductsToPatch(self, listProdToPrepare):
productsToPatch = listProdToPrepare # default
- ldev_products = [p for p in self.products_infos if src.product.product_is_dev(p[1])]
+ ldev_products = [
+ p for p in self.products_infos if src.product.product_is_dev(p[1])
+ ]
if not self._force_patch and len(ldev_products) > 0:
l_products_with_patchs = find_products_with_patchs(ldev_products)
- listNot = [i for i, tmp in l_products_with_patchs]
+ listNot = [i for i, _ in l_products_with_patchs]
productsToPatch, removedList = removeInList(listProdToPrepare, listNot)
if len(removedList) > 0:
msg = _(
productsToPatch = self.getProductsToPatch(productsToPrepare)
args_product_opt_patch = "--products " + ",".join(productsToPatch)
-
# Initialize the results to a running status
res_clean = 0
res_source = 0
self.logger.write(msg, 3)
self.logger.flush()
args_clean = self.args_appli + args_product_opt_clean + " --sources"
- res_clean = self.runner.clean(args_clean, batch=True, verbose = 0, logger_add_link = self.logger)
+ res_clean = self.runner.clean(
+ args_clean, batch=True, verbose=0, logger_add_link=self.logger
+ )
if res_clean == 0:
- self.logger.write('%s\n' % src.printcolors.printc(src.OK_STATUS), 3)
+ self.logger.write("%s\n" % src.printcolors.printc(src.OK_STATUS), 3)
else:
- self.logger.write('%s\n' % src.printcolors.printc(src.KO_STATUS), 3)
+ self.logger.write("%s\n" % src.printcolors.printc(src.KO_STATUS), 3)
if len(productsToPrepare) > 0:
msg = _("Get the sources of the products ...")
self.logger.write(msg, 5)
args_source = self.args_appli + args_product_to_prepare_opt
- res_source = self.runner.source(args_source, logger_add_link=self.logger)
+ res_source = self.runner.source(
+ args_source, logger_add_link=self.logger
+ )
if res_source == 0:
self.logger.write("%s\n" % src.printcolors.printc(src.OK_STATUS), 5)
else:
msg = _("Update the sources of the products ...")
self.logger.write(msg, 5)
args_source = self.args_appli + args_product_to_update_opt
- res_source = self.runner.source_update(args_source, logger_add_link=self.logger)
+ res_source = self.runner.source_update(
+ args_source, logger_add_link=self.logger
+ )
if res_source == 0:
self.logger.write("%s\n" % src.printcolors.printc(src.OK_STATUS), 5)
else:
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# This script is used to build the application module.
# First, it copies the content of the sources directory to the install directory.
import src
+
def compil(config, builder, logger):
builder.prepare()
if not builder.source_dir.smartcopy(builder.install_dir):
- raise src.SatException(_("Error when copying %s sources to install dir") % builder.product_info.name)
-
+ raise src.SatException(
+ _("Error when copying %s sources to install dir")
+ % builder.product_info.name
+ )
+
# test lrelease #.pyconf needs in ..._APPLI pre_depend : ['qt']
- command = "which lrelease"
- res = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE,env=builder.build_environ.environ.environ).communicate()
- if res[1] != "": #an error occured
+ command = "which lrelease"
+ res = subprocess.Popen(
+ command,
+ shell=True,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE,
+ env=builder.build_environ.environ.environ,
+ ).communicate()
+ if res[1] != "": # an error occured
logger.write("ERROR: %s" % res[1])
- builder.log(res[1]+"\n")
+ builder.log(res[1] + "\n")
return 1
-
+
# run lrelease
command = "lrelease *.ts"
- res = subprocess.call(command,
- shell=True,
- cwd=str(builder.install_dir + "resources"),
- env=builder.build_environ.environ.environ,
- stdout=logger.logTxtFile,
- stderr=subprocess.STDOUT)
+ res = subprocess.call(
+ command,
+ shell=True,
+ cwd=str(builder.install_dir + "resources"),
+ env=builder.build_environ.environ.environ,
+ stdout=logger.logTxtFile,
+ stderr=subprocess.STDOUT,
+ )
if res != 0:
res = 1
-
+
return res
from Polyline import Polyline
from Circle import Circle
-class Controller() :
+
+class Controller:
"""Manages the Model instances"""
- def __init__( self, MainFrame ) :
+ def __init__(self, MainFrame):
"""Constructor"""
self._models = []
self._nbCircles = 0
pass
- def getModels( self ) :
+ def getModels(self):
return self._models
- def getMainFrame( self ) :
+ def getMainFrame(self):
return self._mainFrame
- def getNbPolylines( self ) :
+ def getNbPolylines(self):
return self._nbPolylines
- def setNbPolylines( self, n ) :
+ def setNbPolylines(self, n):
self._nbPolylines = n
pass
- def getNbCircles( self ) :
+ def getNbCircles(self):
return self._nbCircles
- def setNbCircles( self, n ) :
+ def setNbCircles(self, n):
self._nbCircles = n
pass
- def createPolyline( self, name, randomNumberOfPoints ) :
+ def createPolyline(self, name, randomNumberOfPoints):
"""Creates a Polyline object nammed name with randomNumberOfPoints points"""
import random
# Making randomNumberOfPoints random positionned points
points = []
- x = random.uniform( 0, randomNumberOfPoints )
- for i in range( randomNumberOfPoints ) :
- x = random.uniform( x, x+randomNumberOfPoints )
- y = random.uniform( 0, x )
- point = x, y
- points.append( point )
- pass
-
- myPolyline = Polyline( name, points, self )
- self._models.append( myPolyline )
- myPolyline.updateViews( mode = 'creation' )
-
- self._nbPolylines +=1
+ x = random.uniform(0, randomNumberOfPoints)
+ for i in range(randomNumberOfPoints):
+ x = random.uniform(x, x + randomNumberOfPoints)
+ y = random.uniform(0, x)
+ point = x, y
+ points.append(point)
+ pass
+
+ myPolyline = Polyline(name, points, self)
+ self._models.append(myPolyline)
+ myPolyline.updateViews(mode="creation")
+
+ self._nbPolylines += 1
return myPolyline
- def createCircle( self, name, center, radius ) :
+ def createCircle(self, name, center, radius):
"""Creates a Circle object nammed name with center and radius"""
- myCircle = Circle( name, center, radius, self )
- self._models.append( myCircle )
- myCircle.updateViews( mode = 'creation' )
+ myCircle = Circle(name, center, radius, self)
+ self._models.append(myCircle)
+ myCircle.updateViews(mode="creation")
- self._nbCircles +=1
+ self._nbCircles += 1
return myCircle
- def showModel( self, model ) :
- model.updateViews( mode = 'showing' )
+ def showModel(self, model):
+ model.updateViews(mode="showing")
pass
- def editName( self, model, name ) :
- model.setName( name )
- model.updateViews( mode = 'modification' )
+ def editName(self, model, name):
+ model.setName(name)
+ model.updateViews(mode="modification")
return model
- def editPoint( self, polyline, newPoint, pointRange ) :
- polyline.editPoint( pointRange, newPoint )
- polyline.updateViews( mode = 'modification' )
+ def editPoint(self, polyline, newPoint, pointRange):
+ polyline.editPoint(pointRange, newPoint)
+ polyline.updateViews(mode="modification")
return polyline
- def editCenter( self, circle, center ) :
- circle.setCenter( center )
- circle.updateViews( mode = 'modification' )
+ def editCenter(self, circle, center):
+ circle.setCenter(center)
+ circle.updateViews(mode="modification")
return circle
- def editRadius( self, circle, radius ) :
- circle.setRadius( radius )
- circle.updateViews( mode = 'modification' )
+ def editRadius(self, circle, radius):
+ circle.setRadius(radius)
+ circle.updateViews(mode="modification")
return circle
- def removeModel( self, model ) :
- model.updateViews( mode = 'supression' )
- index = self._models.index( model )
+ def removeModel(self, model):
+ model.updateViews(mode="supression")
+ index = self._models.index(model)
del model
pass
- def saveListOfModels( self ) :
- for model in self._models :
- model.save()
- pass
+ def saveListOfModels(self):
+ for model in self._models:
+ model.save()
+ pass
pass
+
pass
from Dialog import *
from qtsalome import *
-class CreateCircleDialog( Dialog ) :
- def __init__( self, helpFile, controller, widgetDialogBox ) :
- """Constructor"""
+class CreateCircleDialog(Dialog):
+ def __init__(self, helpFile, controller, widgetDialogBox):
+ """Constructor"""
- # Initializing parent widget
- Dialog.__init__( self, helpFile, controller, widgetDialogBox )
+ # Initializing parent widget
+ Dialog.__init__(self, helpFile, controller, widgetDialogBox)
- # Setting default name
- nbCircles = controller.getNbCircles()
- self.entryName.setText( "circle_" + str(nbCircles+1) )
- pass
+ # Setting default name
+ nbCircles = controller.getNbCircles()
+ self.entryName.setText("circle_" + str(nbCircles + 1))
+ pass
- def addSpecialWidgets( self ) :
- floatValidator = QDoubleValidator( self )
+ def addSpecialWidgets(self):
+ floatValidator = QDoubleValidator(self)
- lxCenter = QLabel( "xCenter", self )
- self.v11.addWidget( lxCenter )
- lyCenter = QLabel( "yCenter", self )
- self.v11.addWidget( lyCenter )
- lRadius = QLabel( "Radius", self )
- self.v11.addWidget( lRadius )
+ lxCenter = QLabel("xCenter", self)
+ self.v11.addWidget(lxCenter)
+ lyCenter = QLabel("yCenter", self)
+ self.v11.addWidget(lyCenter)
+ lRadius = QLabel("Radius", self)
+ self.v11.addWidget(lRadius)
- self.entryxCenter = QLineEdit( self )
- self.entryxCenter.setValidator( floatValidator )
- self.entryxCenter.setText( "0" )
- self.v12.addWidget( self.entryxCenter )
- self.entryyCenter = QLineEdit( self )
- self.entryyCenter.setValidator( floatValidator )
- self.entryyCenter.setText( "0" )
- self.v12.addWidget( self.entryyCenter )
- self.entryRadius = QLineEdit( self )
- self.entryRadius.setValidator( floatValidator )
- self.entryRadius.setText( "10" )
- self.v12.addWidget( self.entryRadius)
- pass
+ self.entryxCenter = QLineEdit(self)
+ self.entryxCenter.setValidator(floatValidator)
+ self.entryxCenter.setText("0")
+ self.v12.addWidget(self.entryxCenter)
+ self.entryyCenter = QLineEdit(self)
+ self.entryyCenter.setValidator(floatValidator)
+ self.entryyCenter.setText("0")
+ self.v12.addWidget(self.entryyCenter)
+ self.entryRadius = QLineEdit(self)
+ self.entryRadius.setValidator(floatValidator)
+ self.entryRadius.setText("10")
+ self.v12.addWidget(self.entryRadius)
+ pass
- def execApply( self ) :
- name = self.name
- center = float(self.xCenter), float(self.yCenter)
- radius = float( self.radius )
- self.getController().createCircle( name, center, radius )
- self.reInitializeDialog()
- return
+ def execApply(self):
+ name = self.name
+ center = float(self.xCenter), float(self.yCenter)
+ radius = float(self.radius)
+ self.getController().createCircle(name, center, radius)
+ self.reInitializeDialog()
+ return
- def retrieveUserEntries( self ) :
- self.name = str( self.entryName.text() )
- self.xCenter = str( self.entryxCenter.text() )
- self.yCenter = str( self.entryyCenter.text() )
- self.radius = str( self.entryRadius.text() )
- pass
+ def retrieveUserEntries(self):
+ self.name = str(self.entryName.text())
+ self.xCenter = str(self.entryxCenter.text())
+ self.yCenter = str(self.entryyCenter.text())
+ self.radius = str(self.entryRadius.text())
+ pass
- def checkUserEntries( self ) :
- if self.name == "" or self.xCenter == "" or self.yCenter == "" or self.radius == "" :
- self.errMessage = 'All attributes must be filled'
- return False
- return True
+ def checkUserEntries(self):
+ if (
+ self.name == ""
+ or self.xCenter == ""
+ or self.yCenter == ""
+ or self.radius == ""
+ ):
+ self.errMessage = "All attributes must be filled"
+ return False
+ return True
+
+ def reInitializeDialog(self):
+ nbCircles = self.getController().getNbCircles()
+ self.entryName.setText("circle_" + str(nbCircles + 1))
+ self.entryxCenter.setText("0")
+ self.entryyCenter.setText("0")
+ self.entryRadius.setText("10")
+ pass
- def reInitializeDialog( self ) :
- nbCircles = self.getController().getNbCircles()
- self.entryName.setText( "circle_" + str(nbCircles+1) )
- self.entryxCenter.setText( "0" )
- self.entryyCenter.setText( "0" )
- self.entryRadius.setText( "10" )
- pass
pass
from Dialog import Dialog
from qtsalome import *
-class CreatePolylineDialog( Dialog ) :
-
- def __init__( self, helpFile, controller, widgetDialogBox ) :
- """Constructor"""
-
- #Initializing parent widget
- Dialog.__init__( self, helpFile, controller, widgetDialogBox )
-
- #Setting default name
- nbPolylines = controller.getNbPolylines()
- self.entryName.setText( "polyline_" + str(nbPolylines+1) )
- pass
-
- def addSpecialWidgets( self ) :
-
- intValidator = QIntValidator( self )
-
- lNbPoints = QLabel( "Number of points", self )
- self.v11.addWidget( lNbPoints )
-
- self.entryNbPoints = QLineEdit( self )
- self.entryNbPoints.setValidator( intValidator )
- self.entryNbPoints.setText( "10" )
- self.v12.addWidget( self.entryNbPoints )
- pass
-
- def execApply( self ) :
- name = self.name
- nbPoints = int( self.nbPoints )
- self.getController().createPolyline( name, nbPoints )
- self.reInitializeDialog()
- return
-
-
- def retrieveUserEntries( self ) :
- self.name = str( self.entryName.text() )
- self.nbPoints = str( self.entryNbPoints.text() )
- pass
-
- def checkUserEntries( self ) :
- if self.name == "" or self.nbPoints == "" :
- self.errMessage = 'All attributes must be filled'
- return False
- if int( self.nbPoints ) > 10 :
- self.errMessage = 'The number of points must not exceed 10'
- return False
- return True
-
- def reInitializeDialog( self ) :
- nbPolylines = self.getController().getNbPolylines()
- self.entryName.setText( "polyline_" + str(nbPolylines+1) )
- self.entryNbPoints.setText( "10" )
- pass
+
+class CreatePolylineDialog(Dialog):
+ def __init__(self, helpFile, controller, widgetDialogBox):
+ """Constructor"""
+
+ # Initializing parent widget
+ Dialog.__init__(self, helpFile, controller, widgetDialogBox)
+
+ # Setting default name
+ nbPolylines = controller.getNbPolylines()
+ self.entryName.setText("polyline_" + str(nbPolylines + 1))
+ pass
+
+ def addSpecialWidgets(self):
+
+ intValidator = QIntValidator(self)
+
+ lNbPoints = QLabel("Number of points", self)
+ self.v11.addWidget(lNbPoints)
+
+ self.entryNbPoints = QLineEdit(self)
+ self.entryNbPoints.setValidator(intValidator)
+ self.entryNbPoints.setText("10")
+ self.v12.addWidget(self.entryNbPoints)
+ pass
+
+ def execApply(self):
+ name = self.name
+ nbPoints = int(self.nbPoints)
+ self.getController().createPolyline(name, nbPoints)
+ self.reInitializeDialog()
+ return
+
+ def retrieveUserEntries(self):
+ self.name = str(self.entryName.text())
+ self.nbPoints = str(self.entryNbPoints.text())
+ pass
+
+ def checkUserEntries(self):
+ if self.name == "" or self.nbPoints == "":
+ self.errMessage = "All attributes must be filled"
+ return False
+ if int(self.nbPoints) > 10:
+ self.errMessage = "The number of points must not exceed 10"
+ return False
+ return True
+
+ def reInitializeDialog(self):
+ nbPolylines = self.getController().getNbPolylines()
+ self.entryName.setText("polyline_" + str(nbPolylines + 1))
+ self.entryNbPoints.setText("10")
+ pass
+
pass
from qtsalome import *
-class Dialog( QDialog ) :
-
- def __init__( self, helpFile, controller, widgetDialogBox ) :
- """Constructor"""
-
- # Initializing parent widget
- QDialog.__init__( self )
-
- # Setting attributes
- self.setObjectName( "Dialog" )
- self.setWindowTitle( "Dialog data" )
- self._helpFile = helpFile
- self._controller = controller
- self._widgetDialogBox = widgetDialogBox
-
- # Setting layouts
- self.mainLayout = QVBoxLayout( self )
- self.h1 = QHBoxLayout( self )
- self.h2 = QHBoxLayout( self )
- self.mainLayout.addLayout( self.h1 )
- self.mainLayout.addLayout( self.h2 )
- self.v11 = QVBoxLayout( self)
- self.v12 = QVBoxLayout( self )
- self.h1.addLayout( self.v11 )
- self.h1.addLayout( self.v12 )
-
- # Filling layouts with standard widgets( common to all childre )
- self.fillStandardWidgets()
- # Adding special widgets to layouts( special to each child )
- self.addSpecialWidgets()
-
- # Connecting widgets to slots
- self.connectSlots()
- pass
-
- def getController( self ) :
- return self._controller
-
- def fillStandardWidgets( self ) :
-
- lName = QLabel( "Name", self )
- self.v11.addWidget( lName )
-
- self.entryName = QLineEdit( self )
- self.v12.addWidget( self.entryName )
-
- #Setting buttons
- self.bApply = QPushButton( "Apply", self )
- self.h2.addWidget( self.bApply )
- self.bClose = QPushButton( "Close", self )
- self.h2.addWidget( self.bClose )
- self.bHelp = QPushButton( "Help", self )
- self.h2.addWidget( self.bHelp )
- pass
-
- def addSpecialWidgets( self ) :
- print('Virtual method')
- pass
-
- def connectSlots( self ) :
- self.bApply.clicked.connect(self.apply)
- self.bHelp.clicked.connect(self.help)
- self.bClose.clicked.connect(self.close)
- pass
-
- def apply( self ) :
-
- self.retrieveUserEntries()
- if not self.checkUserEntries() :
- QMessageBox.warning( self, 'information faillure', self.errMessage )
- return
- self.execApply()
- return
-
- def retrieveUserEntries( self ) :
- self.name = str( self.entryName.text() )
- pass
-
- def checkUserEntries( self ) :
- if self.name == "" :
- self.errMessage = 'All attributes must be filled'
- return False
- return True
-
- def execApply( self ) :
- print('Virtual method')
- pass
-
- def reInitializeDialog( self ) :
- print('Virtual method')
- pass
-
- def help( self ) :
- import os
- os.system( 'firefox ' + self._helpFile + '&' )
- pass
-
- def close( self ) :
- self._widgetDialogBox.close()
- pass
+
+class Dialog(QDialog):
+ def __init__(self, helpFile, controller, widgetDialogBox):
+ """Constructor"""
+
+ # Initializing parent widget
+ QDialog.__init__(self)
+
+ # Setting attributes
+ self.setObjectName("Dialog")
+ self.setWindowTitle("Dialog data")
+ self._helpFile = helpFile
+ self._controller = controller
+ self._widgetDialogBox = widgetDialogBox
+
+ # Setting layouts
+ self.mainLayout = QVBoxLayout(self)
+ self.h1 = QHBoxLayout(self)
+ self.h2 = QHBoxLayout(self)
+ self.mainLayout.addLayout(self.h1)
+ self.mainLayout.addLayout(self.h2)
+ self.v11 = QVBoxLayout(self)
+ self.v12 = QVBoxLayout(self)
+ self.h1.addLayout(self.v11)
+ self.h1.addLayout(self.v12)
+
+ # Filling layouts with standard widgets( common to all childre )
+ self.fillStandardWidgets()
+ # Adding special widgets to layouts( special to each child )
+ self.addSpecialWidgets()
+
+ # Connecting widgets to slots
+ self.connectSlots()
+ pass
+
+ def getController(self):
+ return self._controller
+
+ def fillStandardWidgets(self):
+
+ lName = QLabel("Name", self)
+ self.v11.addWidget(lName)
+
+ self.entryName = QLineEdit(self)
+ self.v12.addWidget(self.entryName)
+
+ # Setting buttons
+ self.bApply = QPushButton("Apply", self)
+ self.h2.addWidget(self.bApply)
+ self.bClose = QPushButton("Close", self)
+ self.h2.addWidget(self.bClose)
+ self.bHelp = QPushButton("Help", self)
+ self.h2.addWidget(self.bHelp)
+ pass
+
+ def addSpecialWidgets(self):
+ print("Virtual method")
+ pass
+
+ def connectSlots(self):
+ self.bApply.clicked.connect(self.apply)
+ self.bHelp.clicked.connect(self.help)
+ self.bClose.clicked.connect(self.close)
+ pass
+
+ def apply(self):
+
+ self.retrieveUserEntries()
+ if not self.checkUserEntries():
+ QMessageBox.warning(self, "information faillure", self.errMessage)
+ return
+ self.execApply()
+ return
+
+ def retrieveUserEntries(self):
+ self.name = str(self.entryName.text())
+ pass
+
+ def checkUserEntries(self):
+ if self.name == "":
+ self.errMessage = "All attributes must be filled"
+ return False
+ return True
+
+ def execApply(self):
+ print("Virtual method")
+ pass
+
+ def reInitializeDialog(self):
+ print("Virtual method")
+ pass
+
+ def help(self):
+ import os
+
+ os.system("firefox " + self._helpFile + "&")
+ pass
+
+ def close(self):
+ self._widgetDialogBox.close()
+ pass
+
pass
from qtsalome import *
-class DialogEdit( QDialog ) :
-
- def __init__( self, helpFile, controller, widgetDialogBox ) :
- """Constructor"""
-
- # Initializing parent widget
- QDialog.__init__( self )
-
- # Setting attributes
- self.setObjectName( "Dialog" )
- self.setWindowTitle( "Dialog data" )
- self._helpFile = helpFile
- self._controller = controller
- self._widgetDialogBox = widgetDialogBox
-
- # Setting layouts
- self.mainLayout = QVBoxLayout( self )
- self.h1 = QHBoxLayout( self )
- self.h2 = QHBoxLayout( self )
- self.mainLayout.addLayout( self.h1 )
- self.mainLayout.addLayout( self.h2 )
- self.v11 = QVBoxLayout( self)
- self.v12 = QVBoxLayout( self )
- self.h1.addLayout( self.v11 )
- self.h1.addLayout( self.v12 )
-
- # Filling layouts with standard widgets( common to all childre )
- self.fillStandardWidgets()
- # Adding special widgets to layouts( special to each child )
- self.addSpecialWidgets()
-
- # Connecting widgets to slots
- self.connectSlots()
- pass
-
- def getController( self ) :
- return self._controller
-
- def fillStandardWidgets( self ) :
-
- #Setting buttons
- self.bOk = QPushButton( "OK", self )
- self.h2.addWidget( self.bOk )
- self.bCancel = QPushButton( "Cancel", self )
- self.h2.addWidget( self.bCancel )
- self.bHelp = QPushButton( "Help", self )
- self.h2.addWidget( self.bHelp )
- pass
-
- def addSpecialWidgets( self ) :
- print('Virtual method')
- pass
-
- def connectSlots( self ) :
- self.bOk.clicked.connect(self.apply)
- self.bHelp.clicked.connect(self.help)
- self.bCancel.clicked.connect(self.close)
- pass
-
- def apply( self ) :
- self.retrieveUserEntries()
- if not self.checkUserEntries() :
- QMessageBox.warning( self, 'information faillure', self.errMessage )
- return
- self.execApply()
- self.close()
- return
-
- def retrieveUserEntries( self ) :
- print('Virtual method')
- pass
-
- def checkUserEntries( self ) :
- print('Virtual method')
- return True
-
- def execApply( self ) :
- print('Virtual method')
- pass
-
- def help( self ) :
- import os
- os.system( 'firefox ' + self._helpFile + '&' )
- pass
-
- def close( self ) :
- self._widgetDialogBox.close()
- pass
+
+class DialogEdit(QDialog):
+ def __init__(self, helpFile, controller, widgetDialogBox):
+ """Constructor"""
+
+ # Initializing parent widget
+ QDialog.__init__(self)
+
+ # Setting attributes
+ self.setObjectName("Dialog")
+ self.setWindowTitle("Dialog data")
+ self._helpFile = helpFile
+ self._controller = controller
+ self._widgetDialogBox = widgetDialogBox
+
+ # Setting layouts
+ self.mainLayout = QVBoxLayout(self)
+ self.h1 = QHBoxLayout(self)
+ self.h2 = QHBoxLayout(self)
+ self.mainLayout.addLayout(self.h1)
+ self.mainLayout.addLayout(self.h2)
+ self.v11 = QVBoxLayout(self)
+ self.v12 = QVBoxLayout(self)
+ self.h1.addLayout(self.v11)
+ self.h1.addLayout(self.v12)
+
+ # Filling layouts with standard widgets( common to all childre )
+ self.fillStandardWidgets()
+ # Adding special widgets to layouts( special to each child )
+ self.addSpecialWidgets()
+
+ # Connecting widgets to slots
+ self.connectSlots()
+ pass
+
+ def getController(self):
+ return self._controller
+
+ def fillStandardWidgets(self):
+
+ # Setting buttons
+ self.bOk = QPushButton("OK", self)
+ self.h2.addWidget(self.bOk)
+ self.bCancel = QPushButton("Cancel", self)
+ self.h2.addWidget(self.bCancel)
+ self.bHelp = QPushButton("Help", self)
+ self.h2.addWidget(self.bHelp)
+ pass
+
+ def addSpecialWidgets(self):
+ print("Virtual method")
+ pass
+
+ def connectSlots(self):
+ self.bOk.clicked.connect(self.apply)
+ self.bHelp.clicked.connect(self.help)
+ self.bCancel.clicked.connect(self.close)
+ pass
+
+ def apply(self):
+ self.retrieveUserEntries()
+ if not self.checkUserEntries():
+ QMessageBox.warning(self, "information faillure", self.errMessage)
+ return
+ self.execApply()
+ self.close()
+ return
+
+ def retrieveUserEntries(self):
+ print("Virtual method")
+ pass
+
+ def checkUserEntries(self):
+ print("Virtual method")
+ return True
+
+ def execApply(self):
+ print("Virtual method")
+ pass
+
+ def help(self):
+ import os
+
+ os.system("firefox " + self._helpFile + "&")
+ pass
+
+ def close(self):
+ self._widgetDialogBox.close()
+ pass
+
pass
from DialogEdit import *
from qtsalome import *
-class EditCenterDialog( DialogEdit ) :
-
- def __init__( self, helpFile, controller, widgetDialogBox, model, oldCenter ) :
- """Constructor"""
-
- # Initializing parent widget
- DialogEdit.__init__( self, helpFile, controller, widgetDialogBox )
-
- self._model = model
-
- # Reading oldX and oldY
- oldX = ""
- oldY = ""
- i = 0
- while oldCenter[i] != ':' :
- oldX += oldCenter[i]
- i += 1
- pass
- for j in range( i+1, len(oldCenter) ) :
- oldY += oldCenter[j]
- pass
- self.entryX.setText( oldX )
- self.entryY.setText( oldY )
- pass
-
- def addSpecialWidgets( self ) :
- floatValidator = QDoubleValidator( self )
-
- lX = QLabel( "X", self )
- self.v11.addWidget( lX )
- lY = QLabel( "Y", self )
- self.v11.addWidget( lY )
-
- self.entryX = QLineEdit( self )
- self.entryX.setValidator( floatValidator )
- self.v12.addWidget( self.entryX )
- self.entryY = QLineEdit( self )
- self.entryY.setValidator( floatValidator )
- self.v12.addWidget( self.entryY )
- pass
-
- def execApply( self ) :
- newX = float( self.newX )
- newY = float( self.newY )
- newCenter = newX, newY
- self.getController().editCenter( self._model, newCenter )
- return
-
- def retrieveUserEntries( self ) :
- self.newX= str( self.entryX.text() )
- self.newY= str( self.entryY.text() )
- pass
-
- def checkUserEntries( self ) :
- if self.newX == "" or self.newY == "" :
- self.errMessage = 'All attributes must be filled'
- return False
- return True
+
+class EditCenterDialog(DialogEdit):
+ def __init__(self, helpFile, controller, widgetDialogBox, model, oldCenter):
+ """Constructor"""
+
+ # Initializing parent widget
+ DialogEdit.__init__(self, helpFile, controller, widgetDialogBox)
+
+ self._model = model
+
+ # Reading oldX and oldY
+ oldX = ""
+ oldY = ""
+ i = 0
+ while oldCenter[i] != ":":
+ oldX += oldCenter[i]
+ i += 1
+ pass
+ for j in range(i + 1, len(oldCenter)):
+ oldY += oldCenter[j]
+ pass
+ self.entryX.setText(oldX)
+ self.entryY.setText(oldY)
+ pass
+
+ def addSpecialWidgets(self):
+ floatValidator = QDoubleValidator(self)
+
+ lX = QLabel("X", self)
+ self.v11.addWidget(lX)
+ lY = QLabel("Y", self)
+ self.v11.addWidget(lY)
+
+ self.entryX = QLineEdit(self)
+ self.entryX.setValidator(floatValidator)
+ self.v12.addWidget(self.entryX)
+ self.entryY = QLineEdit(self)
+ self.entryY.setValidator(floatValidator)
+ self.v12.addWidget(self.entryY)
+ pass
+
+ def execApply(self):
+ newX = float(self.newX)
+ newY = float(self.newY)
+ newCenter = newX, newY
+ self.getController().editCenter(self._model, newCenter)
+ return
+
+ def retrieveUserEntries(self):
+ self.newX = str(self.entryX.text())
+ self.newY = str(self.entryY.text())
+ pass
+
+ def checkUserEntries(self):
+ if self.newX == "" or self.newY == "":
+ self.errMessage = "All attributes must be filled"
+ return False
+ return True
+
pass
from DialogEdit import *
from qtsalome import *
-class EditPointDialog( DialogEdit ) :
- def __init__( self, helpFile, controller, widgetDialogBox, model, oldPoint, pointRange ) :
- """Constructor"""
+class EditPointDialog(DialogEdit):
+ def __init__(
+ self, helpFile, controller, widgetDialogBox, model, oldPoint, pointRange
+ ):
+ """Constructor"""
- #Initializing parent widget
- DialogEdit.__init__( self, helpFile, controller, widgetDialogBox )
+ # Initializing parent widget
+ DialogEdit.__init__(self, helpFile, controller, widgetDialogBox)
- self._model = model
+ self._model = model
- #Reading oldX and oldY
- oldX = ""
- oldY = ""
- i = 0
- while oldPoint[i] != ':' :
- oldX += oldPoint[i]
- i += 1
- pass
- for j in range( i+1, len(oldPoint) ) :
- oldY += oldPoint[j]
- pass
- self.pointRange = pointRange
- self.entryX.setText( oldX )
- self.entryY.setText( oldY )
- pass
+ # Reading oldX and oldY
+ oldX = ""
+ oldY = ""
+ i = 0
+ while oldPoint[i] != ":":
+ oldX += oldPoint[i]
+ i += 1
+ pass
+ for j in range(i + 1, len(oldPoint)):
+ oldY += oldPoint[j]
+ pass
+ self.pointRange = pointRange
+ self.entryX.setText(oldX)
+ self.entryY.setText(oldY)
+ pass
- def addSpecialWidgets( self ) :
- floatValidator = QDoubleValidator( self )
+ def addSpecialWidgets(self):
+ floatValidator = QDoubleValidator(self)
- lX = QLabel( "X", self )
- self.v11.addWidget( lX )
- lY = QLabel( "Y", self )
- self.v11.addWidget( lY )
+ lX = QLabel("X", self)
+ self.v11.addWidget(lX)
+ lY = QLabel("Y", self)
+ self.v11.addWidget(lY)
- self.entryX = QLineEdit( self )
- self.entryX.setValidator( floatValidator )
- self.v12.addWidget( self.entryX )
- self.entryY = QLineEdit( self )
- self.entryY.setValidator( floatValidator )
- self.v12.addWidget( self.entryY )
- pass
+ self.entryX = QLineEdit(self)
+ self.entryX.setValidator(floatValidator)
+ self.v12.addWidget(self.entryX)
+ self.entryY = QLineEdit(self)
+ self.entryY.setValidator(floatValidator)
+ self.v12.addWidget(self.entryY)
+ pass
- def execApply( self ) :
- pointRange = self.pointRange
- newX = float( self.newX )
- newY = float( self.newY )
- newPoint = newX, newY
- self.getController().editPoint( self._model, newPoint, pointRange )
- return
+ def execApply(self):
+ pointRange = self.pointRange
+ newX = float(self.newX)
+ newY = float(self.newY)
+ newPoint = newX, newY
+ self.getController().editPoint(self._model, newPoint, pointRange)
+ return
+ def retrieveUserEntries(self):
+ self.newX = str(self.entryX.text())
+ self.newY = str(self.entryY.text())
+ pass
- def retrieveUserEntries( self ) :
- self.newX= str( self.entryX.text() )
- self.newY= str( self.entryY.text() )
- pass
+ def checkUserEntries(self):
+ if self.newX == "" or self.newY == "":
+ self.errMessage = "All attributes must be filled"
+ return False
+ return True
- def checkUserEntries( self ) :
- if self.newX == "" or self.newY == "" :
- self.errMessage = 'All attributes must be filled'
- return False
- return True
pass
from DialogEdit import *
from qtsalome import *
-class EditRadiusDialog( DialogEdit ) :
- def __init__( self, helpFile, controller, widgetDialogBox, model, oldRadius ) :
- """Constructor"""
+class EditRadiusDialog(DialogEdit):
+ def __init__(self, helpFile, controller, widgetDialogBox, model, oldRadius):
+ """Constructor"""
- #Initializing parent widget
- DialogEdit.__init__( self, helpFile, controller, widgetDialogBox )
+ # Initializing parent widget
+ DialogEdit.__init__(self, helpFile, controller, widgetDialogBox)
- self._model = model
- self.entryRadius.setText( oldRadius )
- pass
+ self._model = model
+ self.entryRadius.setText(oldRadius)
+ pass
- def addSpecialWidgets( self ) :
- floatValidator = QDoubleValidator( self )
+ def addSpecialWidgets(self):
+ floatValidator = QDoubleValidator(self)
- lRadius = QLabel( "Radius", self )
- self.v11.addWidget( lRadius )
- self.entryRadius = QLineEdit( self )
- self.entryRadius.setValidator( floatValidator )
- self.v12.addWidget( self.entryRadius )
- pass
+ lRadius = QLabel("Radius", self)
+ self.v11.addWidget(lRadius)
+ self.entryRadius = QLineEdit(self)
+ self.entryRadius.setValidator(floatValidator)
+ self.v12.addWidget(self.entryRadius)
+ pass
- def execApply( self ) :
- newRadius = self.newRadius
- self.getController().editRadius( self._model, newRadius )
- return
+ def execApply(self):
+ newRadius = self.newRadius
+ self.getController().editRadius(self._model, newRadius)
+ return
+ def retrieveUserEntries(self):
+ self.newRadius = str(self.entryRadius.text())
+ pass
- def retrieveUserEntries( self ) :
- self.newRadius = str( self.entryRadius.text() )
- pass
+ def checkUserEntries(self):
+ if self.newRadius == "":
+ self.errMessage = "All attributes must be filled"
+ return False
+ return True
- def checkUserEntries( self ) :
- if self.newRadius == "" :
- self.errMessage = 'All attributes must be filled'
- return False
- return True
pass
from DialogEdit import *
from qtsalome import *
-class RenameDialog( DialogEdit ) :
-
- def __init__( self, helpFile, controller, widgetDialogBox, model, oldName ) :
- """Constructor"""
-
- # Initializing parent widget
- DialogEdit.__init__( self, helpFile, controller, widgetDialogBox )
-
- self._model = model
- self.entryName.setText( oldName )
- pass
-
- def addSpecialWidgets( self ) :
- lName = QLabel( "Name", self )
- self.v11.addWidget( lName )
- self.entryName = QLineEdit( self )
- self.v12.addWidget( self.entryName )
- pass
-
- def execApply( self ) :
- newName = self.newName
- self.getController().editName( self._model, newName )
- return
-
- def retrieveUserEntries( self ) :
- self.newName = str( self.entryName.text() )
- pass
-
- def checkUserEntries( self ) :
- if self.newName == "" :
- self.errMessage = 'All attributes must be filled'
- return False
- return True
+
+class RenameDialog(DialogEdit):
+ def __init__(self, helpFile, controller, widgetDialogBox, model, oldName):
+ """Constructor"""
+
+ # Initializing parent widget
+ DialogEdit.__init__(self, helpFile, controller, widgetDialogBox)
+
+ self._model = model
+ self.entryName.setText(oldName)
+ pass
+
+ def addSpecialWidgets(self):
+ lName = QLabel("Name", self)
+ self.v11.addWidget(lName)
+ self.entryName = QLineEdit(self)
+ self.v12.addWidget(self.entryName)
+ pass
+
+ def execApply(self):
+ newName = self.newName
+ self.getController().editName(self._model, newName)
+ return
+
+ def retrieveUserEntries(self):
+ self.newName = str(self.entryName.text())
+ pass
+
+ def checkUserEntries(self):
+ if self.newName == "":
+ self.errMessage = "All attributes must be filled"
+ return False
+ return True
+
pass
from qtsalome import *
__all__ = [
- "Circle",
- ]
-
-class Circle( Model ):
-
- def __init__( self, name, center, radius, controller ):
- """Constructor"""
-
- Model.__init__( self,controller )
- self._name = name
- self._center = center
- self._radius = radius
- self.addTreeWidgetItem( self.getName(), controller )
- self.addGraphicScene( controller )
- pass
-
- def getCenter( self ):
- return self._center[0], self._center[1]
-
- def setCenter( self, center ):
- self._center = center
- pass
-
- def getRadius( self ):
- return self._radius
-
- def setRadius( self, radius ):
- self._radius = radius
-
- def addTreeWidgetItem( self, name, controller ):
- from CircleTreeWidgetItem import CircleTreeWidgetItem
- from TreeWidgetItem import TreeWidgetItem
-
- myTreeWidgetItem = CircleTreeWidgetItem( name, controller, ["Show", "Rename", "Delete"] )
- newTreeWidgetItem = TreeWidgetItem( str(self.getCenter()[0]) + ':' + str(self.getCenter()[1]), controller, ["Edit"] )
- myTreeWidgetItem.addChild( newTreeWidgetItem )
- newTreeWidgetItem = TreeWidgetItem( str(self.getRadius()), controller, ["Edit"] )
- myTreeWidgetItem.addChild( newTreeWidgetItem )
- myTreeWidgetItem.setModel( self )
- self.getViews().append( myTreeWidgetItem )
- return myTreeWidgetItem
-
- def addGraphicScene( self, controller ) :
- from CircleGraphicsScene import CircleGraphicsScene
-
- myGraphicsScene = CircleGraphicsScene( controller )
- myGraphicsScene.setModel( self )
- self.getViews().append( myGraphicsScene )
- return myGraphicsScene
-
- def save( self ):
- pass
+ "Circle",
+]
+
+
+class Circle(Model):
+ def __init__(self, name, center, radius, controller):
+ """Constructor"""
+
+ Model.__init__(self, controller)
+ self._name = name
+ self._center = center
+ self._radius = radius
+ self.addTreeWidgetItem(self.getName(), controller)
+ self.addGraphicScene(controller)
+ pass
+
+ def getCenter(self):
+ return self._center[0], self._center[1]
+
+ def setCenter(self, center):
+ self._center = center
+ pass
+
+ def getRadius(self):
+ return self._radius
+
+ def setRadius(self, radius):
+ self._radius = radius
+
+ def addTreeWidgetItem(self, name, controller):
+ from CircleTreeWidgetItem import CircleTreeWidgetItem
+ from TreeWidgetItem import TreeWidgetItem
+
+ myTreeWidgetItem = CircleTreeWidgetItem(
+ name, controller, ["Show", "Rename", "Delete"]
+ )
+ newTreeWidgetItem = TreeWidgetItem(
+ str(self.getCenter()[0]) + ":" + str(self.getCenter()[1]),
+ controller,
+ ["Edit"],
+ )
+ myTreeWidgetItem.addChild(newTreeWidgetItem)
+ newTreeWidgetItem = TreeWidgetItem(str(self.getRadius()), controller, ["Edit"])
+ myTreeWidgetItem.addChild(newTreeWidgetItem)
+ myTreeWidgetItem.setModel(self)
+ self.getViews().append(myTreeWidgetItem)
+ return myTreeWidgetItem
+
+ def addGraphicScene(self, controller):
+ from CircleGraphicsScene import CircleGraphicsScene
+
+ myGraphicsScene = CircleGraphicsScene(controller)
+ myGraphicsScene.setModel(self)
+ self.getViews().append(myGraphicsScene)
+ return myGraphicsScene
+
+ def save(self):
+ pass
+
pass
from View import *
+
class Model:
+ def __init__(self, controller):
+ """Constructor"""
- def __init__( self, controller ):
- """Constructor"""
+ self._name = None
+ self._views = []
+ pass
- self._name = None
- self._views = []
- pass
+ def getName(self):
+ return self._name
- def getName( self ):
- return self._name
+ def setName(self, name):
+ self._name = name
+ pass
- def setName( self, name ):
- self._name = name
- pass
+ def getViews(self):
+ return self._views
- def getViews( self ) :
- return self._views
+ def addView(self):
+ myView = View()
+ self._views.append(myView)
+ return myView
- def addView( self ) :
- myView = View()
- self._views.append( myView )
- return myView
+ def updateViews(self, mode):
+ for view in self._views:
+ view.update(mode)
- def updateViews( self, mode ) :
- for view in self._views : view.update( mode )
+ def save(self):
+ print("Virtual method")
+ pass
- def save( self ) :
- print('Virtual method')
- pass
pass
from Model import *
from qtsalome import *
-class Polyline( Model ):
-
- def __init__( self, name, points, controller ):
- """Constructor"""
-
- Model.__init__( self, controller )
- self._name = name
- self._points = points
- self.addTreeWidgetItem( self.getName(), controller )
- self.addGraphicScene( controller )
- pass
-
- def getPoints( self ):
- return self._points
-
- def setPoints( self, points ):
- self._points = points
- pass
-
- def editPoint( self, pointRange, newPoint ) :
- self._points[ pointRange ] = newPoint
- pass
-
- def addTreeWidgetItem( self, name, controller ):
- from PolyTreeWidgetItem import PolyTreeWidgetItem
- from TreeWidgetItem import TreeWidgetItem
-
- myTreeWidgetItem = PolyTreeWidgetItem( name, controller, ["Show", "Rename", "Delete"] )
- # Adding list of points
- for point in self.getPoints() :
- x = point[0]
- y = point[1]
- newTreeWidgetItem = TreeWidgetItem( str(x) + ":" + str(y), controller, ["Edit"] )
- myTreeWidgetItem.addChild( newTreeWidgetItem )
- pass
- myTreeWidgetItem.setModel( self )
- self.getViews().append( myTreeWidgetItem )
- return myTreeWidgetItem
-
- def addGraphicScene( self, controller ) :
- from PolyGraphicsScene import PolyGraphicsScene
-
- myGraphicsScene = PolyGraphicsScene( controller )
- myGraphicsScene.setModel( self )
- self.getViews().append( myGraphicsScene )
- return myGraphicsScene
-
- def save( self ):
- pass
+
+class Polyline(Model):
+ def __init__(self, name, points, controller):
+ """Constructor"""
+
+ Model.__init__(self, controller)
+ self._name = name
+ self._points = points
+ self.addTreeWidgetItem(self.getName(), controller)
+ self.addGraphicScene(controller)
+ pass
+
+ def getPoints(self):
+ return self._points
+
+ def setPoints(self, points):
+ self._points = points
+ pass
+
+ def editPoint(self, pointRange, newPoint):
+ self._points[pointRange] = newPoint
+ pass
+
+ def addTreeWidgetItem(self, name, controller):
+ from PolyTreeWidgetItem import PolyTreeWidgetItem
+ from TreeWidgetItem import TreeWidgetItem
+
+ myTreeWidgetItem = PolyTreeWidgetItem(
+ name, controller, ["Show", "Rename", "Delete"]
+ )
+ # Adding list of points
+ for point in self.getPoints():
+ x = point[0]
+ y = point[1]
+ newTreeWidgetItem = TreeWidgetItem(
+ str(x) + ":" + str(y), controller, ["Edit"]
+ )
+ myTreeWidgetItem.addChild(newTreeWidgetItem)
+ pass
+ myTreeWidgetItem.setModel(self)
+ self.getViews().append(myTreeWidgetItem)
+ return myTreeWidgetItem
+
+ def addGraphicScene(self, controller):
+ from PolyGraphicsScene import PolyGraphicsScene
+
+ myGraphicsScene = PolyGraphicsScene(controller)
+ myGraphicsScene.setModel(self)
+ self.getViews().append(myGraphicsScene)
+ return myGraphicsScene
+
+ def save(self):
+ pass
+
pass
-from PyQt5.QtCore import *
-from PyQt5.QtGui import *
+from PyQt5.QtCore import *
+from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
from TreeWidget import TreeWidget
from GraphicsView import GraphicsView
from GraphicsScene import GraphicsScene
-class Desktop( QMainWindow ) :
-
- def __init__( self ) :
- """Constructor"""
-
- QMainWindow.__init__( self )
- self._controller = None
-
- # Creating a dockWidget which will contain globalTree
- self._globalTree= TreeWidget( self )
- self._globalTree.setHeaderLabel ( "Object browser" )
- dockGlobalTree = QDockWidget( "Tree view", self )
- dockGlobalTree.setAllowedAreas( Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea )
- dockGlobalTree.setWidget( self._globalTree )
- self.addDockWidget( Qt.LeftDockWidgetArea, dockGlobalTree )
-
- # Creating a central widget which contains the globalGraphicsView
- self._dockGlobalView = QDockWidget( "Graphics view", self )
- scene = GraphicsScene( self._controller )
- self._globalGraphicsView = GraphicsView( scene )
- self._dockGlobalView.setWidget( self._globalGraphicsView )
- self._globalGraphicsView.show()
- self.setCentralWidget( self._dockGlobalView )
-
- # Creating menus and toolbars
- self.createMenus()
- self.createToolBars()
- pass
-
- def getController( self ) :
- return self._controller
-
- def setController( self, controller ) :
- self._controller = controller
- pass
-
- def getGlobalTree( self ) :
- return self._globalTree
-
- def createMenus( self ) :
- # Creating menus
- curveMenu = self.menuBar().addMenu( "Curve" )
- toolsMenu = self.menuBar().addMenu( "Tools" )
- # Adding actions
- createPolylineAction = QAction( "Polyline", self )
- createCircleAction = QAction( "Circle", self )
- curveMenu.addAction( createPolylineAction )
- curveMenu.addAction( createCircleAction )
-
- deleteAllAction = QAction( "Delete all", self )
- toolsMenu.addAction( deleteAllAction )
- # Connecting slots
- createPolylineAction.triggered.connect(self.showCreatePolylineDialog)
- createCircleAction.triggered.connect(self.showCreateCircleDialog)
- deleteAllAction.triggered.connect(self.deleteAll)
- pass
-
- def createToolBars( self ) :
- # Creating toolBars
- createPolylineTB = self.addToolBar( "New polyline")
- createCircleTB = self.addToolBar( "New circle")
- createPolylineAction = QAction( "Polyline", self )
- createCircleAction = QAction( "Circle", self )
- # Adding actions
- createPolylineTB.addAction( createPolylineAction )
- createCircleTB.addAction( createCircleAction )
- # Connecting slots
- createPolylineAction.triggered.connect(self.showCreatePolylineDialog)
- createCircleAction.triggered.connect(self.showCreateCircleDialog)
- pass
-
- def showCreatePolylineDialog( self ) :
- from CreatePolylineDialog import CreatePolylineDialog
-
- widgetDialogBox = QDockWidget( "myDockWidget", self )
- myDialog = CreatePolylineDialog( "www.google.fr", self._controller, widgetDialogBox )
- widgetDialogBox.setAllowedAreas( Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea )
- widgetDialogBox.setWidget( myDialog )
- widgetDialogBox.setWindowTitle( "Polyline definition" )
- self.addDockWidget( Qt.LeftDockWidgetArea, widgetDialogBox )
- pass
-
- def showCreateCircleDialog( self ) :
- from CreateCircleDialog import CreateCircleDialog
-
- widgetDialogBox = QDockWidget( "myDockWidget", self )
- myDialog = CreateCircleDialog( "www.cea.fr", self._controller, widgetDialogBox )
- widgetDialogBox.setAllowedAreas( Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea )
- widgetDialogBox.setWidget( myDialog )
- widgetDialogBox.setWindowTitle( "Polyline definition" )
- self.addDockWidget( Qt.LeftDockWidgetArea, widgetDialogBox )
- pass
-
- def deleteAll( self ) :
- models = self.getController().getModels()
- if len( models ) == 0 : return
- answer = QMessageBox.question( self, 'Confirmation', 'Do you really want to delete all the existing objects ?' , QMessageBox.Yes | QMessageBox.No )
- if answer == QMessageBox.Yes :
- for model in models :
- self.getController().removeModel( model )
- pass
- pass
- pass
-
- def updateGlobalGraphicsView( self, scene ) :
- self._globalGraphicsView.setScene( scene )
- if scene is None :
- self._dockGlobalView.setWindowTitle( "Graphics view" )
- return
- self._dockGlobalView.setWindowTitle( "Graphics view : showing " + scene.getModel().getName() )
- #Resizing the globalGraphicView
- sceneRect = scene.getRect()
- topLeft = sceneRect.topLeft()
- viewRect = QRectF( topLeft.x(), topLeft.y(), 2*sceneRect.width(), 2*sceneRect.height() )
- self._globalGraphicsView.fitInView ( viewRect, Qt.IgnoreAspectRatio )
- pass
+
+class Desktop(QMainWindow):
+ def __init__(self):
+ """Constructor"""
+
+ QMainWindow.__init__(self)
+ self._controller = None
+
+ # Creating a dockWidget which will contain globalTree
+ self._globalTree = TreeWidget(self)
+ self._globalTree.setHeaderLabel("Object browser")
+ dockGlobalTree = QDockWidget("Tree view", self)
+ dockGlobalTree.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea)
+ dockGlobalTree.setWidget(self._globalTree)
+ self.addDockWidget(Qt.LeftDockWidgetArea, dockGlobalTree)
+
+ # Creating a central widget which contains the globalGraphicsView
+ self._dockGlobalView = QDockWidget("Graphics view", self)
+ scene = GraphicsScene(self._controller)
+ self._globalGraphicsView = GraphicsView(scene)
+ self._dockGlobalView.setWidget(self._globalGraphicsView)
+ self._globalGraphicsView.show()
+ self.setCentralWidget(self._dockGlobalView)
+
+ # Creating menus and toolbars
+ self.createMenus()
+ self.createToolBars()
+ pass
+
+ def getController(self):
+ return self._controller
+
+ def setController(self, controller):
+ self._controller = controller
+ pass
+
+ def getGlobalTree(self):
+ return self._globalTree
+
+ def createMenus(self):
+ # Creating menus
+ curveMenu = self.menuBar().addMenu("Curve")
+ toolsMenu = self.menuBar().addMenu("Tools")
+ # Adding actions
+ createPolylineAction = QAction("Polyline", self)
+ createCircleAction = QAction("Circle", self)
+ curveMenu.addAction(createPolylineAction)
+ curveMenu.addAction(createCircleAction)
+
+ deleteAllAction = QAction("Delete all", self)
+ toolsMenu.addAction(deleteAllAction)
+ # Connecting slots
+ createPolylineAction.triggered.connect(self.showCreatePolylineDialog)
+ createCircleAction.triggered.connect(self.showCreateCircleDialog)
+ deleteAllAction.triggered.connect(self.deleteAll)
+ pass
+
+ def createToolBars(self):
+ # Creating toolBars
+ createPolylineTB = self.addToolBar("New polyline")
+ createCircleTB = self.addToolBar("New circle")
+ createPolylineAction = QAction("Polyline", self)
+ createCircleAction = QAction("Circle", self)
+ # Adding actions
+ createPolylineTB.addAction(createPolylineAction)
+ createCircleTB.addAction(createCircleAction)
+ # Connecting slots
+ createPolylineAction.triggered.connect(self.showCreatePolylineDialog)
+ createCircleAction.triggered.connect(self.showCreateCircleDialog)
+ pass
+
+ def showCreatePolylineDialog(self):
+ from CreatePolylineDialog import CreatePolylineDialog
+
+ widgetDialogBox = QDockWidget("myDockWidget", self)
+ myDialog = CreatePolylineDialog(
+ "www.google.fr", self._controller, widgetDialogBox
+ )
+ widgetDialogBox.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea)
+ widgetDialogBox.setWidget(myDialog)
+ widgetDialogBox.setWindowTitle("Polyline definition")
+ self.addDockWidget(Qt.LeftDockWidgetArea, widgetDialogBox)
+ pass
+
+ def showCreateCircleDialog(self):
+ from CreateCircleDialog import CreateCircleDialog
+
+ widgetDialogBox = QDockWidget("myDockWidget", self)
+ myDialog = CreateCircleDialog("www.cea.fr", self._controller, widgetDialogBox)
+ widgetDialogBox.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea)
+ widgetDialogBox.setWidget(myDialog)
+ widgetDialogBox.setWindowTitle("Polyline definition")
+ self.addDockWidget(Qt.LeftDockWidgetArea, widgetDialogBox)
+ pass
+
+ def deleteAll(self):
+ models = self.getController().getModels()
+ if len(models) == 0:
+ return
+ answer = QMessageBox.question(
+ self,
+ "Confirmation",
+ "Do you really want to delete all the existing objects ?",
+ QMessageBox.Yes | QMessageBox.No,
+ )
+ if answer == QMessageBox.Yes:
+ for model in models:
+ self.getController().removeModel(model)
+ pass
+ pass
+ pass
+
+ def updateGlobalGraphicsView(self, scene):
+ self._globalGraphicsView.setScene(scene)
+ if scene is None:
+ self._dockGlobalView.setWindowTitle("Graphics view")
+ return
+ self._dockGlobalView.setWindowTitle(
+ "Graphics view : showing " + scene.getModel().getName()
+ )
+ # Resizing the globalGraphicView
+ sceneRect = scene.getRect()
+ topLeft = sceneRect.topLeft()
+ viewRect = QRectF(
+ topLeft.x(), topLeft.y(), 2 * sceneRect.width(), 2 * sceneRect.height()
+ )
+ self._globalGraphicsView.fitInView(viewRect, Qt.IgnoreAspectRatio)
+ pass
+
pass
import sys
-from PyQt5.QtCore import *
-from PyQt5.QtGui import *
+from PyQt5.QtCore import *
+from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
from Controller import Controller
from Desktop import Desktop
-def main( args ) :
- Appli = QApplication( args )
+
+def main(args):
+ Appli = QApplication(args)
MainFrame = Desktop()
- myController = Controller( MainFrame )
- MainFrame.setController( myController )
+ myController = Controller(MainFrame)
+ MainFrame.setController(myController)
MainFrame.show()
Appli.exec_()
-if __name__ == "__main__" :
- main( sys.argv )
- pass
+if __name__ == "__main__":
+ main(sys.argv)
+ pass
from qtsalome import *
from GraphicsRectItem import GraphicsRectItem
-class CircleGraphicsScene( GraphicsScene ) :
-
- def __init__( self, controller ) :
- GraphicsScene.__init__( self, controller )
- pass
-
- def draw( self ) :
-
- import math
-
- center = self._model.getCenter()
- radius = float( self._model.getRadius() )
- xCenter = float( center[0] )
- yCenter = float( center[1] )
-
- #Drawing the center as a small rectangle
- centerItem = GraphicsRectItem( xCenter-0.1, yCenter-0.1, 0.2, 0.2, None )
- self.addItem( centerItem )
- #Drawing the circle
- rect = QRectF( xCenter-radius, yCenter-radius, 2*radius, 2*radius )
- circleItem = QGraphicsEllipseItem()
- circleItem.setRect( rect )
- self.addItem( circleItem )
- pass
+
+class CircleGraphicsScene(GraphicsScene):
+ def __init__(self, controller):
+ GraphicsScene.__init__(self, controller)
+ pass
+
+ def draw(self):
+
+ import math
+
+ center = self._model.getCenter()
+ radius = float(self._model.getRadius())
+ xCenter = float(center[0])
+ yCenter = float(center[1])
+
+ # Drawing the center as a small rectangle
+ centerItem = GraphicsRectItem(xCenter - 0.1, yCenter - 0.1, 0.2, 0.2, None)
+ self.addItem(centerItem)
+ # Drawing the circle
+ rect = QRectF(xCenter - radius, yCenter - radius, 2 * radius, 2 * radius)
+ circleItem = QGraphicsEllipseItem()
+ circleItem.setRect(rect)
+ self.addItem(circleItem)
+ pass
+
pass
from TreeWidgetItem import TreeWidgetItem
from qtsalome import *
-class CircleTreeWidgetItem( TreeWidgetItem ) :
- def __init__( self, name, controller, actionsList ) :
- """Constructor"""
+class CircleTreeWidgetItem(TreeWidgetItem):
+ def __init__(self, name, controller, actionsList):
+ """Constructor"""
- TreeWidgetItem.__init__( self, name, controller, actionsList )
- pass
+ TreeWidgetItem.__init__(self, name, controller, actionsList)
+ pass
- def editInGlobalTree( self, treeWidgetItem ) :
- name = self.getModel().getName()
- treeWidgetItem.setText( 0 , name )
- center = self._model.getCenter()
- xCenter = center[0]
- yCenter = center[1]
- relatedItem = treeWidgetItem.child( 0 )
- relatedItem.setText( 0 , str(xCenter) + ":" + str(yCenter) )
+ def editInGlobalTree(self, treeWidgetItem):
+ name = self.getModel().getName()
+ treeWidgetItem.setText(0, name)
+ center = self._model.getCenter()
+ xCenter = center[0]
+ yCenter = center[1]
+ relatedItem = treeWidgetItem.child(0)
+ relatedItem.setText(0, str(xCenter) + ":" + str(yCenter))
+
+ radius = self._model.getRadius()
+ relatedItem = treeWidgetItem.child(1)
+ relatedItem.setText(0, str(radius))
+ pass
- radius = self._model.getRadius()
- relatedItem = treeWidgetItem.child( 1 )
- relatedItem.setText( 0 , str(radius) )
- pass
pass
from qtsalome import *
-class GraphicsRectItem( QGraphicsRectItem ) :
- def __init__( self, x, y, w, h, index ) :
- QGraphicsRectItem.__init__( self, x, y, w, h )
- self._index = index
- self.setFlag( self.ItemIsMovable, True )
- self.setFlag( self.ItemIsSelectable, True )
- pass
+class GraphicsRectItem(QGraphicsRectItem):
+ def __init__(self, x, y, w, h, index):
+ QGraphicsRectItem.__init__(self, x, y, w, h)
+ self._index = index
+ self.setFlag(self.ItemIsMovable, True)
+ self.setFlag(self.ItemIsSelectable, True)
+ pass
+
+ def getIndex(self):
+ return self._index
- def getIndex( self ) :
- return self._index
pass
from View import *
from qtsalome import *
-class GraphicsScene( View, QGraphicsScene ) :
- def __init__( self, controller ) :
- """Constructor"""
+class GraphicsScene(View, QGraphicsScene):
+ def __init__(self, controller):
+ """Constructor"""
- View.__init__( self, controller )
- QGraphicsScene.__init__( self )
- pass
+ View.__init__(self, controller)
+ QGraphicsScene.__init__(self)
+ pass
- def getRect( self ) :
- rect = QRectF( 0, 0, self.width(), self.height() )
- return rect
+ def getRect(self):
+ rect = QRectF(0, 0, self.width(), self.height())
+ return rect
- def editPoint( self, oldPoint, newPoint ) :
- polyline = self.getModel()
- self.getController().editPoint( polyline, oldPoint, newPoint )
- pass
+ def editPoint(self, oldPoint, newPoint):
+ polyline = self.getModel()
+ self.getController().editPoint(polyline, oldPoint, newPoint)
+ pass
- def editCenter( self, center ) :
- circle = self.getModel()
- self.getController().editCenter( circle, center )
- pass
+ def editCenter(self, center):
+ circle = self.getModel()
+ self.getController().editCenter(circle, center)
+ pass
- def editRadius( self, radius ) :
- circle = self.getModel()
- self.getController().editRadius( circle, radius )
- pass
+ def editRadius(self, radius):
+ circle = self.getModel()
+ self.getController().editRadius(circle, radius)
+ pass
- def update( self, mode ) :
- if mode == 'creation' :
- self.showInGlobalGraphicsView()
- pass
- elif mode == "showing" :
- self.showInGlobalGraphicsView()
- elif mode == 'modification' :
- self.undraw()
- self.showInGlobalGraphicsView()
- pass
- elif mode == 'supression' :
- self.removeFromGlobalGraphicsView()
- pass
- else :
- return
+ def update(self, mode):
+ if mode == "creation":
+ self.showInGlobalGraphicsView()
+ pass
+ elif mode == "showing":
+ self.showInGlobalGraphicsView()
+ elif mode == "modification":
+ self.undraw()
+ self.showInGlobalGraphicsView()
+ pass
+ elif mode == "supression":
+ self.removeFromGlobalGraphicsView()
+ pass
+ else:
+ return
- def showInGlobalGraphicsView( self ) :
- self.draw()
- self.getController().getMainFrame().updateGlobalGraphicsView( self )
- pass
+ def showInGlobalGraphicsView(self):
+ self.draw()
+ self.getController().getMainFrame().updateGlobalGraphicsView(self)
+ pass
- def removeFromGlobalGraphicsView( self ) :
- self.getController().getMainFrame().updateGlobalGraphicsView( None )
- pass
+ def removeFromGlobalGraphicsView(self):
+ self.getController().getMainFrame().updateGlobalGraphicsView(None)
+ pass
- def draw( self ) :
- print('Virtual method')
- pass
+ def draw(self):
+ print("Virtual method")
+ pass
+
+ def undraw(self):
+ for item in self.items():
+ self.removeItem(item)
+ pass
+ pass
- def undraw( self ) :
- for item in self.items() :
- self.removeItem( item )
- pass
- pass
pass
from Circle import Circle
from qtsalome import *
-class GraphicsView( QGraphicsView ) :
- moved = pyqtSignal(QPointF)
- released = pyqtSignal(QPointF)
+class GraphicsView(QGraphicsView):
- def __init__( self, scene ) :
- QGraphicsView.__init__( self, scene )
- self.setMouseTracking( True )
- self._selectedItem = None
- self.moved[QPointF].connect(self.execMouseMoveEvent)
- self.released[QPointF].connect(self.execMouseReleaseEvent)
- pass
+ moved = pyqtSignal(QPointF)
+ released = pyqtSignal(QPointF)
- def mousePressEvent( self, mouseEvent ) :
- QGraphicsView.mousePressEvent( self, mouseEvent )
- if self.scene() is None : return
- self._selectedItem = self.scene().mouseGrabberItem()
- pass
+ def __init__(self, scene):
+ QGraphicsView.__init__(self, scene)
+ self.setMouseTracking(True)
+ self._selectedItem = None
+ self.moved[QPointF].connect(self.execMouseMoveEvent)
+ self.released[QPointF].connect(self.execMouseReleaseEvent)
+ pass
- def mouseMoveEvent( self, mouseEvent ) :
- QGraphicsView.mouseMoveEvent( self, mouseEvent )
- pt = mouseEvent.pos()
- currentPos = self.mapToScene( pt )
- self.moved.emit(currentPos)
- pass
+ def mousePressEvent(self, mouseEvent):
+ QGraphicsView.mousePressEvent(self, mouseEvent)
+ if self.scene() is None:
+ return
+ self._selectedItem = self.scene().mouseGrabberItem()
+ pass
- def mouseReleaseEvent( self, mouseEvent ) :
- QGraphicsView.mouseReleaseEvent( self, mouseEvent )
- if mouseEvent.button() == Qt.LeftButton :
- pt = mouseEvent.pos()
- newPos = self.mapToScene( pt )
- self.released.emit(newPos)
- self._selectedItem = None
- pass
- pass
+ def mouseMoveEvent(self, mouseEvent):
+ QGraphicsView.mouseMoveEvent(self, mouseEvent)
+ pt = mouseEvent.pos()
+ currentPos = self.mapToScene(pt)
+ self.moved.emit(currentPos)
+ pass
- def execMouseMoveEvent( self, currentPos ) :
- if self._selectedItem is None : return
- selectedIndex = self._selectedItem.getIndex()
- newX = currentPos.x()
- newY = currentPos.y()
- newPoint = newX, newY
- model = self.scene().getModel()
- pen = QPen( QColor("red") )
- if isinstance( model, Polyline ) :
- #Previsualisation
- if selectedIndex == 0 :
- nextPoint = model.getPoints()[ selectedIndex+1 ]
- xNext = nextPoint[0]
- yNext = nextPoint[1]
- self.scene().addLine( newX, newY, xNext, yNext, pen )
- pass
- elif selectedIndex == len( model.getPoints()) - 1 :
- previousPoint = model.getPoints()[ selectedIndex-1 ]
- xPrevious = previousPoint[0]
- yPrevious = previousPoint[1]
- self.scene().addLine( xPrevious, yPrevious, newX, newY, pen )
- pass
- else :
- previousPoint = model.getPoints()[ selectedIndex-1 ]
- xPrevious = previousPoint[0]
- yPrevious = previousPoint[1]
- self.scene().addLine( xPrevious, yPrevious, newX, newY, pen )
- nextPoint = model.getPoints()[ selectedIndex+1 ]
- xNext = nextPoint[0]
- yNext = nextPoint[1]
- self.scene().addLine( newX, newY, xNext, yNext, pen )
- pass
- pass
- elif isinstance( model, Circle ) :
- #Previsualisation
- radius = float( model.getRadius() )
- rect = QRectF( newX-radius, newY-radius, 2*radius, 2*radius )
- circleItem = QGraphicsEllipseItem()
- circleItem.setPen( pen )
- circleItem.setRect( rect )
- self.scene().addItem( circleItem )
- pass
- pass
+ def mouseReleaseEvent(self, mouseEvent):
+ QGraphicsView.mouseReleaseEvent(self, mouseEvent)
+ if mouseEvent.button() == Qt.LeftButton:
+ pt = mouseEvent.pos()
+ newPos = self.mapToScene(pt)
+ self.released.emit(newPos)
+ self._selectedItem = None
+ pass
+ pass
+
+ def execMouseMoveEvent(self, currentPos):
+ if self._selectedItem is None:
+ return
+ selectedIndex = self._selectedItem.getIndex()
+ newX = currentPos.x()
+ newY = currentPos.y()
+ newPoint = newX, newY
+ model = self.scene().getModel()
+ pen = QPen(QColor("red"))
+ if isinstance(model, Polyline):
+ # Previsualisation
+ if selectedIndex == 0:
+ nextPoint = model.getPoints()[selectedIndex + 1]
+ xNext = nextPoint[0]
+ yNext = nextPoint[1]
+ self.scene().addLine(newX, newY, xNext, yNext, pen)
+ pass
+ elif selectedIndex == len(model.getPoints()) - 1:
+ previousPoint = model.getPoints()[selectedIndex - 1]
+ xPrevious = previousPoint[0]
+ yPrevious = previousPoint[1]
+ self.scene().addLine(xPrevious, yPrevious, newX, newY, pen)
+ pass
+ else:
+ previousPoint = model.getPoints()[selectedIndex - 1]
+ xPrevious = previousPoint[0]
+ yPrevious = previousPoint[1]
+ self.scene().addLine(xPrevious, yPrevious, newX, newY, pen)
+ nextPoint = model.getPoints()[selectedIndex + 1]
+ xNext = nextPoint[0]
+ yNext = nextPoint[1]
+ self.scene().addLine(newX, newY, xNext, yNext, pen)
+ pass
+ pass
+ elif isinstance(model, Circle):
+ # Previsualisation
+ radius = float(model.getRadius())
+ rect = QRectF(newX - radius, newY - radius, 2 * radius, 2 * radius)
+ circleItem = QGraphicsEllipseItem()
+ circleItem.setPen(pen)
+ circleItem.setRect(rect)
+ self.scene().addItem(circleItem)
+ pass
+ pass
+
+ def execMouseReleaseEvent(self, newPos):
+ if self._selectedItem is None:
+ return
+ selectedIndex = self._selectedItem.getIndex()
+ newX = newPos.x()
+ newY = newPos.y()
+ newPoint = newX, newY
+ model = self.scene().getModel()
+ if isinstance(model, Polyline):
+ self.scene().getController().editPoint(model, newPoint, selectedIndex)
+ pass
+ elif isinstance(model, Circle):
+ self.scene().getController().editCenter(model, newPoint)
+ pass
+ pass
- def execMouseReleaseEvent( self, newPos ) :
- if self._selectedItem is None : return
- selectedIndex = self._selectedItem.getIndex()
- newX = newPos.x()
- newY = newPos.y()
- newPoint = newX, newY
- model = self.scene().getModel()
- if isinstance( model, Polyline ) :
- self.scene().getController().editPoint( model, newPoint, selectedIndex )
- pass
- elif isinstance( model, Circle ) :
- self.scene().getController().editCenter( model, newPoint )
- pass
- pass
pass
from qtsalome import *
-class Menu( QMenu ) :
- def __init__( self, item ) :
- """Constructor"""
+class Menu(QMenu):
+ def __init__(self, item):
+ """Constructor"""
- QMenu.__init__( self )
- self._item = item
- pass
+ QMenu.__init__(self)
+ self._item = item
+ pass
+
+ def getItem(self):
+ return self._item
- def getItem( self ) :
- return self._item
pass
from qtsalome import *
from GraphicsRectItem import GraphicsRectItem
-class PolyGraphicsScene( GraphicsScene ) :
- def __init__( self, controller ) :
- GraphicsScene.__init__( self, controller )
- pass
+class PolyGraphicsScene(GraphicsScene):
+ def __init__(self, controller):
+ GraphicsScene.__init__(self, controller)
+ pass
- def draw( self ) :
- points = self.getModel().getPoints()
+ def draw(self):
+ points = self.getModel().getPoints()
- # Drawing the points as small rectangles
- for i in range( len(points) ) :
- point = points[i]
- xPoint = float( point[0] )
- yPoint = float( point[1] )
- # Constructing a rectangle centered on point
- pointItem = GraphicsRectItem( xPoint-0.1, yPoint-0.1, 0.2, 0.2, i )
- self.addItem( pointItem )
- pass
+ # Drawing the points as small rectangles
+ for i in range(len(points)):
+ point = points[i]
+ xPoint = float(point[0])
+ yPoint = float(point[1])
+ # Constructing a rectangle centered on point
+ pointItem = GraphicsRectItem(xPoint - 0.1, yPoint - 0.1, 0.2, 0.2, i)
+ self.addItem(pointItem)
+ pass
+
+ # Linking the points with lines
+ for i in range(len(points) - 1):
+ current = points[i]
+ next = points[i + 1]
+ xCurrent = float(current[0])
+ yCurrent = float(current[1])
+ xNext = float(next[0])
+ yNext = float(next[1])
+ line = QLineF(xCurrent, yCurrent, xNext, yNext)
+ lineItem = QGraphicsLineItem()
+ lineItem.setLine(line)
+ self.addItem(lineItem)
+ pass
+ pass
- # Linking the points with lines
- for i in range( len(points) - 1 ) :
- current = points[i]
- next = points[i+1]
- xCurrent = float( current[0] )
- yCurrent = float( current[1] )
- xNext = float( next[0] )
- yNext = float( next[1] )
- line = QLineF( xCurrent, yCurrent, xNext, yNext )
- lineItem = QGraphicsLineItem()
- lineItem.setLine( line )
- self.addItem( lineItem )
- pass
- pass
pass
from TreeWidgetItem import TreeWidgetItem
from qtsalome import *
-class PolyTreeWidgetItem( TreeWidgetItem ) :
- def __init__( self, name, controller, actionsList ) :
- """Constructor"""
+class PolyTreeWidgetItem(TreeWidgetItem):
+ def __init__(self, name, controller, actionsList):
+ """Constructor"""
- TreeWidgetItem.__init__( self, name, controller, actionsList )
- pass
+ TreeWidgetItem.__init__(self, name, controller, actionsList)
+ pass
- def editInGlobalTree( self, treeWidgetItem ) :
- name = self.getModel().getName()
- treeWidgetItem.setText( 0 , name )
+ def editInGlobalTree(self, treeWidgetItem):
+ name = self.getModel().getName()
+ treeWidgetItem.setText(0, name)
+
+ points = self._model.getPoints()
+ for i in range(len(points)):
+ point = points[i]
+ xPoint = point[0]
+ yPoint = point[1]
+ relatedItem = treeWidgetItem.child(i)
+ relatedItem.setText(0, str(xPoint) + ":" + str(yPoint))
+ pass
+ pass
- points = self._model.getPoints()
- for i in range( len(points) ) :
- point = points[i]
- xPoint = point[0]
- yPoint = point[1]
- relatedItem = treeWidgetItem.child( i )
- relatedItem.setText( 0 , str(xPoint) + ":" + str(yPoint) )
- pass
- pass
pass
#########################################
-class TreeWidget( QTreeWidget ) :
- def __init__( self, desktop ) :
- """Constructor"""
+class TreeWidget(QTreeWidget):
+ def __init__(self, desktop):
+ """Constructor"""
- QTreeWidget.__init__( self )
- self._desktop = desktop
+ QTreeWidget.__init__(self)
+ self._desktop = desktop
- #Creating popup menu
- self.setContextMenuPolicy( Qt.CustomContextMenu )
- self.customContextMenuRequested[QPoint].connect(self.createPopups)
- pass
+ # Creating popup menu
+ self.setContextMenuPolicy(Qt.CustomContextMenu)
+ self.customContextMenuRequested[QPoint].connect(self.createPopups)
+ pass
- def createPopups( self, point ) :
- item = self.itemAt( point )
- if item is None : return
- self.menu = Menu( item )
- for action in item.getActionsList():
- if action == "Show" :
- self.menu.addAction(action).triggered.connect(self.show)
- pass
- elif action == 'Rename' :
- self.menu.addAction(action).triggered.connect(self.showRenameDialog)
- pass
- elif action == 'Delete' :
- self.menu.addAction(action).triggered.connect(self.delete)
- pass
- else :
- self.menu.addAction(action).triggered.connect(self.showEditDialog)
- pass
- pass
- self. menu.exec_( QCursor.pos() )
- pass
+ def createPopups(self, point):
+ item = self.itemAt(point)
+ if item is None:
+ return
+ self.menu = Menu(item)
+ for action in item.getActionsList():
+ if action == "Show":
+ self.menu.addAction(action).triggered.connect(self.show)
+ pass
+ elif action == "Rename":
+ self.menu.addAction(action).triggered.connect(self.showRenameDialog)
+ pass
+ elif action == "Delete":
+ self.menu.addAction(action).triggered.connect(self.delete)
+ pass
+ else:
+ self.menu.addAction(action).triggered.connect(self.showEditDialog)
+ pass
+ pass
+ self.menu.exec_(QCursor.pos())
+ pass
- def show( self ) :
- model = self.menu.getItem().getModel()
- controller = self._desktop.getController()
- controller.showModel( model )
- pass
+ def show(self):
+ model = self.menu.getItem().getModel()
+ controller = self._desktop.getController()
+ controller.showModel(model)
+ pass
- def showRenameDialog( self ) :
- model = self.menu.getItem().getModel()
- oldName = model.getName()
- widgetDialogBox = QDockWidget( sgDesktop )
- myDialog = RenameDialog( "www.google.fr", self._desktop.getController(), widgetDialogBox, model, oldName )
- widgetDialogBox.setAllowedAreas( Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea )
- widgetDialogBox.setWidget( myDialog )
- widgetDialogBox.setWindowTitle( "Object renaming" )
- sgDesktop.addDockWidget( Qt.LeftDockWidgetArea, widgetDialogBox )
- pass
+ def showRenameDialog(self):
+ model = self.menu.getItem().getModel()
+ oldName = model.getName()
+ widgetDialogBox = QDockWidget(sgDesktop)
+ myDialog = RenameDialog(
+ "www.google.fr",
+ self._desktop.getController(),
+ widgetDialogBox,
+ model,
+ oldName,
+ )
+ widgetDialogBox.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea)
+ widgetDialogBox.setWidget(myDialog)
+ widgetDialogBox.setWindowTitle("Object renaming")
+ sgDesktop.addDockWidget(Qt.LeftDockWidgetArea, widgetDialogBox)
+ pass
- def delete( self ) :
- answer = QMessageBox.question( self, 'Confirmation', 'Do you really want to remove the selected curve ?' , QMessageBox.Yes | QMessageBox.No )
- if answer == QMessageBox.Yes :
- model = self.menu.getItem().getModel()
- controller = self._desktop.getController()
- controller.removeModel( model )
- pass
- pass
+ def delete(self):
+ answer = QMessageBox.question(
+ self,
+ "Confirmation",
+ "Do you really want to remove the selected curve ?",
+ QMessageBox.Yes | QMessageBox.No,
+ )
+ if answer == QMessageBox.Yes:
+ model = self.menu.getItem().getModel()
+ controller = self._desktop.getController()
+ controller.removeModel(model)
+ pass
+ pass
- def showEditDialog( self ) :
- item = self.menu.getItem()
- parentItem = item.parent()
- parentModel = parentItem.getModel()
- widgetDialogBox = QDockWidget( sgDesktop )
- if isinstance( parentModel, Polyline ) :
- pointRange = parentItem.indexOfChild( item )
- oldPoint = item.text( 0 )
- myDialog = EditPointDialog( "www.google.fr", self._desktop.getController(), widgetDialogBox, parentModel, oldPoint, pointRange )
- pass
- elif isinstance( parentModel, Circle ) :
- selectedRange = parentItem.indexOfChild( item )
- oldSelected = item.text( 0 )
- if selectedRange == 0 : myDialog = EditCenterDialog( "www.google.fr", self._desktop.getController(), widgetDialogBox, parentModel, oldSelected )
- elif selectedRange == 1 : myDialog = EditRadiusDialog("www.google.fr",self._desktop.getController(),widgetDialogBox,parentModel,oldSelected)
- else : pass
- pass
- else : pass
+ def showEditDialog(self):
+ item = self.menu.getItem()
+ parentItem = item.parent()
+ parentModel = parentItem.getModel()
+ widgetDialogBox = QDockWidget(sgDesktop)
+ if isinstance(parentModel, Polyline):
+ pointRange = parentItem.indexOfChild(item)
+ oldPoint = item.text(0)
+ myDialog = EditPointDialog(
+ "www.google.fr",
+ self._desktop.getController(),
+ widgetDialogBox,
+ parentModel,
+ oldPoint,
+ pointRange,
+ )
+ pass
+ elif isinstance(parentModel, Circle):
+ selectedRange = parentItem.indexOfChild(item)
+ oldSelected = item.text(0)
+ if selectedRange == 0:
+ myDialog = EditCenterDialog(
+ "www.google.fr",
+ self._desktop.getController(),
+ widgetDialogBox,
+ parentModel,
+ oldSelected,
+ )
+ elif selectedRange == 1:
+ myDialog = EditRadiusDialog(
+ "www.google.fr",
+ self._desktop.getController(),
+ widgetDialogBox,
+ parentModel,
+ oldSelected,
+ )
+ else:
+ pass
+ pass
+ else:
+ pass
+
+ widgetDialogBox.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea)
+ widgetDialogBox.setWidget(myDialog)
+ widgetDialogBox.setWindowTitle("Object edition")
+ sgDesktop.addDockWidget(Qt.LeftDockWidgetArea, widgetDialogBox)
+ pass
- widgetDialogBox.setAllowedAreas( Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea )
- widgetDialogBox.setWidget( myDialog )
- widgetDialogBox.setWindowTitle( "Object edition" )
- sgDesktop.addDockWidget( Qt.LeftDockWidgetArea, widgetDialogBox )
- pass
pass
from View import *
from qtsalome import *
-class TreeWidgetItem( View, QTreeWidgetItem ) :
-
- def __init__( self, name, controller, actionsList ) :
- """Constructor"""
-
- View.__init__( self, controller )
- self._name = [ name ]
- QTreeWidgetItem.__init__( self, self._name )
- self._actionsList = actionsList
- pass
-
- def getActionsList( self ) :
- return self._actionsList
-
- def editCenter( self, center ) :
- circle = self.getModel()
- self.getController().editCenter( circle, center )
- pass
-
- def editRadius( self, radius ) :
- circle = self.getModel()
- self.getController().editRadius( circle, radius )
- pass
-
- def update( self, mode ) :
- if mode == 'creation' :
- self.addToGlobalTree( self )
- pass
- elif mode == 'modification' :
- self.editInGlobalTree( self )
- pass
- elif mode == 'supression' :
- self.removeFromGlobalTree( self )
- pass
- else :
- return
-
- def addToGlobalTree( self, treeWidgetItem ) :
- globalTree = self.getController().getMainFrame().getGlobalTree()
- globalTree.addTopLevelItem( treeWidgetItem )
- pass
-
- def editInGlobalTree( self, treeWidgetItem ) :
- print('Virtual')
- pass
-
- def removeFromGlobalTree( self, treeWidgetItem ) :
- globalTree = self.getController().getMainFrame().getGlobalTree()
- globalTree.takeTopLevelItem( globalTree.indexOfTopLevelItem(treeWidgetItem) )
- pass
+
+class TreeWidgetItem(View, QTreeWidgetItem):
+ def __init__(self, name, controller, actionsList):
+ """Constructor"""
+
+ View.__init__(self, controller)
+ self._name = [name]
+ QTreeWidgetItem.__init__(self, self._name)
+ self._actionsList = actionsList
+ pass
+
+ def getActionsList(self):
+ return self._actionsList
+
+ def editCenter(self, center):
+ circle = self.getModel()
+ self.getController().editCenter(circle, center)
+ pass
+
+ def editRadius(self, radius):
+ circle = self.getModel()
+ self.getController().editRadius(circle, radius)
+ pass
+
+ def update(self, mode):
+ if mode == "creation":
+ self.addToGlobalTree(self)
+ pass
+ elif mode == "modification":
+ self.editInGlobalTree(self)
+ pass
+ elif mode == "supression":
+ self.removeFromGlobalTree(self)
+ pass
+ else:
+ return
+
+ def addToGlobalTree(self, treeWidgetItem):
+ globalTree = self.getController().getMainFrame().getGlobalTree()
+ globalTree.addTopLevelItem(treeWidgetItem)
+ pass
+
+ def editInGlobalTree(self, treeWidgetItem):
+ print("Virtual")
+ pass
+
+ def removeFromGlobalTree(self, treeWidgetItem):
+ globalTree = self.getController().getMainFrame().getGlobalTree()
+ globalTree.takeTopLevelItem(globalTree.indexOfTopLevelItem(treeWidgetItem))
+ pass
+
pass
-class View() :
+class View:
+ def __init__(self, controller):
+ """Constructor"""
- def __init__( self, controller ) :
- """Constructor"""
+ self._model = None
+ self._controller = controller
+ pass
- self._model = None
- self._controller = controller
- pass
+ def getModel(self):
+ return self._model
- def getModel( self ) :
- return self._model
+ def setModel(self, model):
+ self._model = model
+ pass
- def setModel( self, model ) :
- self._model = model
- pass
+ def getController(self):
+ return self._controller
- def getController( self ) :
- return self._controller
+ def setController(self, controller):
+ self._controller = controller
+ pass
- def setController( self, controller ) :
- self._controller = controller
- pass
+ def editName(self, name):
+ model = self.getModel()
+ self._controller.editName(model, name)
+ pass
- def editName( self, name ) :
- model = self.getModel()
- self._controller.editName( model, name )
- pass
+ def update(self, mode):
+ print("Virtual method")
+ pass
- def update( self, mode ) :
- print('Virtual method')
- pass
pass
from Polyline import Polyline
from Circle import Circle
-class Controller() :
+
+class Controller:
"""Manages the Model instances"""
- def __init__( self, MainFrame ) :
+ def __init__(self, MainFrame):
"""Constructor"""
self._models = []
self._nbCircles = 0
pass
- def getModels( self ) :
+ def getModels(self):
return self._models
- def getMainFrame( self ) :
+ def getMainFrame(self):
return self._mainFrame
- def getNbPolylines( self ) :
+ def getNbPolylines(self):
return self._nbPolylines
- def setNbPolylines( self, n ) :
+ def setNbPolylines(self, n):
self._nbPolylines = n
pass
- def getNbCircles( self ) :
+ def getNbCircles(self):
return self._nbCircles
- def setNbCircles( self, n ) :
+ def setNbCircles(self, n):
self._nbCircles = n
pass
- def createPolyline( self, name, randomNumberOfPoints ) :
+ def createPolyline(self, name, randomNumberOfPoints):
"""Creates a Polyline object nammed name with randomNumberOfPoints points"""
import random
# Making randomNumberOfPoints random positionned points
points = []
- x = random.uniform( 0, randomNumberOfPoints )
- for i in range( randomNumberOfPoints ) :
- x = random.uniform( x, x+randomNumberOfPoints )
- y = random.uniform( 0, x )
- point = x, y
- points.append( point )
- pass
-
- myPolyline = Polyline( name, points, self )
- self._models.append( myPolyline )
- myPolyline.updateViews( mode = 'creation' )
-
- self._nbPolylines +=1
+ x = random.uniform(0, randomNumberOfPoints)
+ for i in range(randomNumberOfPoints):
+ x = random.uniform(x, x + randomNumberOfPoints)
+ y = random.uniform(0, x)
+ point = x, y
+ points.append(point)
+ pass
+
+ myPolyline = Polyline(name, points, self)
+ self._models.append(myPolyline)
+ myPolyline.updateViews(mode="creation")
+
+ self._nbPolylines += 1
return myPolyline
- def createCircle( self, name, center, radius ) :
+ def createCircle(self, name, center, radius):
"""Creates a Circle object nammed name with center and radius"""
- myCircle = Circle( name, center, radius, self )
- self._models.append( myCircle )
- myCircle.updateViews( mode = 'creation' )
+ myCircle = Circle(name, center, radius, self)
+ self._models.append(myCircle)
+ myCircle.updateViews(mode="creation")
- self._nbCircles +=1
+ self._nbCircles += 1
return myCircle
- def showModel( self, model ) :
- model.updateViews( mode = 'showing' )
+ def showModel(self, model):
+ model.updateViews(mode="showing")
pass
- def editName( self, model, name ) :
- model.setName( name )
- model.updateViews( mode = 'modification' )
+ def editName(self, model, name):
+ model.setName(name)
+ model.updateViews(mode="modification")
return model
- def editPoint( self, polyline, newPoint, pointRange ) :
- polyline.editPoint( pointRange, newPoint )
- polyline.updateViews( mode = 'modification' )
+ def editPoint(self, polyline, newPoint, pointRange):
+ polyline.editPoint(pointRange, newPoint)
+ polyline.updateViews(mode="modification")
return polyline
- def editCenter( self, circle, center ) :
- circle.setCenter( center )
- circle.updateViews( mode = 'modification' )
+ def editCenter(self, circle, center):
+ circle.setCenter(center)
+ circle.updateViews(mode="modification")
return circle
- def editRadius( self, circle, radius ) :
- circle.setRadius( radius )
- circle.updateViews( mode = 'modification' )
+ def editRadius(self, circle, radius):
+ circle.setRadius(radius)
+ circle.updateViews(mode="modification")
return circle
- def removeModel( self, model ) :
- model.updateViews( mode = 'supression' )
- index = self._models.index( model )
+ def removeModel(self, model):
+ model.updateViews(mode="supression")
+ index = self._models.index(model)
del model
pass
- def saveListOfModels( self ) :
- for model in self._models :
- model.save()
- pass
+ def saveListOfModels(self):
+ for model in self._models:
+ model.save()
+ pass
pass
+
pass
from Dialog import *
from qtsalome import *
-class CreateCircleDialog( Dialog ) :
- def __init__( self, helpFile, controller, widgetDialogBox ) :
- """Constructor"""
+class CreateCircleDialog(Dialog):
+ def __init__(self, helpFile, controller, widgetDialogBox):
+ """Constructor"""
- # Initializing parent widget
- Dialog.__init__( self, helpFile, controller, widgetDialogBox )
+ # Initializing parent widget
+ Dialog.__init__(self, helpFile, controller, widgetDialogBox)
- # Setting default name
- nbCircles = controller.getNbCircles()
- self.entryName.setText( "circle_" + str(nbCircles+1) )
- pass
+ # Setting default name
+ nbCircles = controller.getNbCircles()
+ self.entryName.setText("circle_" + str(nbCircles + 1))
+ pass
- def addSpecialWidgets( self ) :
- floatValidator = QDoubleValidator( self )
+ def addSpecialWidgets(self):
+ floatValidator = QDoubleValidator(self)
- lxCenter = QLabel( "xCenter", self )
- self.v11.addWidget( lxCenter )
- lyCenter = QLabel( "yCenter", self )
- self.v11.addWidget( lyCenter )
- lRadius = QLabel( "Radius", self )
- self.v11.addWidget( lRadius )
+ lxCenter = QLabel("xCenter", self)
+ self.v11.addWidget(lxCenter)
+ lyCenter = QLabel("yCenter", self)
+ self.v11.addWidget(lyCenter)
+ lRadius = QLabel("Radius", self)
+ self.v11.addWidget(lRadius)
- self.entryxCenter = QLineEdit( self )
- self.entryxCenter.setValidator( floatValidator )
- self.entryxCenter.setText( "0" )
- self.v12.addWidget( self.entryxCenter )
- self.entryyCenter = QLineEdit( self )
- self.entryyCenter.setValidator( floatValidator )
- self.entryyCenter.setText( "0" )
- self.v12.addWidget( self.entryyCenter )
- self.entryRadius = QLineEdit( self )
- self.entryRadius.setValidator( floatValidator )
- self.entryRadius.setText( "10" )
- self.v12.addWidget( self.entryRadius)
- pass
+ self.entryxCenter = QLineEdit(self)
+ self.entryxCenter.setValidator(floatValidator)
+ self.entryxCenter.setText("0")
+ self.v12.addWidget(self.entryxCenter)
+ self.entryyCenter = QLineEdit(self)
+ self.entryyCenter.setValidator(floatValidator)
+ self.entryyCenter.setText("0")
+ self.v12.addWidget(self.entryyCenter)
+ self.entryRadius = QLineEdit(self)
+ self.entryRadius.setValidator(floatValidator)
+ self.entryRadius.setText("10")
+ self.v12.addWidget(self.entryRadius)
+ pass
- def execApply( self ) :
- name = self.name
- center = float(self.xCenter), float(self.yCenter)
- radius = float( self.radius )
- self.getController().createCircle( name, center, radius )
- self.reInitializeDialog()
- return
+ def execApply(self):
+ name = self.name
+ center = float(self.xCenter), float(self.yCenter)
+ radius = float(self.radius)
+ self.getController().createCircle(name, center, radius)
+ self.reInitializeDialog()
+ return
- def retrieveUserEntries( self ) :
- self.name = str( self.entryName.text() )
- self.xCenter = str( self.entryxCenter.text() )
- self.yCenter = str( self.entryyCenter.text() )
- self.radius = str( self.entryRadius.text() )
- pass
+ def retrieveUserEntries(self):
+ self.name = str(self.entryName.text())
+ self.xCenter = str(self.entryxCenter.text())
+ self.yCenter = str(self.entryyCenter.text())
+ self.radius = str(self.entryRadius.text())
+ pass
- def checkUserEntries( self ) :
- if self.name == "" or self.xCenter == "" or self.yCenter == "" or self.radius == "" :
- self.errMessage = 'All attributes must be filled'
- return False
- return True
+ def checkUserEntries(self):
+ if (
+ self.name == ""
+ or self.xCenter == ""
+ or self.yCenter == ""
+ or self.radius == ""
+ ):
+ self.errMessage = "All attributes must be filled"
+ return False
+ return True
+
+ def reInitializeDialog(self):
+ nbCircles = self.getController().getNbCircles()
+ self.entryName.setText("circle_" + str(nbCircles + 1))
+ self.entryxCenter.setText("0")
+ self.entryyCenter.setText("0")
+ self.entryRadius.setText("10")
+ pass
- def reInitializeDialog( self ) :
- nbCircles = self.getController().getNbCircles()
- self.entryName.setText( "circle_" + str(nbCircles+1) )
- self.entryxCenter.setText( "0" )
- self.entryyCenter.setText( "0" )
- self.entryRadius.setText( "10" )
- pass
pass
from Dialog import Dialog
from qtsalome import *
-class CreatePolylineDialog( Dialog ) :
-
- def __init__( self, helpFile, controller, widgetDialogBox ) :
- """Constructor"""
-
- #Initializing parent widget
- Dialog.__init__( self, helpFile, controller, widgetDialogBox )
-
- #Setting default name
- nbPolylines = controller.getNbPolylines()
- self.entryName.setText( "polyline_" + str(nbPolylines+1) )
- pass
-
- def addSpecialWidgets( self ) :
-
- intValidator = QIntValidator( self )
-
- lNbPoints = QLabel( "Number of points", self )
- self.v11.addWidget( lNbPoints )
-
- self.entryNbPoints = QLineEdit( self )
- self.entryNbPoints.setValidator( intValidator )
- self.entryNbPoints.setText( "10" )
- self.v12.addWidget( self.entryNbPoints )
- pass
-
- def execApply( self ) :
- name = self.name
- nbPoints = int( self.nbPoints )
- self.getController().createPolyline( name, nbPoints )
- self.reInitializeDialog()
- return
-
-
- def retrieveUserEntries( self ) :
- self.name = str( self.entryName.text() )
- self.nbPoints = str( self.entryNbPoints.text() )
- pass
-
- def checkUserEntries( self ) :
- if self.name == "" or self.nbPoints == "" :
- self.errMessage = 'All attributes must be filled'
- return False
- if int( self.nbPoints ) > 10 :
- self.errMessage = 'The number of points must not exceed 10'
- return False
- return True
-
- def reInitializeDialog( self ) :
- nbPolylines = self.getController().getNbPolylines()
- self.entryName.setText( "polyline_" + str(nbPolylines+1) )
- self.entryNbPoints.setText( "10" )
- pass
+
+class CreatePolylineDialog(Dialog):
+ def __init__(self, helpFile, controller, widgetDialogBox):
+ """Constructor"""
+
+ # Initializing parent widget
+ Dialog.__init__(self, helpFile, controller, widgetDialogBox)
+
+ # Setting default name
+ nbPolylines = controller.getNbPolylines()
+ self.entryName.setText("polyline_" + str(nbPolylines + 1))
+ pass
+
+ def addSpecialWidgets(self):
+
+ intValidator = QIntValidator(self)
+
+ lNbPoints = QLabel("Number of points", self)
+ self.v11.addWidget(lNbPoints)
+
+ self.entryNbPoints = QLineEdit(self)
+ self.entryNbPoints.setValidator(intValidator)
+ self.entryNbPoints.setText("10")
+ self.v12.addWidget(self.entryNbPoints)
+ pass
+
+ def execApply(self):
+ name = self.name
+ nbPoints = int(self.nbPoints)
+ self.getController().createPolyline(name, nbPoints)
+ self.reInitializeDialog()
+ return
+
+ def retrieveUserEntries(self):
+ self.name = str(self.entryName.text())
+ self.nbPoints = str(self.entryNbPoints.text())
+ pass
+
+ def checkUserEntries(self):
+ if self.name == "" or self.nbPoints == "":
+ self.errMessage = "All attributes must be filled"
+ return False
+ if int(self.nbPoints) > 10:
+ self.errMessage = "The number of points must not exceed 10"
+ return False
+ return True
+
+ def reInitializeDialog(self):
+ nbPolylines = self.getController().getNbPolylines()
+ self.entryName.setText("polyline_" + str(nbPolylines + 1))
+ self.entryNbPoints.setText("10")
+ pass
+
pass
from DialogEdit import *
from qtsalome import *
-class EditCenterDialog( DialogEdit ) :
-
- def __init__( self, helpFile, controller, widgetDialogBox, model, oldCenter ) :
- """Constructor"""
-
- # Initializing parent widget
- DialogEdit.__init__( self, helpFile, controller, widgetDialogBox )
-
- self._model = model
-
- # Reading oldX and oldY
- oldX = ""
- oldY = ""
- i = 0
- while oldCenter[i] != ':' :
- oldX += oldCenter[i]
- i += 1
- pass
- for j in range( i+1, len(oldCenter) ) :
- oldY += oldCenter[j]
- pass
- self.entryX.setText( oldX )
- self.entryY.setText( oldY )
- pass
-
- def addSpecialWidgets( self ) :
- floatValidator = QDoubleValidator( self )
-
- lX = QLabel( "X", self )
- self.v11.addWidget( lX )
- lY = QLabel( "Y", self )
- self.v11.addWidget( lY )
-
- self.entryX = QLineEdit( self )
- self.entryX.setValidator( floatValidator )
- self.v12.addWidget( self.entryX )
- self.entryY = QLineEdit( self )
- self.entryY.setValidator( floatValidator )
- self.v12.addWidget( self.entryY )
- pass
-
- def execApply( self ) :
- newX = float( self.newX )
- newY = float( self.newY )
- newCenter = newX, newY
- self.getController().editCenter( self._model, newCenter )
- return
-
- def retrieveUserEntries( self ) :
- self.newX= str( self.entryX.text() )
- self.newY= str( self.entryY.text() )
- pass
-
- def checkUserEntries( self ) :
- if self.newX == "" or self.newY == "" :
- self.errMessage = 'All attributes must be filled'
- return False
- return True
+
+class EditCenterDialog(DialogEdit):
+ def __init__(self, helpFile, controller, widgetDialogBox, model, oldCenter):
+ """Constructor"""
+
+ # Initializing parent widget
+ DialogEdit.__init__(self, helpFile, controller, widgetDialogBox)
+
+ self._model = model
+
+ # Reading oldX and oldY
+ oldX = ""
+ oldY = ""
+ i = 0
+ while oldCenter[i] != ":":
+ oldX += oldCenter[i]
+ i += 1
+ pass
+ for j in range(i + 1, len(oldCenter)):
+ oldY += oldCenter[j]
+ pass
+ self.entryX.setText(oldX)
+ self.entryY.setText(oldY)
+ pass
+
+ def addSpecialWidgets(self):
+ floatValidator = QDoubleValidator(self)
+
+ lX = QLabel("X", self)
+ self.v11.addWidget(lX)
+ lY = QLabel("Y", self)
+ self.v11.addWidget(lY)
+
+ self.entryX = QLineEdit(self)
+ self.entryX.setValidator(floatValidator)
+ self.v12.addWidget(self.entryX)
+ self.entryY = QLineEdit(self)
+ self.entryY.setValidator(floatValidator)
+ self.v12.addWidget(self.entryY)
+ pass
+
+ def execApply(self):
+ newX = float(self.newX)
+ newY = float(self.newY)
+ newCenter = newX, newY
+ self.getController().editCenter(self._model, newCenter)
+ return
+
+ def retrieveUserEntries(self):
+ self.newX = str(self.entryX.text())
+ self.newY = str(self.entryY.text())
+ pass
+
+ def checkUserEntries(self):
+ if self.newX == "" or self.newY == "":
+ self.errMessage = "All attributes must be filled"
+ return False
+ return True
+
pass
from DialogEdit import *
from qtsalome import *
-class EditPointDialog( DialogEdit ) :
- def __init__( self, helpFile, controller, widgetDialogBox, model, oldPoint, pointRange ) :
- """Constructor"""
+class EditPointDialog(DialogEdit):
+ def __init__(
+ self, helpFile, controller, widgetDialogBox, model, oldPoint, pointRange
+ ):
+ """Constructor"""
- #Initializing parent widget
- DialogEdit.__init__( self, helpFile, controller, widgetDialogBox )
+ # Initializing parent widget
+ DialogEdit.__init__(self, helpFile, controller, widgetDialogBox)
- self._model = model
+ self._model = model
- #Reading oldX and oldY
- oldX = ""
- oldY = ""
- i = 0
- while oldPoint[i] != ':' :
- oldX += oldPoint[i]
- i += 1
- pass
- for j in range( i+1, len(oldPoint) ) :
- oldY += oldPoint[j]
- pass
- self.pointRange = pointRange
- self.entryX.setText( oldX )
- self.entryY.setText( oldY )
- pass
+ # Reading oldX and oldY
+ oldX = ""
+ oldY = ""
+ i = 0
+ while oldPoint[i] != ":":
+ oldX += oldPoint[i]
+ i += 1
+ pass
+ for j in range(i + 1, len(oldPoint)):
+ oldY += oldPoint[j]
+ pass
+ self.pointRange = pointRange
+ self.entryX.setText(oldX)
+ self.entryY.setText(oldY)
+ pass
- def addSpecialWidgets( self ) :
- floatValidator = QDoubleValidator( self )
+ def addSpecialWidgets(self):
+ floatValidator = QDoubleValidator(self)
- lX = QLabel( "X", self )
- self.v11.addWidget( lX )
- lY = QLabel( "Y", self )
- self.v11.addWidget( lY )
+ lX = QLabel("X", self)
+ self.v11.addWidget(lX)
+ lY = QLabel("Y", self)
+ self.v11.addWidget(lY)
- self.entryX = QLineEdit( self )
- self.entryX.setValidator( floatValidator )
- self.v12.addWidget( self.entryX )
- self.entryY = QLineEdit( self )
- self.entryY.setValidator( floatValidator )
- self.v12.addWidget( self.entryY )
- pass
+ self.entryX = QLineEdit(self)
+ self.entryX.setValidator(floatValidator)
+ self.v12.addWidget(self.entryX)
+ self.entryY = QLineEdit(self)
+ self.entryY.setValidator(floatValidator)
+ self.v12.addWidget(self.entryY)
+ pass
- def execApply( self ) :
- pointRange = self.pointRange
- newX = float( self.newX )
- newY = float( self.newY )
- newPoint = newX, newY
- self.getController().editPoint( self._model, newPoint, pointRange )
- return
+ def execApply(self):
+ pointRange = self.pointRange
+ newX = float(self.newX)
+ newY = float(self.newY)
+ newPoint = newX, newY
+ self.getController().editPoint(self._model, newPoint, pointRange)
+ return
+ def retrieveUserEntries(self):
+ self.newX = str(self.entryX.text())
+ self.newY = str(self.entryY.text())
+ pass
- def retrieveUserEntries( self ) :
- self.newX= str( self.entryX.text() )
- self.newY= str( self.entryY.text() )
- pass
+ def checkUserEntries(self):
+ if self.newX == "" or self.newY == "":
+ self.errMessage = "All attributes must be filled"
+ return False
+ return True
- def checkUserEntries( self ) :
- if self.newX == "" or self.newY == "" :
- self.errMessage = 'All attributes must be filled'
- return False
- return True
pass
from DialogEdit import *
from qtsalome import *
-class EditRadiusDialog( DialogEdit ) :
- def __init__( self, helpFile, controller, widgetDialogBox, model, oldRadius ) :
- """Constructor"""
+class EditRadiusDialog(DialogEdit):
+ def __init__(self, helpFile, controller, widgetDialogBox, model, oldRadius):
+ """Constructor"""
- #Initializing parent widget
- DialogEdit.__init__( self, helpFile, controller, widgetDialogBox )
+ # Initializing parent widget
+ DialogEdit.__init__(self, helpFile, controller, widgetDialogBox)
- self._model = model
- self.entryRadius.setText( oldRadius )
- pass
+ self._model = model
+ self.entryRadius.setText(oldRadius)
+ pass
- def addSpecialWidgets( self ) :
- floatValidator = QDoubleValidator( self )
+ def addSpecialWidgets(self):
+ floatValidator = QDoubleValidator(self)
- lRadius = QLabel( "Radius", self )
- self.v11.addWidget( lRadius )
- self.entryRadius = QLineEdit( self )
- self.entryRadius.setValidator( floatValidator )
- self.v12.addWidget( self.entryRadius )
- pass
+ lRadius = QLabel("Radius", self)
+ self.v11.addWidget(lRadius)
+ self.entryRadius = QLineEdit(self)
+ self.entryRadius.setValidator(floatValidator)
+ self.v12.addWidget(self.entryRadius)
+ pass
- def execApply( self ) :
- newRadius = self.newRadius
- self.getController().editRadius( self._model, newRadius )
- return
+ def execApply(self):
+ newRadius = self.newRadius
+ self.getController().editRadius(self._model, newRadius)
+ return
+ def retrieveUserEntries(self):
+ self.newRadius = str(self.entryRadius.text())
+ pass
- def retrieveUserEntries( self ) :
- self.newRadius = str( self.entryRadius.text() )
- pass
+ def checkUserEntries(self):
+ if self.newRadius == "":
+ self.errMessage = "All attributes must be filled"
+ return False
+ return True
- def checkUserEntries( self ) :
- if self.newRadius == "" :
- self.errMessage = 'All attributes must be filled'
- return False
- return True
pass
from DialogEdit import *
from qtsalome import *
-class RenameDialog( DialogEdit ) :
-
- def __init__( self, helpFile, controller, widgetDialogBox, model, oldName ) :
- """Constructor"""
-
- # Initializing parent widget
- DialogEdit.__init__( self, helpFile, controller, widgetDialogBox )
-
- self._model = model
- self.entryName.setText( oldName )
- pass
-
- def addSpecialWidgets( self ) :
- lName = QLabel( "Name", self )
- self.v11.addWidget( lName )
- self.entryName = QLineEdit( self )
- self.v12.addWidget( self.entryName )
- pass
-
- def execApply( self ) :
- newName = self.newName
- self.getController().editName( self._model, newName )
- return
-
- def retrieveUserEntries( self ) :
- self.newName = str( self.entryName.text() )
- pass
-
- def checkUserEntries( self ) :
- if self.newName == "" :
- self.errMessage = 'All attributes must be filled'
- return False
- return True
+
+class RenameDialog(DialogEdit):
+ def __init__(self, helpFile, controller, widgetDialogBox, model, oldName):
+ """Constructor"""
+
+ # Initializing parent widget
+ DialogEdit.__init__(self, helpFile, controller, widgetDialogBox)
+
+ self._model = model
+ self.entryName.setText(oldName)
+ pass
+
+ def addSpecialWidgets(self):
+ lName = QLabel("Name", self)
+ self.v11.addWidget(lName)
+ self.entryName = QLineEdit(self)
+ self.v12.addWidget(self.entryName)
+ pass
+
+ def execApply(self):
+ newName = self.newName
+ self.getController().editName(self._model, newName)
+ return
+
+ def retrieveUserEntries(self):
+ self.newName = str(self.entryName.text())
+ pass
+
+ def checkUserEntries(self):
+ if self.newName == "":
+ self.errMessage = "All attributes must be filled"
+ return False
+ return True
+
pass
from qtsalome import *
__all__ = [
- "Circle",
- ]
-
-class Circle( Model ):
-
- def __init__( self, name, center, radius, controller ):
- """Constructor"""
-
- Model.__init__( self,controller )
- self._name = name
- self._center = center
- self._radius = radius
- self.addTreeWidgetItem( self.getName(), controller )
- self.addGraphicScene( controller )
- pass
-
- def getCenter( self ):
- return self._center[0], self._center[1]
-
- def setCenter( self, center ):
- self._center = center
- pass
-
- def getRadius( self ):
- return self._radius
-
- def setRadius( self, radius ):
- self._radius = radius
-
- def addTreeWidgetItem( self, name, controller ):
- from CircleTreeWidgetItem import CircleTreeWidgetItem
- from TreeWidgetItem import TreeWidgetItem
-
- myTreeWidgetItem = CircleTreeWidgetItem( name, controller, ["Show", "Rename", "Delete"] )
- newTreeWidgetItem = TreeWidgetItem( str(self.getCenter()[0]) + ':' + str(self.getCenter()[1]), controller, ["Edit"] )
- myTreeWidgetItem.addChild( newTreeWidgetItem )
- newTreeWidgetItem = TreeWidgetItem( str(self.getRadius()), controller, ["Edit"] )
- myTreeWidgetItem.addChild( newTreeWidgetItem )
- myTreeWidgetItem.setModel( self )
- self.getViews().append( myTreeWidgetItem )
- return myTreeWidgetItem
-
- def addGraphicScene( self, controller ) :
- from CircleGraphicsScene import CircleGraphicsScene
-
- myGraphicsScene = CircleGraphicsScene( controller )
- myGraphicsScene.setModel( self )
- self.getViews().append( myGraphicsScene )
- return myGraphicsScene
-
- def save( self ):
- pass
+ "Circle",
+]
+
+
+class Circle(Model):
+ def __init__(self, name, center, radius, controller):
+ """Constructor"""
+
+ Model.__init__(self, controller)
+ self._name = name
+ self._center = center
+ self._radius = radius
+ self.addTreeWidgetItem(self.getName(), controller)
+ self.addGraphicScene(controller)
+ pass
+
+ def getCenter(self):
+ return self._center[0], self._center[1]
+
+ def setCenter(self, center):
+ self._center = center
+ pass
+
+ def getRadius(self):
+ return self._radius
+
+ def setRadius(self, radius):
+ self._radius = radius
+
+ def addTreeWidgetItem(self, name, controller):
+ from CircleTreeWidgetItem import CircleTreeWidgetItem
+ from TreeWidgetItem import TreeWidgetItem
+
+ myTreeWidgetItem = CircleTreeWidgetItem(
+ name, controller, ["Show", "Rename", "Delete"]
+ )
+ newTreeWidgetItem = TreeWidgetItem(
+ str(self.getCenter()[0]) + ":" + str(self.getCenter()[1]),
+ controller,
+ ["Edit"],
+ )
+ myTreeWidgetItem.addChild(newTreeWidgetItem)
+ newTreeWidgetItem = TreeWidgetItem(str(self.getRadius()), controller, ["Edit"])
+ myTreeWidgetItem.addChild(newTreeWidgetItem)
+ myTreeWidgetItem.setModel(self)
+ self.getViews().append(myTreeWidgetItem)
+ return myTreeWidgetItem
+
+ def addGraphicScene(self, controller):
+ from CircleGraphicsScene import CircleGraphicsScene
+
+ myGraphicsScene = CircleGraphicsScene(controller)
+ myGraphicsScene.setModel(self)
+ self.getViews().append(myGraphicsScene)
+ return myGraphicsScene
+
+ def save(self):
+ pass
+
pass
from Model import *
from qtsalome import *
-class Polyline( Model ):
-
- def __init__( self, name, points, controller ):
- """Constructor"""
-
- Model.__init__( self, controller )
- self._name = name
- self._points = points
- self.addTreeWidgetItem( self.getName(), controller )
- self.addGraphicScene( controller )
- pass
-
- def getPoints( self ):
- return self._points
-
- def setPoints( self, points ):
- self._points = points
- pass
-
- def editPoint( self, pointRange, newPoint ) :
- self._points[ pointRange ] = newPoint
- pass
-
- def addTreeWidgetItem( self, name, controller ):
- from PolyTreeWidgetItem import PolyTreeWidgetItem
- from TreeWidgetItem import TreeWidgetItem
-
- myTreeWidgetItem = PolyTreeWidgetItem( name, controller, ["Show", "Rename", "Delete"] )
- # Adding list of points
- for point in self.getPoints() :
- x = point[0]
- y = point[1]
- newTreeWidgetItem = TreeWidgetItem( str(x) + ":" + str(y), controller, ["Edit"] )
- myTreeWidgetItem.addChild( newTreeWidgetItem )
- pass
- myTreeWidgetItem.setModel( self )
- self.getViews().append( myTreeWidgetItem )
- return myTreeWidgetItem
-
- def addGraphicScene( self, controller ) :
- from PolyGraphicsScene import PolyGraphicsScene
-
- myGraphicsScene = PolyGraphicsScene( controller )
- myGraphicsScene.setModel( self )
- self.getViews().append( myGraphicsScene )
- return myGraphicsScene
-
- def save( self ):
- pass
+
+class Polyline(Model):
+ def __init__(self, name, points, controller):
+ """Constructor"""
+
+ Model.__init__(self, controller)
+ self._name = name
+ self._points = points
+ self.addTreeWidgetItem(self.getName(), controller)
+ self.addGraphicScene(controller)
+ pass
+
+ def getPoints(self):
+ return self._points
+
+ def setPoints(self, points):
+ self._points = points
+ pass
+
+ def editPoint(self, pointRange, newPoint):
+ self._points[pointRange] = newPoint
+ pass
+
+ def addTreeWidgetItem(self, name, controller):
+ from PolyTreeWidgetItem import PolyTreeWidgetItem
+ from TreeWidgetItem import TreeWidgetItem
+
+ myTreeWidgetItem = PolyTreeWidgetItem(
+ name, controller, ["Show", "Rename", "Delete"]
+ )
+ # Adding list of points
+ for point in self.getPoints():
+ x = point[0]
+ y = point[1]
+ newTreeWidgetItem = TreeWidgetItem(
+ str(x) + ":" + str(y), controller, ["Edit"]
+ )
+ myTreeWidgetItem.addChild(newTreeWidgetItem)
+ pass
+ myTreeWidgetItem.setModel(self)
+ self.getViews().append(myTreeWidgetItem)
+ return myTreeWidgetItem
+
+ def addGraphicScene(self, controller):
+ from PolyGraphicsScene import PolyGraphicsScene
+
+ myGraphicsScene = PolyGraphicsScene(controller)
+ myGraphicsScene.setModel(self)
+ self.getViews().append(myGraphicsScene)
+ return myGraphicsScene
+
+ def save(self):
+ pass
+
pass
-from PyQt5.QtCore import *
-from PyQt5.QtGui import *
+from PyQt5.QtCore import *
+from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
from TreeWidget import TreeWidget
from GraphicsView import GraphicsView
from GraphicsScene import GraphicsScene
-class Desktop( QMainWindow ) :
-
- def __init__( self ) :
- """Constructor"""
-
- QMainWindow.__init__( self )
- self._controller = None
-
- # Creating a dockWidget which will contain globalTree
- self._globalTree= TreeWidget( self )
- self._globalTree.setHeaderLabel ( "Object browser" )
- dockGlobalTree = QDockWidget( "Tree view", self )
- dockGlobalTree.setAllowedAreas( Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea )
- dockGlobalTree.setWidget( self._globalTree )
- self.addDockWidget( Qt.LeftDockWidgetArea, dockGlobalTree )
-
- # Creating a central widget which contains the globalGraphicsView
- self._dockGlobalView = QDockWidget( "Graphics view", self )
- scene = GraphicsScene( self._controller )
- self._globalGraphicsView = GraphicsView( scene )
- self._dockGlobalView.setWidget( self._globalGraphicsView )
- self._globalGraphicsView.show()
- self.setCentralWidget( self._dockGlobalView )
-
- # Creating menus and toolbars
- self.createMenus()
- self.createToolBars()
- pass
-
- def getController( self ) :
- return self._controller
-
- def setController( self, controller ) :
- self._controller = controller
- pass
-
- def getGlobalTree( self ) :
- return self._globalTree
-
- def createMenus( self ) :
- # Creating menus
- curveMenu = self.menuBar().addMenu( "Curve" )
- toolsMenu = self.menuBar().addMenu( "Tools" )
- # Adding actions
- createPolylineAction = QAction( "Polyline", self )
- createCircleAction = QAction( "Circle", self )
- curveMenu.addAction( createPolylineAction )
- curveMenu.addAction( createCircleAction )
-
- deleteAllAction = QAction( "Delete all", self )
- toolsMenu.addAction( deleteAllAction )
- # Connecting slots
- createPolylineAction.triggered.connect(self.showCreatePolylineDialog)
- createCircleAction.triggered.connect(self.showCreateCircleDialog)
- deleteAllAction.triggered.connect(self.deleteAll)
- pass
-
- def createToolBars( self ) :
- # Creating toolBars
- createPolylineTB = self.addToolBar( "New polyline")
- createCircleTB = self.addToolBar( "New circle")
- createPolylineAction = QAction( "Polyline", self )
- createCircleAction = QAction( "Circle", self )
- # Adding actions
- createPolylineTB.addAction( createPolylineAction )
- createCircleTB.addAction( createCircleAction )
- # Connecting slots
- createPolylineAction.triggered.connect(self.showCreatePolylineDialog)
- createCircleAction.triggered.connect(self.showCreateCircleDialog)
- pass
-
- def showCreatePolylineDialog( self ) :
- from CreatePolylineDialog import CreatePolylineDialog
-
- widgetDialogBox = QDockWidget( "myDockWidget", self )
- myDialog = CreatePolylineDialog( "www.google.fr", self._controller, widgetDialogBox )
- widgetDialogBox.setAllowedAreas( Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea )
- widgetDialogBox.setWidget( myDialog )
- widgetDialogBox.setWindowTitle( "Polyline definition" )
- self.addDockWidget( Qt.LeftDockWidgetArea, widgetDialogBox )
- pass
-
- def showCreateCircleDialog( self ) :
- from CreateCircleDialog import CreateCircleDialog
-
- widgetDialogBox = QDockWidget( "myDockWidget", self )
- myDialog = CreateCircleDialog( "www.cea.fr", self._controller, widgetDialogBox )
- widgetDialogBox.setAllowedAreas( Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea )
- widgetDialogBox.setWidget( myDialog )
- widgetDialogBox.setWindowTitle( "Polyline definition" )
- self.addDockWidget( Qt.LeftDockWidgetArea, widgetDialogBox )
- pass
-
- def deleteAll( self ) :
- models = self.getController().getModels()
- if len( models ) == 0 : return
- answer = QMessageBox.question( self, 'Confirmation', 'Do you really want to delete all the existing objects ?' , QMessageBox.Yes | QMessageBox.No )
- if answer == QMessageBox.Yes :
- for model in models :
- self.getController().removeModel( model )
- pass
- pass
- pass
-
- def updateGlobalGraphicsView( self, scene ) :
- self._globalGraphicsView.setScene( scene )
- if scene is None :
- self._dockGlobalView.setWindowTitle( "Graphics view" )
- return
- self._dockGlobalView.setWindowTitle( "Graphics view : showing " + scene.getModel().getName() )
- #Resizing the globalGraphicView
- sceneRect = scene.getRect()
- topLeft = sceneRect.topLeft()
- viewRect = QRectF( topLeft.x(), topLeft.y(), 2*sceneRect.width(), 2*sceneRect.height() )
- self._globalGraphicsView.fitInView ( viewRect, Qt.IgnoreAspectRatio )
- pass
+
+class Desktop(QMainWindow):
+ def __init__(self):
+ """Constructor"""
+
+ QMainWindow.__init__(self)
+ self._controller = None
+
+ # Creating a dockWidget which will contain globalTree
+ self._globalTree = TreeWidget(self)
+ self._globalTree.setHeaderLabel("Object browser")
+ dockGlobalTree = QDockWidget("Tree view", self)
+ dockGlobalTree.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea)
+ dockGlobalTree.setWidget(self._globalTree)
+ self.addDockWidget(Qt.LeftDockWidgetArea, dockGlobalTree)
+
+ # Creating a central widget which contains the globalGraphicsView
+ self._dockGlobalView = QDockWidget("Graphics view", self)
+ scene = GraphicsScene(self._controller)
+ self._globalGraphicsView = GraphicsView(scene)
+ self._dockGlobalView.setWidget(self._globalGraphicsView)
+ self._globalGraphicsView.show()
+ self.setCentralWidget(self._dockGlobalView)
+
+ # Creating menus and toolbars
+ self.createMenus()
+ self.createToolBars()
+ pass
+
+ def getController(self):
+ return self._controller
+
+ def setController(self, controller):
+ self._controller = controller
+ pass
+
+ def getGlobalTree(self):
+ return self._globalTree
+
+ def createMenus(self):
+ # Creating menus
+ curveMenu = self.menuBar().addMenu("Curve")
+ toolsMenu = self.menuBar().addMenu("Tools")
+ # Adding actions
+ createPolylineAction = QAction("Polyline", self)
+ createCircleAction = QAction("Circle", self)
+ curveMenu.addAction(createPolylineAction)
+ curveMenu.addAction(createCircleAction)
+
+ deleteAllAction = QAction("Delete all", self)
+ toolsMenu.addAction(deleteAllAction)
+ # Connecting slots
+ createPolylineAction.triggered.connect(self.showCreatePolylineDialog)
+ createCircleAction.triggered.connect(self.showCreateCircleDialog)
+ deleteAllAction.triggered.connect(self.deleteAll)
+ pass
+
+ def createToolBars(self):
+ # Creating toolBars
+ createPolylineTB = self.addToolBar("New polyline")
+ createCircleTB = self.addToolBar("New circle")
+ createPolylineAction = QAction("Polyline", self)
+ createCircleAction = QAction("Circle", self)
+ # Adding actions
+ createPolylineTB.addAction(createPolylineAction)
+ createCircleTB.addAction(createCircleAction)
+ # Connecting slots
+ createPolylineAction.triggered.connect(self.showCreatePolylineDialog)
+ createCircleAction.triggered.connect(self.showCreateCircleDialog)
+ pass
+
+ def showCreatePolylineDialog(self):
+ from CreatePolylineDialog import CreatePolylineDialog
+
+ widgetDialogBox = QDockWidget("myDockWidget", self)
+ myDialog = CreatePolylineDialog(
+ "www.google.fr", self._controller, widgetDialogBox
+ )
+ widgetDialogBox.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea)
+ widgetDialogBox.setWidget(myDialog)
+ widgetDialogBox.setWindowTitle("Polyline definition")
+ self.addDockWidget(Qt.LeftDockWidgetArea, widgetDialogBox)
+ pass
+
+ def showCreateCircleDialog(self):
+ from CreateCircleDialog import CreateCircleDialog
+
+ widgetDialogBox = QDockWidget("myDockWidget", self)
+ myDialog = CreateCircleDialog("www.cea.fr", self._controller, widgetDialogBox)
+ widgetDialogBox.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea)
+ widgetDialogBox.setWidget(myDialog)
+ widgetDialogBox.setWindowTitle("Polyline definition")
+ self.addDockWidget(Qt.LeftDockWidgetArea, widgetDialogBox)
+ pass
+
+ def deleteAll(self):
+ models = self.getController().getModels()
+ if len(models) == 0:
+ return
+ answer = QMessageBox.question(
+ self,
+ "Confirmation",
+ "Do you really want to delete all the existing objects ?",
+ QMessageBox.Yes | QMessageBox.No,
+ )
+ if answer == QMessageBox.Yes:
+ for model in models:
+ self.getController().removeModel(model)
+ pass
+ pass
+ pass
+
+ def updateGlobalGraphicsView(self, scene):
+ self._globalGraphicsView.setScene(scene)
+ if scene is None:
+ self._dockGlobalView.setWindowTitle("Graphics view")
+ return
+ self._dockGlobalView.setWindowTitle(
+ "Graphics view : showing " + scene.getModel().getName()
+ )
+ # Resizing the globalGraphicView
+ sceneRect = scene.getRect()
+ topLeft = sceneRect.topLeft()
+ viewRect = QRectF(
+ topLeft.x(), topLeft.y(), 2 * sceneRect.width(), 2 * sceneRect.height()
+ )
+ self._globalGraphicsView.fitInView(viewRect, Qt.IgnoreAspectRatio)
+ pass
+
pass
import sys
-from PyQt5.QtCore import *
-from PyQt5.QtGui import *
+from PyQt5.QtCore import *
+from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
from Controller import Controller
from Desktop import Desktop
-def main( args ) :
- Appli = QApplication( args )
+
+def main(args):
+ Appli = QApplication(args)
MainFrame = Desktop()
- myController = Controller( MainFrame )
- MainFrame.setController( myController )
+ myController = Controller(MainFrame)
+ MainFrame.setController(myController)
MainFrame.show()
Appli.exec_()
-if __name__ == "__main__" :
- main( sys.argv )
- pass
+if __name__ == "__main__":
+ main(sys.argv)
+ pass
from qtsalome import *
from GraphicsRectItem import GraphicsRectItem
-class CircleGraphicsScene( GraphicsScene ) :
-
- def __init__( self, controller ) :
- GraphicsScene.__init__( self, controller )
- pass
-
- def draw( self ) :
-
- import math
-
- center = self._model.getCenter()
- radius = float( self._model.getRadius() )
- xCenter = float( center[0] )
- yCenter = float( center[1] )
-
- #Drawing the center as a small rectangle
- centerItem = GraphicsRectItem( xCenter-0.1, yCenter-0.1, 0.2, 0.2, None )
- self.addItem( centerItem )
- #Drawing the circle
- rect = QRectF( xCenter-radius, yCenter-radius, 2*radius, 2*radius )
- circleItem = QGraphicsEllipseItem()
- circleItem.setRect( rect )
- self.addItem( circleItem )
- pass
+
+class CircleGraphicsScene(GraphicsScene):
+ def __init__(self, controller):
+ GraphicsScene.__init__(self, controller)
+ pass
+
+ def draw(self):
+
+ import math
+
+ center = self._model.getCenter()
+ radius = float(self._model.getRadius())
+ xCenter = float(center[0])
+ yCenter = float(center[1])
+
+ # Drawing the center as a small rectangle
+ centerItem = GraphicsRectItem(xCenter - 0.1, yCenter - 0.1, 0.2, 0.2, None)
+ self.addItem(centerItem)
+ # Drawing the circle
+ rect = QRectF(xCenter - radius, yCenter - radius, 2 * radius, 2 * radius)
+ circleItem = QGraphicsEllipseItem()
+ circleItem.setRect(rect)
+ self.addItem(circleItem)
+ pass
+
pass
from TreeWidgetItem import TreeWidgetItem
from qtsalome import *
-class CircleTreeWidgetItem( TreeWidgetItem ) :
- def __init__( self, name, controller, actionsList ) :
- """Constructor"""
+class CircleTreeWidgetItem(TreeWidgetItem):
+ def __init__(self, name, controller, actionsList):
+ """Constructor"""
- TreeWidgetItem.__init__( self, name, controller, actionsList )
- pass
+ TreeWidgetItem.__init__(self, name, controller, actionsList)
+ pass
- def editInGlobalTree( self, treeWidgetItem ) :
- name = self.getModel().getName()
- treeWidgetItem.setText( 0 , name )
- center = self._model.getCenter()
- xCenter = center[0]
- yCenter = center[1]
- relatedItem = treeWidgetItem.child( 0 )
- relatedItem.setText( 0 , str(xCenter) + ":" + str(yCenter) )
+ def editInGlobalTree(self, treeWidgetItem):
+ name = self.getModel().getName()
+ treeWidgetItem.setText(0, name)
+ center = self._model.getCenter()
+ xCenter = center[0]
+ yCenter = center[1]
+ relatedItem = treeWidgetItem.child(0)
+ relatedItem.setText(0, str(xCenter) + ":" + str(yCenter))
+
+ radius = self._model.getRadius()
+ relatedItem = treeWidgetItem.child(1)
+ relatedItem.setText(0, str(radius))
+ pass
- radius = self._model.getRadius()
- relatedItem = treeWidgetItem.child( 1 )
- relatedItem.setText( 0 , str(radius) )
- pass
pass
from qtsalome import *
-class GraphicsRectItem( QGraphicsRectItem ) :
- def __init__( self, x, y, w, h, index ) :
- QGraphicsRectItem.__init__( self, x, y, w, h )
- self._index = index
- self.setFlag( self.ItemIsMovable, True )
- self.setFlag( self.ItemIsSelectable, True )
- pass
+class GraphicsRectItem(QGraphicsRectItem):
+ def __init__(self, x, y, w, h, index):
+ QGraphicsRectItem.__init__(self, x, y, w, h)
+ self._index = index
+ self.setFlag(self.ItemIsMovable, True)
+ self.setFlag(self.ItemIsSelectable, True)
+ pass
+
+ def getIndex(self):
+ return self._index
- def getIndex( self ) :
- return self._index
pass
from Circle import Circle
from qtsalome import *
-class GraphicsView( QGraphicsView ) :
- moved = pyqtSignal(QPointF)
- released = pyqtSignal(QPointF)
+class GraphicsView(QGraphicsView):
- def __init__( self, scene ) :
- QGraphicsView.__init__( self, scene )
- self.setMouseTracking( True )
- self._selectedItem = None
- self.moved[QPointF].connect(self.execMouseMoveEvent)
- self.released[QPointF].connect(self.execMouseReleaseEvent)
- pass
+ moved = pyqtSignal(QPointF)
+ released = pyqtSignal(QPointF)
- def mousePressEvent( self, mouseEvent ) :
- QGraphicsView.mousePressEvent( self, mouseEvent )
- if self.scene() is None : return
- self._selectedItem = self.scene().mouseGrabberItem()
- pass
+ def __init__(self, scene):
+ QGraphicsView.__init__(self, scene)
+ self.setMouseTracking(True)
+ self._selectedItem = None
+ self.moved[QPointF].connect(self.execMouseMoveEvent)
+ self.released[QPointF].connect(self.execMouseReleaseEvent)
+ pass
- def mouseMoveEvent( self, mouseEvent ) :
- QGraphicsView.mouseMoveEvent( self, mouseEvent )
- pt = mouseEvent.pos()
- currentPos = self.mapToScene( pt )
- self.moved.emit(currentPos)
- pass
+ def mousePressEvent(self, mouseEvent):
+ QGraphicsView.mousePressEvent(self, mouseEvent)
+ if self.scene() is None:
+ return
+ self._selectedItem = self.scene().mouseGrabberItem()
+ pass
- def mouseReleaseEvent( self, mouseEvent ) :
- QGraphicsView.mouseReleaseEvent( self, mouseEvent )
- if mouseEvent.button() == Qt.LeftButton :
- pt = mouseEvent.pos()
- newPos = self.mapToScene( pt )
- self.released.emit(newPos)
- self._selectedItem = None
- pass
- pass
+ def mouseMoveEvent(self, mouseEvent):
+ QGraphicsView.mouseMoveEvent(self, mouseEvent)
+ pt = mouseEvent.pos()
+ currentPos = self.mapToScene(pt)
+ self.moved.emit(currentPos)
+ pass
- def execMouseMoveEvent( self, currentPos ) :
- if self._selectedItem is None : return
- selectedIndex = self._selectedItem.getIndex()
- newX = currentPos.x()
- newY = currentPos.y()
- newPoint = newX, newY
- model = self.scene().getModel()
- pen = QPen( QColor("red") )
- if isinstance( model, Polyline ) :
- #Previsualisation
- if selectedIndex == 0 :
- nextPoint = model.getPoints()[ selectedIndex+1 ]
- xNext = nextPoint[0]
- yNext = nextPoint[1]
- self.scene().addLine( newX, newY, xNext, yNext, pen )
- pass
- elif selectedIndex == len( model.getPoints()) - 1 :
- previousPoint = model.getPoints()[ selectedIndex-1 ]
- xPrevious = previousPoint[0]
- yPrevious = previousPoint[1]
- self.scene().addLine( xPrevious, yPrevious, newX, newY, pen )
- pass
- else :
- previousPoint = model.getPoints()[ selectedIndex-1 ]
- xPrevious = previousPoint[0]
- yPrevious = previousPoint[1]
- self.scene().addLine( xPrevious, yPrevious, newX, newY, pen )
- nextPoint = model.getPoints()[ selectedIndex+1 ]
- xNext = nextPoint[0]
- yNext = nextPoint[1]
- self.scene().addLine( newX, newY, xNext, yNext, pen )
- pass
- pass
- elif isinstance( model, Circle ) :
- #Previsualisation
- radius = float( model.getRadius() )
- rect = QRectF( newX-radius, newY-radius, 2*radius, 2*radius )
- circleItem = QGraphicsEllipseItem()
- circleItem.setPen( pen )
- circleItem.setRect( rect )
- self.scene().addItem( circleItem )
- pass
- pass
+ def mouseReleaseEvent(self, mouseEvent):
+ QGraphicsView.mouseReleaseEvent(self, mouseEvent)
+ if mouseEvent.button() == Qt.LeftButton:
+ pt = mouseEvent.pos()
+ newPos = self.mapToScene(pt)
+ self.released.emit(newPos)
+ self._selectedItem = None
+ pass
+ pass
+
+ def execMouseMoveEvent(self, currentPos):
+ if self._selectedItem is None:
+ return
+ selectedIndex = self._selectedItem.getIndex()
+ newX = currentPos.x()
+ newY = currentPos.y()
+ newPoint = newX, newY
+ model = self.scene().getModel()
+ pen = QPen(QColor("red"))
+ if isinstance(model, Polyline):
+ # Previsualisation
+ if selectedIndex == 0:
+ nextPoint = model.getPoints()[selectedIndex + 1]
+ xNext = nextPoint[0]
+ yNext = nextPoint[1]
+ self.scene().addLine(newX, newY, xNext, yNext, pen)
+ pass
+ elif selectedIndex == len(model.getPoints()) - 1:
+ previousPoint = model.getPoints()[selectedIndex - 1]
+ xPrevious = previousPoint[0]
+ yPrevious = previousPoint[1]
+ self.scene().addLine(xPrevious, yPrevious, newX, newY, pen)
+ pass
+ else:
+ previousPoint = model.getPoints()[selectedIndex - 1]
+ xPrevious = previousPoint[0]
+ yPrevious = previousPoint[1]
+ self.scene().addLine(xPrevious, yPrevious, newX, newY, pen)
+ nextPoint = model.getPoints()[selectedIndex + 1]
+ xNext = nextPoint[0]
+ yNext = nextPoint[1]
+ self.scene().addLine(newX, newY, xNext, yNext, pen)
+ pass
+ pass
+ elif isinstance(model, Circle):
+ # Previsualisation
+ radius = float(model.getRadius())
+ rect = QRectF(newX - radius, newY - radius, 2 * radius, 2 * radius)
+ circleItem = QGraphicsEllipseItem()
+ circleItem.setPen(pen)
+ circleItem.setRect(rect)
+ self.scene().addItem(circleItem)
+ pass
+ pass
+
+ def execMouseReleaseEvent(self, newPos):
+ if self._selectedItem is None:
+ return
+ selectedIndex = self._selectedItem.getIndex()
+ newX = newPos.x()
+ newY = newPos.y()
+ newPoint = newX, newY
+ model = self.scene().getModel()
+ if isinstance(model, Polyline):
+ self.scene().getController().editPoint(model, newPoint, selectedIndex)
+ pass
+ elif isinstance(model, Circle):
+ self.scene().getController().editCenter(model, newPoint)
+ pass
+ pass
- def execMouseReleaseEvent( self, newPos ) :
- if self._selectedItem is None : return
- selectedIndex = self._selectedItem.getIndex()
- newX = newPos.x()
- newY = newPos.y()
- newPoint = newX, newY
- model = self.scene().getModel()
- if isinstance( model, Polyline ) :
- self.scene().getController().editPoint( model, newPoint, selectedIndex )
- pass
- elif isinstance( model, Circle ) :
- self.scene().getController().editCenter( model, newPoint )
- pass
- pass
pass
from qtsalome import *
-class Menu( QMenu ) :
- def __init__( self, item ) :
- """Constructor"""
+class Menu(QMenu):
+ def __init__(self, item):
+ """Constructor"""
- QMenu.__init__( self )
- self._item = item
- pass
+ QMenu.__init__(self)
+ self._item = item
+ pass
+
+ def getItem(self):
+ return self._item
- def getItem( self ) :
- return self._item
pass
from qtsalome import *
from GraphicsRectItem import GraphicsRectItem
-class PolyGraphicsScene( GraphicsScene ) :
- def __init__( self, controller ) :
- GraphicsScene.__init__( self, controller )
- pass
+class PolyGraphicsScene(GraphicsScene):
+ def __init__(self, controller):
+ GraphicsScene.__init__(self, controller)
+ pass
- def draw( self ) :
- points = self.getModel().getPoints()
+ def draw(self):
+ points = self.getModel().getPoints()
- # Drawing the points as small rectangles
- for i in range( len(points) ) :
- point = points[i]
- xPoint = float( point[0] )
- yPoint = float( point[1] )
- # Constructing a rectangle centered on point
- pointItem = GraphicsRectItem( xPoint-0.1, yPoint-0.1, 0.2, 0.2, i )
- self.addItem( pointItem )
- pass
+ # Drawing the points as small rectangles
+ for i in range(len(points)):
+ point = points[i]
+ xPoint = float(point[0])
+ yPoint = float(point[1])
+ # Constructing a rectangle centered on point
+ pointItem = GraphicsRectItem(xPoint - 0.1, yPoint - 0.1, 0.2, 0.2, i)
+ self.addItem(pointItem)
+ pass
+
+ # Linking the points with lines
+ for i in range(len(points) - 1):
+ current = points[i]
+ next = points[i + 1]
+ xCurrent = float(current[0])
+ yCurrent = float(current[1])
+ xNext = float(next[0])
+ yNext = float(next[1])
+ line = QLineF(xCurrent, yCurrent, xNext, yNext)
+ lineItem = QGraphicsLineItem()
+ lineItem.setLine(line)
+ self.addItem(lineItem)
+ pass
+ pass
- # Linking the points with lines
- for i in range( len(points) - 1 ) :
- current = points[i]
- next = points[i+1]
- xCurrent = float( current[0] )
- yCurrent = float( current[1] )
- xNext = float( next[0] )
- yNext = float( next[1] )
- line = QLineF( xCurrent, yCurrent, xNext, yNext )
- lineItem = QGraphicsLineItem()
- lineItem.setLine( line )
- self.addItem( lineItem )
- pass
- pass
pass
from TreeWidgetItem import TreeWidgetItem
from qtsalome import *
-class PolyTreeWidgetItem( TreeWidgetItem ) :
- def __init__( self, name, controller, actionsList ) :
- """Constructor"""
+class PolyTreeWidgetItem(TreeWidgetItem):
+ def __init__(self, name, controller, actionsList):
+ """Constructor"""
- TreeWidgetItem.__init__( self, name, controller, actionsList )
- pass
+ TreeWidgetItem.__init__(self, name, controller, actionsList)
+ pass
- def editInGlobalTree( self, treeWidgetItem ) :
- name = self.getModel().getName()
- treeWidgetItem.setText( 0 , name )
+ def editInGlobalTree(self, treeWidgetItem):
+ name = self.getModel().getName()
+ treeWidgetItem.setText(0, name)
+
+ points = self._model.getPoints()
+ for i in range(len(points)):
+ point = points[i]
+ xPoint = point[0]
+ yPoint = point[1]
+ relatedItem = treeWidgetItem.child(i)
+ relatedItem.setText(0, str(xPoint) + ":" + str(yPoint))
+ pass
+ pass
- points = self._model.getPoints()
- for i in range( len(points) ) :
- point = points[i]
- xPoint = point[0]
- yPoint = point[1]
- relatedItem = treeWidgetItem.child( i )
- relatedItem.setText( 0 , str(xPoint) + ":" + str(yPoint) )
- pass
- pass
pass
#########################################
-class TreeWidget( QTreeWidget ) :
- def __init__( self, desktop ) :
- """Constructor"""
+class TreeWidget(QTreeWidget):
+ def __init__(self, desktop):
+ """Constructor"""
- QTreeWidget.__init__( self )
- self._desktop = desktop
+ QTreeWidget.__init__(self)
+ self._desktop = desktop
- #Creating popup menu
- self.setContextMenuPolicy( Qt.CustomContextMenu )
- self.customContextMenuRequested[QPoint].connect(self.createPopups)
- pass
+ # Creating popup menu
+ self.setContextMenuPolicy(Qt.CustomContextMenu)
+ self.customContextMenuRequested[QPoint].connect(self.createPopups)
+ pass
- def createPopups( self, point ) :
- item = self.itemAt( point )
- if item is None : return
- self.menu = Menu( item )
- for action in item.getActionsList():
- if action == "Show" :
- self.menu.addAction(action).triggered.connect(self.show)
- pass
- elif action == 'Rename' :
- self.menu.addAction(action).triggered.connect(self.showRenameDialog)
- pass
- elif action == 'Delete' :
- self.menu.addAction(action).triggered.connect(self.delete)
- pass
- else :
- self.menu.addAction(action).triggered.connect(self.showEditDialog)
- pass
- pass
- self. menu.exec_( QCursor.pos() )
- pass
+ def createPopups(self, point):
+ item = self.itemAt(point)
+ if item is None:
+ return
+ self.menu = Menu(item)
+ for action in item.getActionsList():
+ if action == "Show":
+ self.menu.addAction(action).triggered.connect(self.show)
+ pass
+ elif action == "Rename":
+ self.menu.addAction(action).triggered.connect(self.showRenameDialog)
+ pass
+ elif action == "Delete":
+ self.menu.addAction(action).triggered.connect(self.delete)
+ pass
+ else:
+ self.menu.addAction(action).triggered.connect(self.showEditDialog)
+ pass
+ pass
+ self.menu.exec_(QCursor.pos())
+ pass
- def show( self ) :
- model = self.menu.getItem().getModel()
- controller = self._desktop.getController()
- controller.showModel( model )
- pass
+ def show(self):
+ model = self.menu.getItem().getModel()
+ controller = self._desktop.getController()
+ controller.showModel(model)
+ pass
- def showRenameDialog( self ) :
- model = self.menu.getItem().getModel()
- oldName = model.getName()
- widgetDialogBox = QDockWidget( sgDesktop )
- myDialog = RenameDialog( "www.google.fr", self._desktop.getController(), widgetDialogBox, model, oldName )
- widgetDialogBox.setAllowedAreas( Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea )
- widgetDialogBox.setWidget( myDialog )
- widgetDialogBox.setWindowTitle( "Object renaming" )
- sgDesktop.addDockWidget( Qt.LeftDockWidgetArea, widgetDialogBox )
- pass
+ def showRenameDialog(self):
+ model = self.menu.getItem().getModel()
+ oldName = model.getName()
+ widgetDialogBox = QDockWidget(sgDesktop)
+ myDialog = RenameDialog(
+ "www.google.fr",
+ self._desktop.getController(),
+ widgetDialogBox,
+ model,
+ oldName,
+ )
+ widgetDialogBox.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea)
+ widgetDialogBox.setWidget(myDialog)
+ widgetDialogBox.setWindowTitle("Object renaming")
+ sgDesktop.addDockWidget(Qt.LeftDockWidgetArea, widgetDialogBox)
+ pass
- def delete( self ) :
- answer = QMessageBox.question( self, 'Confirmation', 'Do you really want to remove the selected curve ?' , QMessageBox.Yes | QMessageBox.No )
- if answer == QMessageBox.Yes :
- model = self.menu.getItem().getModel()
- controller = self._desktop.getController()
- controller.removeModel( model )
- pass
- pass
+ def delete(self):
+ answer = QMessageBox.question(
+ self,
+ "Confirmation",
+ "Do you really want to remove the selected curve ?",
+ QMessageBox.Yes | QMessageBox.No,
+ )
+ if answer == QMessageBox.Yes:
+ model = self.menu.getItem().getModel()
+ controller = self._desktop.getController()
+ controller.removeModel(model)
+ pass
+ pass
- def showEditDialog( self ) :
- item = self.menu.getItem()
- parentItem = item.parent()
- parentModel = parentItem.getModel()
- widgetDialogBox = QDockWidget( sgDesktop )
- if isinstance( parentModel, Polyline ) :
- pointRange = parentItem.indexOfChild( item )
- oldPoint = item.text( 0 )
- myDialog = EditPointDialog( "www.google.fr", self._desktop.getController(), widgetDialogBox, parentModel, oldPoint, pointRange )
- pass
- elif isinstance( parentModel, Circle ) :
- selectedRange = parentItem.indexOfChild( item )
- oldSelected = item.text( 0 )
- if selectedRange == 0 : myDialog = EditCenterDialog( "www.google.fr", self._desktop.getController(), widgetDialogBox, parentModel, oldSelected )
- elif selectedRange == 1 : myDialog = EditRadiusDialog("www.google.fr",self._desktop.getController(),widgetDialogBox,parentModel,oldSelected)
- else : pass
- pass
- else : pass
+ def showEditDialog(self):
+ item = self.menu.getItem()
+ parentItem = item.parent()
+ parentModel = parentItem.getModel()
+ widgetDialogBox = QDockWidget(sgDesktop)
+ if isinstance(parentModel, Polyline):
+ pointRange = parentItem.indexOfChild(item)
+ oldPoint = item.text(0)
+ myDialog = EditPointDialog(
+ "www.google.fr",
+ self._desktop.getController(),
+ widgetDialogBox,
+ parentModel,
+ oldPoint,
+ pointRange,
+ )
+ pass
+ elif isinstance(parentModel, Circle):
+ selectedRange = parentItem.indexOfChild(item)
+ oldSelected = item.text(0)
+ if selectedRange == 0:
+ myDialog = EditCenterDialog(
+ "www.google.fr",
+ self._desktop.getController(),
+ widgetDialogBox,
+ parentModel,
+ oldSelected,
+ )
+ elif selectedRange == 1:
+ myDialog = EditRadiusDialog(
+ "www.google.fr",
+ self._desktop.getController(),
+ widgetDialogBox,
+ parentModel,
+ oldSelected,
+ )
+ else:
+ pass
+ pass
+ else:
+ pass
+
+ widgetDialogBox.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea)
+ widgetDialogBox.setWidget(myDialog)
+ widgetDialogBox.setWindowTitle("Object edition")
+ sgDesktop.addDockWidget(Qt.LeftDockWidgetArea, widgetDialogBox)
+ pass
- widgetDialogBox.setAllowedAreas( Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea )
- widgetDialogBox.setWidget( myDialog )
- widgetDialogBox.setWindowTitle( "Object edition" )
- sgDesktop.addDockWidget( Qt.LeftDockWidgetArea, widgetDialogBox )
- pass
pass
def update_context(app, pagename, templatename, context, doctree):
- context['alabaster_version'] = version.__version__
+ context["alabaster_version"] = version.__version__
+
def setup(app):
# add_html_theme is new in Sphinx 1.6+
- if hasattr(app, 'add_html_theme'):
+ if hasattr(app, "add_html_theme"):
theme_path = os.path.abspath(os.path.dirname(__file__))
- app.add_html_theme('alabaster', theme_path)
- app.connect('html-page-context', update_context)
- return {'version': version.__version__,
- 'parallel_read_safe': True}
+ app.add_html_theme("alabaster", theme_path)
+ app.connect("html-page-context", update_context)
+ return {"version": version.__version__, "parallel_read_safe": True}
__version_info__ = (0, 7, 10)
-__version__ = '.'.join(map(str, __version_info__))
+__version__ = ".".join(map(str, __version_info__))
# flake8: noqa
from pygments.style import Style
-from pygments.token import Keyword, Name, Comment, String, Error, \
- Number, Operator, Generic, Whitespace, Punctuation, Other, Literal
+from pygments.token import (
+ Keyword,
+ Name,
+ Comment,
+ String,
+ Error,
+ Number,
+ Operator,
+ Generic,
+ Whitespace,
+ Punctuation,
+ Other,
+ Literal,
+)
# Originally based on FlaskyStyle which was based on 'tango'.
class Alabaster(Style):
- background_color = "#f8f8f8" # doesn't seem to override CSS 'pre' styling?
+ background_color = "#f8f8f8" # doesn't seem to override CSS 'pre' styling?
default_style = ""
styles = {
# No corresponding class for the following:
- #Text: "", # class: ''
- Whitespace: "underline #f8f8f8", # class: 'w'
- Error: "#a40000 border:#ef2929", # class: 'err'
- Other: "#000000", # class 'x'
-
- Comment: "italic #8f5902", # class: 'c'
- Comment.Preproc: "noitalic", # class: 'cp'
-
- Keyword: "bold #004461", # class: 'k'
- Keyword.Constant: "bold #004461", # class: 'kc'
- Keyword.Declaration: "bold #004461", # class: 'kd'
- Keyword.Namespace: "bold #004461", # class: 'kn'
- Keyword.Pseudo: "bold #004461", # class: 'kp'
- Keyword.Reserved: "bold #004461", # class: 'kr'
- Keyword.Type: "bold #004461", # class: 'kt'
-
- Operator: "#582800", # class: 'o'
- Operator.Word: "bold #004461", # class: 'ow' - like keywords
-
- Punctuation: "bold #000000", # class: 'p'
-
+ # Text: "", # class: ''
+ Whitespace: "underline #f8f8f8", # class: 'w'
+ Error: "#a40000 border:#ef2929", # class: 'err'
+ Other: "#000000", # class 'x'
+ Comment: "italic #8f5902", # class: 'c'
+ Comment.Preproc: "noitalic", # class: 'cp'
+ Keyword: "bold #004461", # class: 'k'
+ Keyword.Constant: "bold #004461", # class: 'kc'
+ Keyword.Declaration: "bold #004461", # class: 'kd'
+ Keyword.Namespace: "bold #004461", # class: 'kn'
+ Keyword.Pseudo: "bold #004461", # class: 'kp'
+ Keyword.Reserved: "bold #004461", # class: 'kr'
+ Keyword.Type: "bold #004461", # class: 'kt'
+ Operator: "#582800", # class: 'o'
+ Operator.Word: "bold #004461", # class: 'ow' - like keywords
+ Punctuation: "bold #000000", # class: 'p'
# because special names such as Name.Class, Name.Function, etc.
# are not recognized as such later in the parsing, we choose them
# to look the same as ordinary variables.
- Name: "#000000", # class: 'n'
- Name.Attribute: "#c4a000", # class: 'na' - to be revised
- Name.Builtin: "#004461", # class: 'nb'
- Name.Builtin.Pseudo: "#3465a4", # class: 'bp'
- Name.Class: "#000000", # class: 'nc' - to be revised
- Name.Constant: "#000000", # class: 'no' - to be revised
- Name.Decorator: "#888", # class: 'nd' - to be revised
- Name.Entity: "#ce5c00", # class: 'ni'
- Name.Exception: "bold #cc0000", # class: 'ne'
- Name.Function: "#000000", # class: 'nf'
- Name.Property: "#000000", # class: 'py'
- Name.Label: "#f57900", # class: 'nl'
- Name.Namespace: "#000000", # class: 'nn' - to be revised
- Name.Other: "#000000", # class: 'nx'
- Name.Tag: "bold #004461", # class: 'nt' - like a keyword
- Name.Variable: "#000000", # class: 'nv' - to be revised
- Name.Variable.Class: "#000000", # class: 'vc' - to be revised
- Name.Variable.Global: "#000000", # class: 'vg' - to be revised
- Name.Variable.Instance: "#000000", # class: 'vi' - to be revised
-
- Number: "#990000", # class: 'm'
-
- Literal: "#000000", # class: 'l'
- Literal.Date: "#000000", # class: 'ld'
-
- String: "#4e9a06", # class: 's'
- String.Backtick: "#4e9a06", # class: 'sb'
- String.Char: "#4e9a06", # class: 'sc'
- String.Doc: "italic #8f5902", # class: 'sd' - like a comment
- String.Double: "#4e9a06", # class: 's2'
- String.Escape: "#4e9a06", # class: 'se'
- String.Heredoc: "#4e9a06", # class: 'sh'
- String.Interpol: "#4e9a06", # class: 'si'
- String.Other: "#4e9a06", # class: 'sx'
- String.Regex: "#4e9a06", # class: 'sr'
- String.Single: "#4e9a06", # class: 's1'
- String.Symbol: "#4e9a06", # class: 'ss'
-
- Generic: "#000000", # class: 'g'
- Generic.Deleted: "#a40000", # class: 'gd'
- Generic.Emph: "italic #000000", # class: 'ge'
- Generic.Error: "#ef2929", # class: 'gr'
- Generic.Heading: "bold #000080", # class: 'gh'
- Generic.Inserted: "#00A000", # class: 'gi'
- Generic.Output: "#888", # class: 'go'
- Generic.Prompt: "#745334", # class: 'gp'
- Generic.Strong: "bold #000000", # class: 'gs'
- Generic.Subheading: "bold #800080", # class: 'gu'
- Generic.Traceback: "bold #a40000", # class: 'gt'
+ Name: "#000000", # class: 'n'
+ Name.Attribute: "#c4a000", # class: 'na' - to be revised
+ Name.Builtin: "#004461", # class: 'nb'
+ Name.Builtin.Pseudo: "#3465a4", # class: 'bp'
+ Name.Class: "#000000", # class: 'nc' - to be revised
+ Name.Constant: "#000000", # class: 'no' - to be revised
+ Name.Decorator: "#888", # class: 'nd' - to be revised
+ Name.Entity: "#ce5c00", # class: 'ni'
+ Name.Exception: "bold #cc0000", # class: 'ne'
+ Name.Function: "#000000", # class: 'nf'
+ Name.Property: "#000000", # class: 'py'
+ Name.Label: "#f57900", # class: 'nl'
+ Name.Namespace: "#000000", # class: 'nn' - to be revised
+ Name.Other: "#000000", # class: 'nx'
+ Name.Tag: "bold #004461", # class: 'nt' - like a keyword
+ Name.Variable: "#000000", # class: 'nv' - to be revised
+ Name.Variable.Class: "#000000", # class: 'vc' - to be revised
+ Name.Variable.Global: "#000000", # class: 'vg' - to be revised
+ Name.Variable.Instance: "#000000", # class: 'vi' - to be revised
+ Number: "#990000", # class: 'm'
+ Literal: "#000000", # class: 'l'
+ Literal.Date: "#000000", # class: 'ld'
+ String: "#4e9a06", # class: 's'
+ String.Backtick: "#4e9a06", # class: 'sb'
+ String.Char: "#4e9a06", # class: 'sc'
+ String.Doc: "italic #8f5902", # class: 'sd' - like a comment
+ String.Double: "#4e9a06", # class: 's2'
+ String.Escape: "#4e9a06", # class: 'se'
+ String.Heredoc: "#4e9a06", # class: 'sh'
+ String.Interpol: "#4e9a06", # class: 'si'
+ String.Other: "#4e9a06", # class: 'sx'
+ String.Regex: "#4e9a06", # class: 'sr'
+ String.Single: "#4e9a06", # class: 's1'
+ String.Symbol: "#4e9a06", # class: 'ss'
+ Generic: "#000000", # class: 'g'
+ Generic.Deleted: "#a40000", # class: 'gd'
+ Generic.Emph: "italic #000000", # class: 'ge'
+ Generic.Error: "#ef2929", # class: 'gr'
+ Generic.Heading: "bold #000080", # class: 'gh'
+ Generic.Inserted: "#00A000", # class: 'gi'
+ Generic.Output: "#888", # class: 'go'
+ Generic.Prompt: "#745334", # class: 'gp'
+ Generic.Strong: "bold #000000", # class: 'gs'
+ Generic.Subheading: "bold #800080", # class: 'gu'
+ Generic.Traceback: "bold #a40000", # class: 'gt'
}
extensions = []
-templates_path = ['_templates']
-source_suffix = '.rst'
-master_doc = 'index'
+templates_path = ["_templates"]
+source_suffix = ".rst"
+master_doc = "index"
-project = u'Alabaster'
+project = u"Alabaster"
year = datetime.now().year
-copyright = u'%d Jeff Forcier' % year
+copyright = u"%d Jeff Forcier" % year
-exclude_patterns = ['_build']
+exclude_patterns = ["_build"]
-html_theme = 'alabaster'
+html_theme = "alabaster"
html_sidebars = {
- '**': [
- 'about.html',
- 'navigation.html',
- 'relations.html',
- 'searchbox.html',
- 'donate.html',
+ "**": [
+ "about.html",
+ "navigation.html",
+ "relations.html",
+ "searchbox.html",
+ "donate.html",
]
}
html_theme_options = {
- 'description': "A light, configurable Sphinx theme",
- 'github_user': 'bitprophet',
- 'github_repo': 'alabaster',
- 'fixed_sidebar': True,
+ "description": "A light, configurable Sphinx theme",
+ "github_user": "bitprophet",
+ "github_repo": "alabaster",
+ "fixed_sidebar": True,
}
-extensions.append('releases')
-releases_github_path = 'bitprophet/alabaster'
+extensions.append("releases")
+releases_github_path = "bitprophet/alabaster"
# Our pre-0.x releases are unstable / mix bugs+features
releases_unstable_prehistory = True
# Version info -- read without importing
_locals = {}
-with open('alabaster/_version.py') as fp:
+with open("alabaster/_version.py") as fp:
exec(fp.read(), None, _locals)
-version = _locals['__version__']
+version = _locals["__version__"]
# README into long description
-with codecs.open('README.rst', encoding='utf-8') as f:
+with codecs.open("README.rst", encoding="utf-8") as f:
readme = f.read()
setup(
- name='alabaster',
+ name="alabaster",
version=version,
- description='A configurable sidebar-enabled Sphinx theme',
+ description="A configurable sidebar-enabled Sphinx theme",
long_description=readme,
- author='Jeff Forcier',
- author_email='jeff@bitprophet.org',
- url='https://alabaster.readthedocs.io',
- packages=['alabaster'],
+ author="Jeff Forcier",
+ author_email="jeff@bitprophet.org",
+ url="https://alabaster.readthedocs.io",
+ packages=["alabaster"],
include_package_data=True,
entry_points={
- 'sphinx.html_themes': [
- 'alabaster = alabaster',
+ "sphinx.html_themes": [
+ "alabaster = alabaster",
]
},
classifiers=[
- 'Development Status :: 5 - Production/Stable',
- 'Intended Audience :: Developers',
- 'License :: OSI Approved :: BSD License',
- 'Operating System :: OS Independent',
- 'Programming Language :: Python',
- 'Programming Language :: Python :: 2',
- 'Programming Language :: Python :: 2.6',
- 'Programming Language :: Python :: 2.7',
- 'Programming Language :: Python :: 3',
- 'Programming Language :: Python :: 3.2',
- 'Programming Language :: Python :: 3.3',
- 'Programming Language :: Python :: 3.4',
- 'Programming Language :: Python :: 3.5',
- 'Programming Language :: Python :: 3.6',
- 'Programming Language :: Python :: Implementation :: CPython',
- 'Programming Language :: Python :: Implementation :: PyPy',
- 'Topic :: Documentation',
- 'Topic :: Software Development :: Documentation',
+ "Development Status :: 5 - Production/Stable",
+ "Intended Audience :: Developers",
+ "License :: OSI Approved :: BSD License",
+ "Operating System :: OS Independent",
+ "Programming Language :: Python",
+ "Programming Language :: Python :: 2",
+ "Programming Language :: Python :: 2.6",
+ "Programming Language :: Python :: 2.7",
+ "Programming Language :: Python :: 3",
+ "Programming Language :: Python :: 3.2",
+ "Programming Language :: Python :: 3.3",
+ "Programming Language :: Python :: 3.4",
+ "Programming Language :: Python :: 3.5",
+ "Programming Language :: Python :: 3.6",
+ "Programming Language :: Python :: Implementation :: CPython",
+ "Programming Language :: Python :: Implementation :: PyPy",
+ "Topic :: Documentation",
+ "Topic :: Software Development :: Documentation",
],
)
ns = Collection(release, docs)
-ns.configure({
- 'packaging': {
- 'sign': True,
- 'wheel': True,
- 'changelog_file': 'docs/changelog.rst',
+ns.configure(
+ {
+ "packaging": {
+ "sign": True,
+ "wheel": True,
+ "changelog_file": "docs/changelog.rst",
+ }
}
-})
+)
# https://stackoverflow.com/questions/23462494/how-to-add-a-custom-css-file-to-sphinx
-# this needs realpath(custom), cause problem on relocated git clone,
+# this needs realpath(custom), cause problem on relocated git clone,
# so use file link instead in _themes/alabaster: ln -s ../../../../src/custom.css custom.css
# def setup(app):
# custom = os.path.join('src', 'custom.css')
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
-#sys.path.insert(0, os.path.abspath('.'))
+# sys.path.insert(0, os.path.abspath('.'))
# -- General configuration -----------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
-#needs_sphinx = '1.0'
+# needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be extensions
# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
-extensions = ['sphinx.ext.intersphinx', 'sphinx.ext.todo', 'sphinx.ext.mathjax', 'sphinx.ext.viewcode']
+extensions = [
+ "sphinx.ext.intersphinx",
+ "sphinx.ext.todo",
+ "sphinx.ext.mathjax",
+ "sphinx.ext.viewcode",
+]
# do not use rst_prolog please use doc/rst_prolog.rst and '.. include:: ../rst_prolog.rst'
# https://github.com/sphinx-doc/sphinx/issues/2445
# Add any paths that contain templates here, relative to this directory.
-templates_path = ['_templates']
+templates_path = ["_templates"]
# The suffix of source filenames.
-source_suffix = '.rst'
+source_suffix = ".rst"
# The encoding of source files.
-#source_encoding = 'utf-8-sig'
+# source_encoding = 'utf-8-sig'
# The master toctree document.
-master_doc = 'index'
+master_doc = "index"
# General information about the project.
-project = u'sat'
-copyright = u'2019, CEA'
+project = u"sat"
+copyright = u"2019, CEA"
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
-version = '5.8'
+version = "5.8"
# The full version, including alpha/beta/rc tags.
-release = '5.8.0'
+release = "5.8.0"
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
-#language = None
+# language = None
# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
-#today = ''
+# today = ''
# Else, today_fmt is used as the format for a strftime call.
-#today_fmt = '%B %d, %Y'
+# today_fmt = '%B %d, %Y'
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
exclude_patterns = []
# The reST default role (used for this markup: `text`) to use for all documents.
-#default_role = None
+# default_role = None
# If true, '()' will be appended to :func: etc. cross-reference text.
-#add_function_parentheses = True
+# add_function_parentheses = True
# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
-#add_module_names = True
+# add_module_names = True
# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
-#show_authors = False
+# show_authors = False
# The name of the Pygments (syntax highlighting) style to use.
-pygments_style = 'sphinx'
+pygments_style = "sphinx"
# A list of ignored prefixes for module index sorting.
-#modindex_common_prefix = []
+# modindex_common_prefix = []
# -- Options for HTML output ---------------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
# default sphinxdoc scrolls agogo traditional nature haiku
-html_theme = 'alabaster' #added in _theme dir
+html_theme = "alabaster" # added in _theme dir
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
#'sidebar_includehidden': True,
#'sidebar_collapse': True,
#'show_powered_by': False,
- 'show_related': True,
- 'fixed_sidebar': False,
- 'page_width': '1000px',
- 'sidebar_width': '250px',
- 'font_size': '0.9em', #'1.0625em',
- 'code_font_size': '0.8em',
+ "show_related": True,
+ "fixed_sidebar": False,
+ "page_width": "1000px",
+ "sidebar_width": "250px",
+ "font_size": "0.9em", #'1.0625em',
+ "code_font_size": "0.8em",
#'note_bg': '#eee',
- 'pre_bg': '#fee', # code-block background
+ "pre_bg": "#fee", # code-block background
#'gray_1': '#00f',
#'gray_2': '#f00',
#'gray_3': '#0f0',
}
# Add any paths that contain custom themes here, relative to this directory.
-html_theme_path = ["../_themes/alabaster", ]
+html_theme_path = [
+ "../_themes/alabaster",
+]
# The name for this set of Sphinx documents. If None, it defaults to
# "<project> v<release> documentation".
-#html_title = None
+# html_title = None
# A shorter title for the navigation bar. Default is the same as html_title.
-#html_short_title = None
+# html_short_title = None
# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
-#html_static_path = ['_static']
+# html_static_path = ['_static']
# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
# using the given strftime format.
-#html_last_updated_fmt = '%b %d, %Y'
+# html_last_updated_fmt = '%b %d, %Y'
# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
html_use_smartypants = False
# Custom sidebar templates, maps document names to template names.
-#html_sidebars = {}
+# html_sidebars = {}
# Additional templates that should be rendered to pages, maps page names to
# template names.
-#html_additional_pages = {}
+# html_additional_pages = {}
# If false, no module index is generated.
-#html_domain_indices = True
+# html_domain_indices = True
# If false, no index is generated.
-#html_use_index = True
+# html_use_index = True
# If true, the index is split into individual pages for each letter.
-#html_split_index = False
+# html_split_index = False
# If true, links to the reST sources are added to the pages.
-#html_show_sourcelink = True
+# html_show_sourcelink = True
# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
-#html_show_sphinx = True
+# html_show_sphinx = True
# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
-#html_show_copyright = True
+# html_show_copyright = True
# If true, an OpenSearch description file will be output, and all pages will
# contain a <link> tag referring to it. The value of this option must be the
# base URL from which the finished HTML is served.
-#html_use_opensearch = ''
+# html_use_opensearch = ''
# This is the file name suffix for HTML files (e.g. ".xhtml").
-#html_file_suffix = None
+# html_file_suffix = None
# Output file base name for HTML help builder.
-htmlhelp_basename = 'satdoc'
+htmlhelp_basename = "satdoc"
# -- Options for LaTeX output --------------------------------------------------
latex_elements = {
- # The paper size ('letterpaper' or 'a4paper').
- 'papersize': 'a4paper',
-
- # The font size ('10pt', '11pt' or '12pt').
- 'pointsize': '10pt',
-
- # Additional stuff for the LaTeX preamble.
- #'preamble': '',
-
- # http://www.sphinx-doc.org/en/master/latex.html
- 'sphinxsetup': 'verbatimwithframe=false, VerbatimColor={rgb}{.98,.94,.94}',
+ # The paper size ('letterpaper' or 'a4paper').
+ "papersize": "a4paper",
+ # The font size ('10pt', '11pt' or '12pt').
+ "pointsize": "10pt",
+ # Additional stuff for the LaTeX preamble.
+ #'preamble': '',
+ # http://www.sphinx-doc.org/en/master/latex.html
+ "sphinxsetup": "verbatimwithframe=false, VerbatimColor={rgb}{.98,.94,.94}",
}
# The paper size ('letter' or 'a4').
-#latex_paper_size = 'a4'
+# latex_paper_size = 'a4'
# The font size ('10pt', '11pt' or '12pt').
-#latex_font_size = '10pt'
+# latex_font_size = '10pt'
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title, author, documentclass [howto/manual]).
latex_documents = [
- ('index', 'sat.tex', u'SAT Documentation',
- u'CEA DES/ISAS/DM2S/STMF/LGLS', 'manual'),
+ (
+ "index",
+ "sat.tex",
+ u"SAT Documentation",
+ u"CEA DES/ISAS/DM2S/STMF/LGLS",
+ "manual",
+ ),
]
# The name of an image file (relative to this directory) to place at the top of
# the title page.
-#latex_logo = None
+# latex_logo = None
# For "manual" documents, if this is true, then toplevel headings are parts,
# not chapters.
-#latex_use_parts = False
+# latex_use_parts = False
# If true, show page references after internal links.
latex_show_pagerefs = True
# If true, show URL addresses after external links.
-latex_show_urls = 'footnote' # sphinx version 1.7 # True
+latex_show_urls = "footnote" # sphinx version 1.7 # True
# Additional stuff for the LaTeX preamble.
-#latex_preamble = ''
+# latex_preamble = ''
# Documents to append as an appendix to all manuals.
-#latex_appendices = []
+# latex_appendices = []
# If false, no module index is generated.
-#latex_domain_indices = True
+# latex_domain_indices = True
# -- Options for manual page output --------------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
- ('index', 'sat', u'SAT Documentation',
- [u'CEA DES/ISAS/DM2S/STMF/LGLS'], 1)
+ ("index", "sat", u"SAT Documentation", [u"CEA DES/ISAS/DM2S/STMF/LGLS"], 1)
]
-
-
"[/.*:\[\]\(\)@=])|"
"((?:\{[^}]+\})?[^/\[\]\(\)@=\s]+)|"
"\s+"
- )
+)
+
def xpath_tokenizer(pattern, namespaces=None):
for token in xpath_tokenizer_re.findall(pattern):
else:
yield token
+
def get_parent_map(context):
parent_map = context.parent_map
if parent_map is None:
parent_map[e] = p
return parent_map
+
def prepare_child(next, token):
tag = token[1]
+
def select(context, result):
for elem in result:
for e in elem:
if e.tag == tag:
yield e
+
return select
+
def prepare_star(next, token):
def select(context, result):
for elem in result:
yield from elem
+
return select
+
def prepare_self(next, token):
def select(context, result):
yield from result
+
return select
+
def prepare_descendant(next, token):
token = next()
if token[0] == "*":
tag = token[1]
else:
raise SyntaxError("invalid descendant")
+
def select(context, result):
for elem in result:
for e in elem.iter(tag):
if e is not elem:
yield e
+
return select
+
def prepare_parent(next, token):
def select(context, result):
# FIXME: raise error if .. is applied at toplevel?
if parent not in result_map:
result_map[parent] = None
yield parent
+
return select
+
def prepare_predicate(next, token):
# FIXME: replace with real parser!!! refs:
# http://effbot.org/zone/simple-iterator-parser.htm
if signature == "@-":
# [@attribute] predicate
key = predicate[1]
+
def select(context, result):
for elem in result:
if elem.get(key) is not None:
yield elem
+
return select
if signature == "@-='":
# [@attribute='value']
key = predicate[1]
value = predicate[-1]
+
def select(context, result):
for elem in result:
if elem.get(key) == value:
yield elem
+
return select
if signature == "-" and not re.match("\-?\d+$", predicate[0]):
# [tag]
tag = predicate[0]
+
def select(context, result):
for elem in result:
if elem.find(tag) is not None:
yield elem
+
return select
if signature == "-='" and not re.match("\-?\d+$", predicate[0]):
# [tag='value']
tag = predicate[0]
value = predicate[-1]
+
def select(context, result):
for elem in result:
for e in elem.findall(tag):
if "".join(e.itertext()) == value:
yield elem
break
+
return select
if signature == "-" or signature == "-()" or signature == "-()-":
# [index] or [last()] or [last()-index]
raise SyntaxError("XPath offset from last() must be negative")
else:
index = -1
+
def select(context, result):
parent_map = get_parent_map(context)
for elem in result:
yield elem
except (IndexError, KeyError):
pass
+
return select
raise SyntaxError("invalid predicate")
+
ops = {
"": prepare_child,
"*": prepare_star,
"..": prepare_parent,
"//": prepare_descendant,
"[": prepare_predicate,
- }
+}
_cache = {}
+
class _SelectorContext:
parent_map = None
+
def __init__(self, root):
self.root = root
+
# --------------------------------------------------------------------
##
# Generate all matching objects.
+
def iterfind(elem, path, namespaces=None):
# compile selector pattern
- cache_key = (path, None if namespaces is None
- else tuple(sorted(namespaces.items())))
+ cache_key = (
+ path,
+ None if namespaces is None else tuple(sorted(namespaces.items())),
+ )
if path[-1:] == "/":
- path = path + "*" # implicit all (FIXME: keep this?)
+ path = path + "*" # implicit all (FIXME: keep this?)
try:
selector = _cache[cache_key]
except KeyError:
result = select(context, result)
return result
+
##
# Find first matching object.
+
def find(elem, path, namespaces=None):
try:
return next(iterfind(elem, path, namespaces))
except StopIteration:
return None
+
##
# Find all matching objects.
+
def findall(elem, path, namespaces=None):
return list(iterfind(elem, path, namespaces))
+
##
# Find text for first matching object.
+
def findtext(elem, path, default=None, namespaces=None):
try:
elem = next(iterfind(elem, path, namespaces))
return elem.text or ""
except StopIteration:
- return default
\ No newline at end of file
+ return default
-
-
"""
using VERSION 1.3.0 native xml.etree.ElementTree for python3
appending method tostring serialize 'pretty_xml'
_versionPython = sys.version_info[0]
if _versionPython < 3:
- # python2 previous historic mode
- import src.ElementTreePython2 as etree
- DBG.write("ElementTree Python2 %s" % etree.VERSION, etree.__file__, DBG.isDeveloper())
- tostring = etree.tostring
+ # python2 previous historic mode
+ import src.ElementTreePython2 as etree
+
+ DBG.write(
+ "ElementTree Python2 %s" % etree.VERSION, etree.__file__, DBG.isDeveloper()
+ )
+ tostring = etree.tostring
else:
- # python3 mode
- # import xml.etree.ElementTree as etree # native version
- import src.ElementTreePython3 as etree # VERSION 1.3.0 plus _serialize 'pretty_xml'
- DBG.write("ElementTree Python3 %s" % etree.VERSION, etree.__file__, DBG.isDeveloper())
-
- def tostring(node, encoding='utf-8'):
- """
- fix output as str with encoding='unicode' because python3
- If encoding is "unicode", a string is returned.
- Otherwise a bytestring is returned
- """
- try:
- aStr = etree.tostring(node, encoding='unicode', method="pretty_xml")
- except:
- print("*****************************\n problem node", node)
- # try no pretty
- aStr = etree.tostring(node, encoding='unicode')
- # if be byte
- # aStr = aStr.decode('utf-8')
- return aStr
+ # python3 mode
+ # import xml.etree.ElementTree as etree # native version
+ import src.ElementTreePython3 as etree # VERSION 1.3.0 plus _serialize 'pretty_xml'
+
+ DBG.write(
+ "ElementTree Python3 %s" % etree.VERSION, etree.__file__, DBG.isDeveloper()
+ )
+
+ def tostring(node, encoding="utf-8"):
+ """
+ fix output as str with encoding='unicode' because python3
+ If encoding is "unicode", a string is returned.
+ Otherwise a bytestring is returned
+ """
+ try:
+ aStr = etree.tostring(node, encoding="unicode", method="pretty_xml")
+ except:
+ print("*****************************\n problem node", node)
+ # try no pretty
+ aStr = etree.tostring(node, encoding="unicode")
+ # if be byte
+ # aStr = aStr.decode('utf-8')
+ return aStr
+
# common use
Element = etree.Element
parse = etree.parse
-
# public symbols
"Comment",
"dump",
- "Element", "ElementTree",
+ "Element",
+ "ElementTree",
"fromstring",
- "iselement", "iterparse",
+ "iselement",
+ "iterparse",
"parse",
- "PI", "ProcessingInstruction",
+ "PI",
+ "ProcessingInstruction",
"QName",
"SubElement",
"tostring",
"TreeBuilder",
- "VERSION", "XML",
+ "VERSION",
+ "XML",
"XMLTreeBuilder",
- ]
+]
##
# The <b>Element</b> type is a flexible container object, designed to
import string, sys, re, platform
+
class _SimpleElementPath:
# emulate pre-1.2 find/findtext/findall behaviour
def find(self, element, tag):
if elem.tag == tag:
return elem
return None
+
def findtext(self, element, tag, default=None):
for elem in element:
if elem.tag == tag:
return elem.text or ""
return default
+
def findall(self, element, tag):
if tag[:3] == ".//":
return element.getiterator(tag[3:])
result.append(elem)
return result
+
"""
# obsolete
# ElementPath.py is for python3 2019
# FIXME: issue warning in this case?
ElementPath = _SimpleElementPath()
"""
-ElementPath = _SimpleElementPath() # before 2019 python2 situation sat5.0
+ElementPath = _SimpleElementPath() # before 2019 python2 situation sat5.0
# TODO: add support for custom namespace resolvers/default namespaces
# TODO: add improved support for incremental parsing
# @see Comment
# @see ProcessingInstruction
+
class _ElementInterface:
# <tag attrib>text<child/>...</tag>tail
# next sibling element's start tag. This is either a string or
# the value None, if there was no text.
- tail = None # text after end tag, if any
+ tail = None # text after end tag, if any
def __init__(self, tag, attrib):
self.tag = tag
else:
res.append(key)
return res
-
+
##
# Gets element attributes, as a sequence. The attributes are
# returned in an arbitrary order.
nodes.extend(node.getiterator(tag))
return nodes
+
# compatibility
_Element = _ElementInterface
# @return An element instance.
# @defreturn Element
+
def Element(tag, attrib={}, **extra):
attrib = attrib.copy()
attrib.update(extra)
return _ElementInterface(tag, attrib)
+
##
# Subelement factory. This function creates an element instance, and
# appends it to an existing element.
# @return An element instance.
# @defreturn Element
+
def SubElement(parent, tag, attrib={}, **extra):
attrib = attrib.copy()
attrib.update(extra)
parent.append(element)
return element
+
##
# Comment element factory. This factory function creates a special
# element that will be serialized as an XML comment.
# @return An element instance, representing a comment.
# @defreturn Element
+
def Comment(text=None):
element = Element(Comment)
element.text = text
return element
+
##
# PI element factory. This factory function creates a special element
# that will be serialized as an XML processing instruction.
# @return An element instance, representing a PI.
# @defreturn Element
+
def ProcessingInstruction(target, text=None):
element = Element(ProcessingInstruction)
element.text = target
element.text = element.text + " " + text
return element
+
PI = ProcessingInstruction
##
# an URI, and this argument is interpreted as a local name.
# @return An opaque object, representing the QName.
+
class QName:
def __init__(self, text_or_uri, tag=None):
if tag:
text_or_uri = "{%s}%s" % (text_or_uri, tag)
self.text = text_or_uri
+
def __str__(self):
return self.text
+
def __hash__(self):
return hash(self.text)
+
def __cmp__(self, other):
if isinstance(other, QName):
return cmp(self.text, other.text)
return cmp(self.text, other)
+
##
# ElementTree wrapper class. This class represents an entire element
# hierarchy, and adds some extra support for serialization to and from
# @keyparam file Optional file handle or name. If given, the
# tree is initialized with the contents of this XML file.
-class ElementTree:
+class ElementTree:
def __init__(self, element=None, file=None):
assert element is None or iselement(element)
- self._root = element # first node
+ self._root = element # first node
if file:
self.parse(file)
file.write("<?%s?>\n" % _escape_cdata(node.text, encoding))
else:
items = node.items()
- xmlns_items = [] # new namespaces in this scope
+ xmlns_items = [] # new namespaces in this scope
try:
if isinstance(tag, QName) or tag[:1] == "{":
tag, xmlns = fixtag(tag, namespaces)
- if xmlns: xmlns_items.append(xmlns)
+ if xmlns:
+ xmlns_items.append(xmlns)
except TypeError:
_raise_serialization_error(tag)
- file.write(' ' * margin)
+ file.write(" " * margin)
file.write(_encode("<", encoding) + _encode(tag, encoding))
if items or xmlns_items:
try:
- items = sorted(items) # lexical order
+ items = sorted(items) # lexical order
except:
print("*** problem sorting items", items)
for k, v in items:
try:
if isinstance(k, QName) or k[:1] == "{":
k, xmlns = fixtag(k, namespaces)
- if xmlns: xmlns_items.append(xmlns)
+ if xmlns:
+ xmlns_items.append(xmlns)
except TypeError:
_raise_serialization_error(k)
try:
if isinstance(v, QName):
v, xmlns = fixtag(v, namespaces)
- if xmlns: xmlns_items.append(xmlns)
+ if xmlns:
+ xmlns_items.append(xmlns)
except TypeError:
_raise_serialization_error(v)
- file.write(" %s=\"%s\"" % (k,v))
+ file.write(' %s="%s"' % (k, v))
for k, v in xmlns_items:
- file.write(" %s=\"%s\"" % (k,v))
+ file.write(' %s="%s"' % (k, v))
if node.text or len(node):
file.write(">")
if node.text:
file.write(_escape_cdata(node.text, encoding))
- if len(node) > 0: file.write("\n")
+ if len(node) > 0:
+ file.write("\n")
for n in node:
self._write(file, n, encoding, namespaces, margin + 2)
- if len(node) > 0: file.write(' ' * margin)
- file.write(_encode("</", encoding) + _encode(tag, encoding) + _encode(">\n", encoding))
+ if len(node) > 0:
+ file.write(" " * margin)
+ file.write(
+ _encode("</", encoding)
+ + _encode(tag, encoding)
+ + _encode(">\n", encoding)
+ )
else:
file.write("/>\n")
for k, v in xmlns_items:
if node.tail:
file.write(_escape_cdata(node.tail, encoding))
+
# --------------------------------------------------------------------
# helpers
# @return A true value if this is an element object.
# @defreturn flag
+
def iselement(element):
# FIXME: not sure about this; might be a better idea to look
# for tag/attrib/text attributes
return isinstance(element, _ElementInterface) or hasattr(element, "tag")
+
##
# Writes an element tree or element structure to sys.stdout. This
# function should be used for debugging only.
#
# @param elem An element tree or an individual element.
+
def dump(elem):
# debugging
if not isinstance(elem, ElementTree):
if not tail or tail[-1] != "\n":
sys.stdout.write("\n")
+
def _encode(s, encoding):
try:
return s.encode(encoding)
except AttributeError:
- return s # 1.5.2: assume the string uses the right encoding
+ return s # 1.5.2: assume the string uses the right encoding
+
if sys.version[:3] == "1.5":
- _escape = re.compile(r"[&<>\"\x80-\xff]+") # 1.5.2
+ _escape = re.compile(r"[&<>\"\x80-\xff]+") # 1.5.2
else:
_escape = re.compile(eval(r'u"[&<>\"\u0080-\uffff]+"'))
"http://schemas.xmlsoap.org/wsdl/": "wsdl",
}
+
def _raise_serialization_error(text):
- raise TypeError(
- "cannot serialize %r (type %s)" % (text, type(text).__name__)
- )
+ raise TypeError("cannot serialize %r (type %s)" % (text, type(text).__name__))
+
def _encode_entity(text, pattern=_escape):
# map reserved and non-ascii characters to numerical entities
text = "&#%d;" % ord(char)
append(text)
return string.join(out, "")
+
try:
return _encode(pattern.sub(escape_entities, text), "ascii")
except TypeError:
_raise_serialization_error(text)
+
#
# the following functions assume an ascii-compatible encoding
# (or "utf-16")
+
def _escape_cdata(text, encoding=None, replace=str.replace):
# escape character data
try:
- if platform.python_version()[0] == '2': # python 2.x.y
+ if platform.python_version()[0] == "2": # python 2.x.y
if encoding:
try:
text = _encode(text, encoding)
except UnicodeError:
return _encode_entity(text)
-
+
text = replace(text, "&", "&")
text = replace(text, "<", "<")
text = replace(text, ">", ">")
except (TypeError, AttributeError):
_raise_serialization_error(text)
+
def _escape_attrib(text, encoding=None, replace=str.replace):
# escape attribute value
try:
text = replace(text, "&", "&")
- text = replace(text, "'", "'") # FIXME: overkill
- text = replace(text, "\"", """)
+ text = replace(text, "'", "'") # FIXME: overkill
+ text = replace(text, '"', """)
text = replace(text, "<", "<")
text = replace(text, ">", ">")
if encoding:
except (TypeError, AttributeError):
_raise_serialization_error(text)
+
def fixtag(tag, namespaces):
# given a decorated tag (of the form {uri}tag), return prefixed
# tag and namespace declaration, if any
xmlns = None
return "%s:%s" % (prefix, tag), xmlns
+
##
# Parses an XML document into an element tree.
#
# standard {@link XMLTreeBuilder} parser is used.
# @return An ElementTree instance
+
def parse(source, parser=None):
tree = ElementTree()
tree.parse(source, parser)
return tree
+
##
# Parses an XML document into an element tree incrementally, and reports
# what's going on to the user.
# events are reported.
# @return A (event, elem) iterator.
-class iterparse:
+class iterparse:
def __init__(self, source, events=None):
if not hasattr(source, "read"):
# OP TEST
try:
parser.ordered_attributes = 1
parser.specified_attributes = 1
- def handler(tag, attrib_in, event=event, append=append,
- start=self._parser._start_list):
+
+ def handler(
+ tag,
+ attrib_in,
+ event=event,
+ append=append,
+ start=self._parser._start_list,
+ ):
append((event, start(tag, attrib_in)))
+
parser.StartElementHandler = handler
except AttributeError:
- def handler(tag, attrib_in, event=event, append=append,
- start=self._parser._start):
+
+ def handler(
+ tag,
+ attrib_in,
+ event=event,
+ append=append,
+ start=self._parser._start,
+ ):
append((event, start(tag, attrib_in)))
+
parser.StartElementHandler = handler
elif event == "end":
- def handler(tag, event=event, append=append,
- end=self._parser._end):
+
+ def handler(tag, event=event, append=append, end=self._parser._end):
append((event, end(tag)))
+
parser.EndElementHandler = handler
elif event == "start-ns":
+
def handler(prefix, uri, event=event, append=append):
try:
uri = _encode(uri, "ascii")
except UnicodeError:
pass
append((event, (prefix or "", uri)))
+
parser.StartNamespaceDeclHandler = handler
elif event == "end-ns":
+
def handler(prefix, event=event, append=append):
append((event, None))
+
parser.EndNamespaceDeclHandler = handler
def next(self):
try:
iter
+
def __iter__(self):
return self
+
except NameError:
+
def __getitem__(self, index):
return self.next()
+
##
# Parses an XML document from a string constant. This function can
# be used to embed "XML literals" in Python code.
# @return An Element instance.
# @defreturn Element
+
def XML(text):
parser = XMLTreeBuilder()
parser.feed(text)
return parser.close()
+
##
# Parses an XML document from a string constant, and also returns
# a dictionary which maps from element id:s to elements.
# @return A tuple containing an Element instance and a dictionary.
# @defreturn (Element, dictionary)
+
def XMLID(text):
parser = XMLTreeBuilder()
parser.feed(text)
ids[id] = elem
return tree, ids
+
##
# Parses an XML document from a string constant. Same as {@link #XML}.
#
# @return An encoded string containing the XML data.
# @defreturn string
+
def tostring(element, encoding=None):
class dummy:
pass
+
data = []
file = dummy()
file.write = data.append
data2.append(item)
return "".join(data2)
+
##
# Generic element structure builder. This builder converts a sequence
# of {@link #TreeBuilder.start}, {@link #TreeBuilder.data}, and {@link
# @param element_factory Optional element factory. This factory
# is called to create new Element instances, as necessary.
-class TreeBuilder:
+class TreeBuilder:
def __init__(self, element_factory=None):
- self._data = [] # data collector
- self._elem = [] # element stack
- self._last = None # last element
- self._tail = None # true if we're after an end tag
+ self._data = [] # data collector
+ self._elem = [] # element stack
+ self._last = None # last element
+ self._tail = None # true if we're after an end tag
if element_factory is None:
element_factory = _ElementInterface
self._factory = element_factory
def end(self, tag):
self._flush()
self._last = self._elem.pop()
- assert self._last.tag == tag,\
- "end tag mismatch (expected %s, got %s)" % (
- self._last.tag, tag)
+ assert self._last.tag == tag, "end tag mismatch (expected %s, got %s)" % (
+ self._last.tag,
+ tag,
+ )
self._tail = 1
return self._last
+
##
# Element structure builder for XML source data, based on the
# <b>expat</b> parser.
# @see #ElementTree
# @see #TreeBuilder
-class XMLTreeBuilder:
+class XMLTreeBuilder:
def __init__(self, html=0, target=None):
try:
from xml.parsers import expat
except ImportError:
- raise ImportError(
- "No module named expat; use SimpleXMLTreeBuilder instead"
- )
+ raise ImportError("No module named expat; use SimpleXMLTreeBuilder instead")
self._parser = parser = expat.ParserCreate(None, "}")
if target is None:
target = TreeBuilder()
self._target = target
- self._names = {} # name memo cache
+ self._names = {} # name memo cache
# callbacks
parser.DefaultHandlerExpand = self._default
parser.StartElementHandler = self._start
parser.StartElementHandler = self._start_list
except AttributeError:
pass
- #encoding = None
- #if not parser.returns_unicode:
+ # encoding = None
+ # if not parser.returns_unicode:
# encoding = "utf-8"
# target.xml(encoding, None)
self._doctype = None
attrib = {}
if attrib_in:
for i in range(0, len(attrib_in), 2):
- attrib[fixname(attrib_in[i])] = self._fixtext(attrib_in[i+1])
+ attrib[fixname(attrib_in[i])] = self._fixtext(attrib_in[i + 1])
return self._target.start(tag, attrib)
def _data(self, text):
self._target.data(self.entity[text[1:-1]])
except KeyError:
from xml.parsers import expat
+
raise expat.error(
- "undefined entity %s: line %d, column %d" %
- (text, self._parser.ErrorLineNumber,
- self._parser.ErrorColumnNumber)
+ "undefined entity %s: line %d, column %d"
+ % (
+ text,
+ self._parser.ErrorLineNumber,
+ self._parser.ErrorColumnNumber,
)
+ )
elif prefix == "<" and text[:9] == "<!DOCTYPE":
- self._doctype = [] # inside a doctype declaration
+ self._doctype = [] # inside a doctype declaration
elif self._doctype is not None:
# parse doctype contents
if prefix == ">":
try:
self._parser.Parse(data, 0)
except:
- print("*** problem feed:\n%s" % data.decode('utf-8'))
+ print("*** problem feed:\n%s" % data.decode("utf-8"))
##
# Finishes feeding data to the parser.
# @defreturn Element
def close(self):
- self._parser.Parse("", 1) # end of data
+ self._parser.Parse("", 1) # end of data
tree = self._target.close()
- del self._target, self._parser # get rid of circular references
+ del self._target, self._parser # get rid of circular references
return tree
"""
-#---------------------------------------------------------------------
+# ---------------------------------------------------------------------
# Licensed to PSF under a Contributor Agreement.
# See http://www.python.org/psf/license for licensing details.
#
# public symbols
"Comment",
"dump",
- "Element", "ElementTree",
- "fromstring", "fromstringlist",
- "iselement", "iterparse",
- "parse", "ParseError",
- "PI", "ProcessingInstruction",
+ "Element",
+ "ElementTree",
+ "fromstring",
+ "fromstringlist",
+ "iselement",
+ "iterparse",
+ "parse",
+ "ParseError",
+ "PI",
+ "ProcessingInstruction",
"QName",
"SubElement",
- "tostring", "tostringlist",
+ "tostring",
+ "tostringlist",
"TreeBuilder",
"VERSION",
- "XML", "XMLID",
+ "XML",
+ "XMLID",
"XMLParser",
"register_namespace",
- ]
+]
VERSION = "1.3.0"
'position' - the line and column of the error
"""
+
pass
+
# --------------------------------------------------------------------
def iselement(element):
"""Return True if *element* appears to be an Element."""
- return hasattr(element, 'tag')
+ return hasattr(element, "tag")
class Element:
def __init__(self, tag, attrib={}, **extra):
if not isinstance(attrib, dict):
- raise TypeError("attrib must be dict, not %s" % (
- attrib.__class__.__name__,))
+ raise TypeError(
+ "attrib must be dict, not %s" % (attrib.__class__.__name__,)
+ )
attrib = attrib.copy()
attrib.update(extra)
self.tag = tag
warnings.warn(
"The behavior of this method will change in future versions. "
"Use specific 'len(elem)' or 'elem is not None' test instead.",
- FutureWarning, stacklevel=2
- )
- return len(self._children) != 0 # emulate old behaviour, for now
+ FutureWarning,
+ stacklevel=2,
+ )
+ return len(self._children) != 0 # emulate old behaviour, for now
def __getitem__(self, index):
return self._children[index]
# Need to refer to the actual Python implementation, not the
# shadowing C implementation.
if not isinstance(e, _Element_Py):
- raise TypeError('expected an Element, not %s' % type(e).__name__)
+ raise TypeError("expected an Element, not %s" % type(e).__name__)
def remove(self, subelement):
"""Remove matching subelement.
warnings.warn(
"This method will be removed in future versions. "
"Use 'list(elem)' or iteration over elem instead.",
- DeprecationWarning, stacklevel=2
- )
+ DeprecationWarning,
+ stacklevel=2,
+ )
return self._children
def find(self, path, namespaces=None):
warnings.warn(
"This method will be removed in future versions. "
"Use 'elem.iter()' or 'list(elem.iter())' instead.",
- PendingDeprecationWarning, stacklevel=2
+ PendingDeprecationWarning,
+ stacklevel=2,
)
return list(self.iter(tag))
element.text = element.text + " " + text
return element
+
PI = ProcessingInstruction
be interpreted as a local name.
"""
+
def __init__(self, text_or_uri, tag=None):
if tag:
text_or_uri = "{%s}%s" % (text_or_uri, tag)
self.text = text_or_uri
+
def __str__(self):
return self.text
+
def __repr__(self):
- return '<QName %r>' % (self.text,)
+ return "<QName %r>" % (self.text,)
+
def __hash__(self):
return hash(self.text)
+
def __le__(self, other):
if isinstance(other, QName):
return self.text <= other.text
return self.text <= other
+
def __lt__(self, other):
if isinstance(other, QName):
return self.text < other.text
return self.text < other
+
def __ge__(self, other):
if isinstance(other, QName):
return self.text >= other.text
return self.text >= other
+
def __gt__(self, other):
if isinstance(other, QName):
return self.text > other.text
return self.text > other
+
def __eq__(self, other):
if isinstance(other, QName):
return self.text == other.text
return self.text == other
+
def __ne__(self, other):
if isinstance(other, QName):
return self.text != other.text
return self.text != other
+
# --------------------------------------------------------------------
contents will be used to initialize the tree with.
"""
+
def __init__(self, element=None, file=None):
# assert element is None or iselement(element)
- self._root = element # first node
+ self._root = element # first node
if file:
self.parse(file)
if parser is None:
# If no parser was specified, create a default XMLParser
parser = XMLParser()
- if hasattr(parser, '_parse_whole'):
+ if hasattr(parser, "_parse_whole"):
# The default XMLParser, when it comes from an accelerator,
# can define an internal _parse_whole API for efficiency.
# It can be used to parse the whole source without feeding
warnings.warn(
"This method will be removed in future versions. "
"Use 'tree.iter()' or 'list(tree.iter())' instead.",
- PendingDeprecationWarning, stacklevel=2
+ PendingDeprecationWarning,
+ stacklevel=2,
)
return list(self.iter(tag))
"This search is broken in 1.3 and earlier, and will be "
"fixed in a future version. If you rely on the current "
"behaviour, change it to %r" % path,
- FutureWarning, stacklevel=2
- )
+ FutureWarning,
+ stacklevel=2,
+ )
return self._root.find(path, namespaces)
def findtext(self, path, default=None, namespaces=None):
"This search is broken in 1.3 and earlier, and will be "
"fixed in a future version. If you rely on the current "
"behaviour, change it to %r" % path,
- FutureWarning, stacklevel=2
- )
+ FutureWarning,
+ stacklevel=2,
+ )
return self._root.findtext(path, default, namespaces)
def findall(self, path, namespaces=None):
"This search is broken in 1.3 and earlier, and will be "
"fixed in a future version. If you rely on the current "
"behaviour, change it to %r" % path,
- FutureWarning, stacklevel=2
- )
+ FutureWarning,
+ stacklevel=2,
+ )
return self._root.findall(path, namespaces)
def iterfind(self, path, namespaces=None):
"This search is broken in 1.3 and earlier, and will be "
"fixed in a future version. If you rely on the current "
"behaviour, change it to %r" % path,
- FutureWarning, stacklevel=2
- )
+ FutureWarning,
+ stacklevel=2,
+ )
return self._root.iterfind(path, namespaces)
- def write(self, file_or_filename,
- encoding=None,
- xml_declaration=None,
- default_namespace=None,
- method=None, *,
- short_empty_elements=True):
+ def write(
+ self,
+ file_or_filename,
+ encoding=None,
+ xml_declaration=None,
+ default_namespace=None,
+ method=None,
+ *,
+ short_empty_elements=True
+ ):
"""Write element tree to a file as XML.
Arguments:
encoding = "us-ascii"
enc_lower = encoding.lower()
with _get_writer(file_or_filename, enc_lower) as write:
- if method == "xml" and (xml_declaration or
- (xml_declaration is None and
- enc_lower not in ("utf-8", "us-ascii", "unicode"))):
+ if method == "xml" and (
+ xml_declaration
+ or (
+ xml_declaration is None
+ and enc_lower not in ("utf-8", "us-ascii", "unicode")
+ )
+ ):
declared_encoding = encoding
if enc_lower == "unicode":
# Retrieve the default encoding for the xml declaration
import locale
+
declared_encoding = locale.getpreferredencoding()
- write("<?xml version='1.0' encoding='%s'?>\n" % (
- declared_encoding,))
+ write("<?xml version='1.0' encoding='%s'?>\n" % (declared_encoding,))
if method == "text":
_serialize_text(write, self._root)
else:
qnames, namespaces = _namespaces(self._root, default_namespace)
serialize = _serialize[method]
- serialize(write, self._root, qnames, namespaces,
- short_empty_elements=short_empty_elements)
+ serialize(
+ write,
+ self._root,
+ qnames,
+ namespaces,
+ short_empty_elements=short_empty_elements,
+ )
def write_c14n(self, file):
# lxml.etree compatibility. use output method instead
return self.write(file, method="c14n")
+
# --------------------------------------------------------------------
# serialization support
+
@contextlib.contextmanager
def _get_writer(file_or_filename, encoding):
# returns text write method and release all resources after using
if encoding == "unicode":
file = open(file_or_filename, "w")
else:
- file = open(file_or_filename, "w", encoding=encoding,
- errors="xmlcharrefreplace")
+ file = open(
+ file_or_filename, "w", encoding=encoding, errors="xmlcharrefreplace"
+ )
with file:
yield file.write
else:
file.tell = file_or_filename.tell
except AttributeError:
pass
- file = io.TextIOWrapper(file,
- encoding=encoding,
- errors="xmlcharrefreplace",
- newline="\n")
+ file = io.TextIOWrapper(
+ file, encoding=encoding, errors="xmlcharrefreplace", newline="\n"
+ )
# Keep the original file open when the TextIOWrapper is
# destroyed
stack.callback(file.detach)
yield file.write
+
def _namespaces(elem, default_namespace=None):
# identify namespaces used in this tree
if prefix:
qnames[qname] = "%s:%s" % (prefix, tag)
else:
- qnames[qname] = tag # default element
+ qnames[qname] = tag # default element
else:
if default_namespace:
# FIXME: can this be handled in XML 1.0?
raise ValueError(
"cannot use non-qualified names with "
"default_namespace option"
- )
+ )
qnames[qname] = qname
except TypeError:
_raise_serialization_error(qname)
add_qname(text.text)
return qnames, namespaces
-def _serialize_xml(write, elem, qnames, namespaces,
- short_empty_elements, **kwargs):
+
+def _serialize_xml(write, elem, qnames, namespaces, short_empty_elements, **kwargs):
tag = elem.tag
text = elem.text
if tag is Comment:
if text:
write(_escape_cdata(text))
for e in elem:
- _serialize_xml(write, e, qnames, None,
- short_empty_elements=short_empty_elements)
+ _serialize_xml(
+ write, e, qnames, None, short_empty_elements=short_empty_elements
+ )
else:
write("<" + tag)
items = list(elem.items())
if items or namespaces:
if namespaces:
- for v, k in sorted(namespaces.items(),
- key=lambda x: x[1]): # sort on prefix
+ for v, k in sorted(
+ namespaces.items(), key=lambda x: x[1]
+ ): # sort on prefix
if k:
k = ":" + k
- write(" xmlns%s=\"%s\"" % (
- k,
- _escape_attrib(v)
- ))
+ write(' xmlns%s="%s"' % (k, _escape_attrib(v)))
for k, v in sorted(items): # lexical order
if isinstance(k, QName):
k = k.text
v = qnames[v.text]
else:
v = _escape_attrib(v)
- write(" %s=\"%s\"" % (qnames[k], v))
+ write(' %s="%s"' % (qnames[k], v))
if text or len(elem) or not short_empty_elements:
write(">")
if text:
write(_escape_cdata(text))
for e in elem:
- _serialize_xml(write, e, qnames, None,
- short_empty_elements=short_empty_elements)
+ _serialize_xml(
+ write,
+ e,
+ qnames,
+ None,
+ short_empty_elements=short_empty_elements,
+ )
write("</" + tag + ">")
else:
write(" />")
if elem.tail:
write(_escape_cdata(elem.tail))
+
# add from cvw jan 2019
-def _serialize_pretty_xml(write, elem, qnames, namespaces,
- short_empty_elements, indent=0):
+def _serialize_pretty_xml(
+ write, elem, qnames, namespaces, short_empty_elements, indent=0
+):
# print("*****pretty***** indent", elem.tag, indent)
tag = elem.tag
text = elem.text
if tag is Comment:
- write("<!--%s-->" % text)
+ write("<!--%s-->" % text)
elif tag is ProcessingInstruction:
- write("<?%s?>" % text)
+ write("<?%s?>" % text)
else:
- tag = qnames[tag]
- if tag is None:
- if text:
- write(_escape_cdata(text))
- for e in elem:
- _serialize_pretty_xml(write, e, qnames, None,
- short_empty_elements=short_empty_elements, indent=indent)
- else:
- write(" "*indent + "<" + tag)
- items = list(elem.items())
- if items or namespaces:
- if namespaces:
- for v, k in sorted(namespaces.items(),
- key=lambda x: x[1]): # sort on prefix
- if k:
- k = ":" + k
- write(" xmlns%s=\"%s\"" % (
- k,
- _escape_attrib(v)
- ))
- for k, v in sorted(items): # lexical order
- # print("atrrib ", k, v)
- if isinstance(k, QName):
- k = k.text
- if isinstance(v, QName):
- v = qnames[v.text]
- else:
- v = _escape_attrib(v)
- write(" %s=\"%s\"" % (qnames[k], v))
- if text or len(elem) or not short_empty_elements:
- if text:
- write(">")
- write(_escape_cdata(text))
- else:
- write(">\n")
-
- for e in elem:
- _serialize_pretty_xml(write, e, qnames, None,
- short_empty_elements=short_empty_elements, indent=indent+2)
- write(" "*indent + "</" + tag + ">\n")
+ tag = qnames[tag]
+ if tag is None:
+ if text:
+ write(_escape_cdata(text))
+ for e in elem:
+ _serialize_pretty_xml(
+ write,
+ e,
+ qnames,
+ None,
+ short_empty_elements=short_empty_elements,
+ indent=indent,
+ )
else:
- write(" />\n")
+ write(" " * indent + "<" + tag)
+ items = list(elem.items())
+ if items or namespaces:
+ if namespaces:
+ for v, k in sorted(
+ namespaces.items(), key=lambda x: x[1]
+ ): # sort on prefix
+ if k:
+ k = ":" + k
+ write(' xmlns%s="%s"' % (k, _escape_attrib(v)))
+ for k, v in sorted(items): # lexical order
+ # print("atrrib ", k, v)
+ if isinstance(k, QName):
+ k = k.text
+ if isinstance(v, QName):
+ v = qnames[v.text]
+ else:
+ v = _escape_attrib(v)
+ write(' %s="%s"' % (qnames[k], v))
+ if text or len(elem) or not short_empty_elements:
+ if text:
+ write(">")
+ write(_escape_cdata(text))
+ else:
+ write(">\n")
+
+ for e in elem:
+ _serialize_pretty_xml(
+ write,
+ e,
+ qnames,
+ None,
+ short_empty_elements=short_empty_elements,
+ indent=indent + 2,
+ )
+ write(" " * indent + "</" + tag + ">\n")
+ else:
+ write(" />\n")
if elem.tail:
- write(_escape_cdata(elem.tail))
+ write(_escape_cdata(elem.tail))
-HTML_EMPTY = ("area", "base", "basefont", "br", "col", "frame", "hr",
- "img", "input", "isindex", "link", "meta", "param")
+HTML_EMPTY = (
+ "area",
+ "base",
+ "basefont",
+ "br",
+ "col",
+ "frame",
+ "hr",
+ "img",
+ "input",
+ "isindex",
+ "link",
+ "meta",
+ "param",
+)
try:
HTML_EMPTY = set(HTML_EMPTY)
except NameError:
pass
+
def _serialize_html(write, elem, qnames, namespaces, **kwargs):
tag = elem.tag
text = elem.text
items = list(elem.items())
if items or namespaces:
if namespaces:
- for v, k in sorted(namespaces.items(),
- key=lambda x: x[1]): # sort on prefix
+ for v, k in sorted(
+ namespaces.items(), key=lambda x: x[1]
+ ): # sort on prefix
if k:
k = ":" + k
- write(" xmlns%s=\"%s\"" % (
- k,
- _escape_attrib(v)
- ))
+ write(' xmlns%s="%s"' % (k, _escape_attrib(v)))
for k, v in sorted(items): # lexical order
if isinstance(k, QName):
k = k.text
else:
v = _escape_attrib_html(v)
# FIXME: handle boolean attributes
- write(" %s=\"%s\"" % (qnames[k], v))
+ write(' %s="%s"' % (qnames[k], v))
write(">")
ltag = tag.lower()
if text:
if elem.tail:
write(_escape_cdata(elem.tail))
+
def _serialize_text(write, elem):
for part in elem.itertext():
write(part)
if elem.tail:
write(elem.tail)
+
_serialize = {
"xml": _serialize_xml,
"pretty_xml": _serialize_pretty_xml,
"html": _serialize_html,
"text": _serialize_text,
-# this optional method is imported at the end of the module
-# "c14n": _serialize_c14n,
+ # this optional method is imported at the end of the module
+ # "c14n": _serialize_c14n,
}
del _namespace_map[k]
_namespace_map[uri] = prefix
+
_namespace_map = {
# "well-known" namespace prefixes
"http://www.w3.org/XML/1998/namespace": "xml",
# For tests and troubleshooting
register_namespace._namespace_map = _namespace_map
+
def _raise_serialization_error(text):
- raise TypeError(
- "cannot serialize %r (type %s)" % (text, type(text).__name__)
- )
+ raise TypeError("cannot serialize %r (type %s)" % (text, type(text).__name__))
+
def _escape_cdata(text):
# escape character data
except (TypeError, AttributeError):
_raise_serialization_error(text)
+
def _escape_attrib(text):
# escape attribute value
try:
text = text.replace("<", "<")
if ">" in text:
text = text.replace(">", ">")
- if "\"" in text:
- text = text.replace("\"", """)
+ if '"' in text:
+ text = text.replace('"', """)
if "\n" in text:
text = text.replace("\n", " ")
return text
except (TypeError, AttributeError):
_raise_serialization_error(text)
+
def _escape_attrib_html(text):
# escape attribute value
try:
text = text.replace("&", "&")
if ">" in text:
text = text.replace(">", ">")
- if "\"" in text:
- text = text.replace("\"", """)
+ if '"' in text:
+ text = text.replace('"', """)
return text
except (TypeError, AttributeError):
_raise_serialization_error(text)
+
# --------------------------------------------------------------------
-def tostring(element, encoding=None, method=None, *,
- short_empty_elements=True):
+
+def tostring(element, encoding=None, method=None, *, short_empty_elements=True):
"""Generate string representation of XML element.
All subelements are included. If encoding is "unicode", a string
Returns an (optionally) encoded string containing the XML data.
"""
- stream = io.StringIO() if encoding == 'unicode' else io.BytesIO()
- ElementTree(element).write(stream, encoding, method=method,
- short_empty_elements=short_empty_elements)
+ stream = io.StringIO() if encoding == "unicode" else io.BytesIO()
+ ElementTree(element).write(
+ stream, encoding, method=method, short_empty_elements=short_empty_elements
+ )
return stream.getvalue()
+
class _ListDataStream(io.BufferedIOBase):
"""An auxiliary stream accumulating into a list reference."""
+
def __init__(self, lst):
self.lst = lst
def tell(self):
return len(self.lst)
-def tostringlist(element, encoding=None, method=None, *,
- short_empty_elements=True):
+
+def tostringlist(element, encoding=None, method=None, *, short_empty_elements=True):
lst = []
stream = _ListDataStream(lst)
- ElementTree(element).write(stream, encoding, method=method,
- short_empty_elements=short_empty_elements)
+ ElementTree(element).write(
+ stream, encoding, method=method, short_empty_elements=short_empty_elements
+ )
return lst
if not tail or tail[-1] != "\n":
sys.stdout.write("\n")
+
# --------------------------------------------------------------------
# parsing
class XMLPullParser:
-
def __init__(self, events=None, *, _parser=None):
# The _parser argument is for internal use only and must not be relied
# upon in user code. It will be removed in a future release.
class _IterParseIterator:
-
def __init__(self, source, events, parser, close_source=False):
# Use the internal, undocumented _parser argument for now; When the
# parser argument of iterparse is removed, this can be killed.
ids[id] = elem
return tree, ids
+
# Parse XML document from string constant. Alias for XML().
fromstring = XML
+
def fromstringlist(sequence, parser=None):
"""Parse XML document from sequence of string fragments.
parser.feed(text)
return parser.close()
+
# --------------------------------------------------------------------
to create new Element instances, as necessary.
"""
+
def __init__(self, element_factory=None):
- self._data = [] # data collector
- self._elem = [] # element stack
- self._last = None # last element
- self._tail = None # true if we're after an end tag
+ self._data = [] # data collector
+ self._elem = [] # element stack
+ self._last = None # last element
+ self._tail = None # true if we're after an end tag
if element_factory is None:
element_factory = Element
self._factory = element_factory
"""
self._flush()
self._last = self._elem.pop()
- assert self._last.tag == tag,\
- "end tag mismatch (expected %s, got %s)" % (
- self._last.tag, tag)
+ assert self._last.tag == tag, "end tag mismatch (expected %s, got %s)" % (
+ self._last.tag,
+ tag,
+ )
self._tail = 1
return self._last
except ImportError:
raise ImportError(
"No module named expat; use SimpleXMLTreeBuilder instead"
- )
+ )
parser = expat.ParserCreate(encoding, "}")
if target is None:
target = TreeBuilder()
self.parser = self._parser = parser
self.target = self._target = target
self._error = expat.error
- self._names = {} # name memo cache
+ self._names = {} # name memo cache
# main callbacks
parser.DefaultHandlerExpand = self._default
- if hasattr(target, 'start'):
+ if hasattr(target, "start"):
parser.StartElementHandler = self._start
- if hasattr(target, 'end'):
+ if hasattr(target, "end"):
parser.EndElementHandler = self._end
- if hasattr(target, 'data'):
+ if hasattr(target, "data"):
parser.CharacterDataHandler = target.data
# miscellaneous callbacks
- if hasattr(target, 'comment'):
+ if hasattr(target, "comment"):
parser.CommentHandler = target.comment
- if hasattr(target, 'pi'):
+ if hasattr(target, "pi"):
parser.ProcessingInstructionHandler = target.pi
# Configure pyexpat: buffering, new-style attribute handling.
parser.buffer_text = 1
try:
self.version = "Expat %d.%d.%d" % expat.version_info
except AttributeError:
- pass # unknown
+ pass # unknown
def _setevents(self, events_queue, events_to_report):
# Internal API for XMLPullParser
if event_name == "start":
parser.ordered_attributes = 1
parser.specified_attributes = 1
- def handler(tag, attrib_in, event=event_name, append=append,
- start=self._start):
+
+ def handler(
+ tag, attrib_in, event=event_name, append=append, start=self._start
+ ):
append((event, start(tag, attrib_in)))
+
parser.StartElementHandler = handler
elif event_name == "end":
- def handler(tag, event=event_name, append=append,
- end=self._end):
+
+ def handler(tag, event=event_name, append=append, end=self._end):
append((event, end(tag)))
+
parser.EndElementHandler = handler
elif event_name == "start-ns":
+
def handler(prefix, uri, event=event_name, append=append):
append((event, (prefix or "", uri or "")))
+
parser.StartNamespaceDeclHandler = handler
elif event_name == "end-ns":
+
def handler(prefix, event=event_name, append=append):
append((event, None))
+
parser.EndNamespaceDeclHandler = handler
else:
raise ValueError("unknown event %r" % event_name)
attrib = {}
if attr_list:
for i in range(0, len(attr_list), 2):
- attrib[fixname(attr_list[i])] = attr_list[i+1]
+ attrib[fixname(attr_list[i])] = attr_list[i + 1]
return self.target.start(tag, attrib)
def _end(self, tag):
data_handler(self.entity[text[1:-1]])
except KeyError:
from xml.parsers import expat
+
err = expat.error(
- "undefined entity %s: line %d, column %d" %
- (text, self.parser.ErrorLineNumber,
- self.parser.ErrorColumnNumber)
- )
- err.code = 11 # XML_ERROR_UNDEFINED_ENTITY
+ "undefined entity %s: line %d, column %d"
+ % (text, self.parser.ErrorLineNumber, self.parser.ErrorColumnNumber)
+ )
+ err.code = 11 # XML_ERROR_UNDEFINED_ENTITY
err.lineno = self.parser.ErrorLineNumber
err.offset = self.parser.ErrorColumnNumber
raise err
elif prefix == "<" and text[:9] == "<!DOCTYPE":
- self._doctype = [] # inside a doctype declaration
+ self._doctype = [] # inside a doctype declaration
elif self._doctype is not None:
# parse doctype contents
if prefix == ">":
"This method of XMLParser is deprecated. Define doctype() "
"method on the TreeBuilder target.",
DeprecationWarning,
- )
+ )
# sentinel, if doctype is redefined in a subclass
__doctype = doctype
def close(self):
"""Finish feeding data to parser and return element structure."""
try:
- self.parser.Parse("", 1) # end of data
+ self.parser.Parse("", 1) # end of data
except self._error as v:
self._raiseerror(v)
try:
# Element, SubElement, ParseError, TreeBuilder, XMLParser
from _elementtree import *
except ImportError:
- pass
\ No newline at end of file
+ pass
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2013 CEA/DEN
#
# This library is free software; you can redistribute it and/or
from . import template
import platform
-if platform.system() == "Windows" :
+
+if platform.system() == "Windows":
import colorama
+
colorama.init()
OK_STATUS = "OK"
KNOWNFAILURE_STATUS = "KF"
TIMEOUT_STATUS = "TIMEOUT"
+
class SatException(Exception):
"""sat exception class"""
+
def message(self, arg):
if sys.version_info[0] >= 3:
# message method is not available for python 3.8+
return super().msg(arg)
else:
- return super(SatException,self).message(arg)
+ return super(SatException, self).message(arg)
+
def ensure_path_exists(p):
"""Create a path if not existing
if not os.path.exists(p):
os.makedirs(p)
-def check_config_has_application( config, details = None ):
+
+def check_config_has_application(config, details=None):
"""check that the config has the key APPLICATION. Else raise an exception.
:param config class 'common.pyconf.Config': The config.
"""
- if 'APPLICATION' not in config:
- message = _("An APPLICATION is required. Use 'config --list' to get the list of available applications.\n")
- if details :
+ if "APPLICATION" not in config:
+ message = _(
+ "An APPLICATION is required. Use 'config --list' to get the list of available applications.\n"
+ )
+ if details:
details.append(message)
- raise SatException( message )
+ raise SatException(message)
+
-def check_platform_is_supported( config, logger ):
+def check_platform_is_supported(config, logger):
"""check that the platform is supported, write warning if not.
:param config class 'common.pyconf.Config': The config.
"""
- if 'platform' in config.APPLICATION and config.VARS.dist not in config.APPLICATION.platform:
- msg = "WARNING: Your application configuration is not supported on this platform (%s)\n"\
- " Please consider using the native application!" % config.VARS.dist
+ if (
+ "platform" in config.APPLICATION
+ and config.VARS.dist not in config.APPLICATION.platform
+ ):
+ msg = (
+ "WARNING: Your application configuration is not supported on this platform (%s)\n"
+ " Please consider using the native application!" % config.VARS.dist
+ )
logger.write("\n%s\n\n" % printcolors.printcWarning(msg), 1)
return
-def check_config_has_profile( config, details = None ):
+
+def check_config_has_profile(config, details=None):
"""\
check that the config has the key APPLICATION.profile.
else, raise an exception.
:param config class 'common.pyconf.Config': The config.
"""
check_config_has_application(config)
- if 'profile' not in config.APPLICATION:
+ if "profile" not in config.APPLICATION:
message = _("A profile section is required in your application.\n")
- if details :
+ if details:
details.append(message)
- raise SatException( message )
+ raise SatException(message)
-def appli_test_property(config,property_name, property_value):
+
+def appli_test_property(config, property_name, property_value):
"""Generic function to test if an application has a property set to a value
:param config class 'common.pyconf.Config': The config.
:param property_name : The name of the property to check
:rtype: boolean
"""
# first check if application has property_value
- if not ("APPLICATION" in config and
- "properties" in config.APPLICATION and
- property_name in config.APPLICATION.properties):
+ if not (
+ "APPLICATION" in config
+ and "properties" in config.APPLICATION
+ and property_name in config.APPLICATION.properties
+ ):
return False
# then check to the property is set to property_value
- eval_expression = 'config.APPLICATION.properties.%s == "%s"' %\
- (property_name,property_value)
+ eval_expression = 'config.APPLICATION.properties.%s == "%s"' % (
+ property_name,
+ property_value,
+ )
result = eval(eval_expression)
return result
-def config_has_application( config ):
- return 'APPLICATION' in config
+def config_has_application(config):
+ return "APPLICATION" in config
+
def get_cfg_param(config, param_name, default):
"""\
return config[param_name]
return default
+
def strSplitN(aList, nb, skip="\n "):
"""
example
strValue = ""
i = 0
for v in aList:
- strValue += "%15s, " % str(v)
- i += 1
- if i >= nb:
- strValue += skip
- i = 0
+ strValue += "%15s, " % str(v)
+ i += 1
+ if i >= nb:
+ strValue += skip
+ i = 0
if len(aList) > nb:
strValue = skip + strValue
return strValue
+
def getProductNames(cfg, wildcards, logger):
"""get products names using * or ? as wildcards like shell Linux"""
res = []
if type(wildcards) is list:
- wilds = wildcards
+ wilds = wildcards
else:
- wilds = [wildcards]
+ wilds = [wildcards]
notFound = {}
products = cfg.APPLICATION.products.keys()
for wild in wildcards:
- ok = False
- for prod in products:
- filtered = fnmatch.filter([prod], wild)
- # print("filtered", prod, wild, filtered)
- if len(filtered) > 0:
- res.append(prod)
- ok = True
- continue
- if not ok:
- notFound[wild] = None
+ ok = False
+ for prod in products:
+ filtered = fnmatch.filter([prod], wild)
+ # print("filtered", prod, wild, filtered)
+ if len(filtered) > 0:
+ res.append(prod)
+ ok = True
+ continue
+ if not ok:
+ notFound[wild] = None
if len(res) == 0:
- logger.warning("Empty list of products, from %s" % wilds)
+ logger.warning("Empty list of products, from %s" % wilds)
if len(notFound.keys()) > 0:
- strProd = strSplitN( sorted(products), 5)
- logger.warning("products not found: %s\n availables products are:\n%s" % \
- (sorted(notFound.keys()), strProd) )
+ strProd = strSplitN(sorted(products), 5)
+ logger.warning(
+ "products not found: %s\n availables products are:\n%s"
+ % (sorted(notFound.keys()), strProd)
+ )
return res
printcolors.print_value(logger, sp + i[0], i[1], 2)
logger.write("\n", 2)
+
def get_base_path(config):
"""\
Returns the path of the products base.
:rtype: str
"""
if "base" not in config.LOCAL:
- local_file_path = os.path.join(config.VARS.salometoolsway,
- "data",
- "local.pyconf")
+ local_file_path = os.path.join(
+ config.VARS.salometoolsway, "data", "local.pyconf"
+ )
msg = _("Please define a base path in the file %s" % local_file_path)
raise SatException(msg)
return base_path
+
def get_launcher_name(config):
"""\
Returns the name of salome launcher.
:rtype: str
"""
check_config_has_application(config)
- if 'profile' in config.APPLICATION and 'launcher_name' in config.APPLICATION.profile:
+ if (
+ "profile" in config.APPLICATION
+ and "launcher_name" in config.APPLICATION.profile
+ ):
launcher_name = config.APPLICATION.profile.launcher_name
else:
- launcher_name = 'salome'
+ launcher_name = "salome"
return launcher_name
+
def get_launcher_exe(config):
"""\
Returns the name of exe defined in profile section.
:rtype: str
"""
check_config_has_application(config)
- if 'profile' in config.APPLICATION and 'exe' in config.APPLICATION.profile:
+ if "profile" in config.APPLICATION and "exe" in config.APPLICATION.profile:
exe_name = config.APPLICATION.profile.exe
else:
exe_name = None
:rtype: str
"""
if "log_dir" not in config.LOCAL:
- local_file_path = os.path.join(config.VARS.salometoolsway,
- "data",
- "local.pyconf")
+ local_file_path = os.path.join(
+ config.VARS.salometoolsway, "data", "local.pyconf"
+ )
msg = _("Please define a log_dir in the file %s" % local_file_path)
raise SatException(msg)
return log_dir_path
+
def get_salometool_version(config):
- """Return the salomeTool version.
+ """Return the salomeTool version.
- :param config Config: The global Config instance.
- :return: the description of this version of sat in terms of tag and commit
- """
- return config.LOCAL.tag
+ :param config Config: The global Config instance.
+ :return: the description of this version of sat in terms of tag and commit
+ """
+ return config.LOCAL.tag
def get_salome_version(config):
import versionMinorMajorPatch as VMMP
- if hasattr(config.APPLICATION, 'version_salome'):
+ if hasattr(config.APPLICATION, "version_salome"):
version = VMMP.MinorMajorPatch(config.APPLICATION.version_salome)
else:
kernel_info = product.get_product_config(config, "KERNEL")
- aFile = os.path.join(
- kernel_info.install_dir,
- "bin",
- "salome",
- "VERSION")
+ aFile = os.path.join(kernel_info.install_dir, "bin", "salome", "VERSION")
if not os.path.isfile(aFile):
return None
with open(aFile) as f:
- line = f.readline() # example: '[SALOME KERNEL] : 8.4.0'
+ line = f.readline() # example: '[SALOME KERNEL] : 8.4.0'
version = VMMP.MinorMajorPatch(line.split(":")[1])
# from nov. 2023 and SALOME 9.10.0 forbid test(s) on integer, use MajorMinorPatch class tests
return version
+
def read_config_from_a_file(filePath):
- try:
- cfg_file = pyconf.Config(filePath)
- except pyconf.ConfigError as e:
- raise SatException(_("Error in configuration file: %(file)s\n %(error)s") % \
- { 'file': filePath, 'error': str(e) })
- return cfg_file
+ try:
+ cfg_file = pyconf.Config(filePath)
+ except pyconf.ConfigError as e:
+ raise SatException(
+ _("Error in configuration file: %(file)s\n %(error)s")
+ % {"file": filePath, "error": str(e)}
+ )
+ return cfg_file
+
def get_tmp_filename(cfg, name):
if not os.path.exists(cfg.VARS.tmp_root):
return os.path.join(cfg.VARS.tmp_root, name)
+
##
# Utils class to simplify path manipulations.
class Path:
if self.islink():
os.remove(self.path)
else:
- shutil.rmtree( self.path, onerror = handleRemoveReadonly )
+ shutil.rmtree(self.path, onerror=handleRemoveReadonly)
def copy(self, path, smart=False):
if not isinstance(path, Path):
except:
return False
-def find_file_in_lpath(file_name, lpath, additional_dir = ""):
+
+def find_file_in_lpath(file_name, lpath, additional_dir=""):
"""\
Find in all the directories in lpath list the file that has the same name
as file_name.
return os.path.join(dir_complete, file_name)
return False
-def find_file_in_ftppath(file_name, ftppath, installation_dir, logger, additional_dir = ""):
+
+def find_file_in_ftppath(
+ file_name, ftppath, installation_dir, logger, additional_dir=""
+):
"""\
Find in all ftp servers in ftppath the file called file_name
If it is found then return the destination path of the file
if not os.path.exists(installation_dir):
os.makedirs(installation_dir)
- destination=os.path.join(installation_dir, file_name)
+ destination = os.path.join(installation_dir, file_name)
# paths in ftppath may contain several paths separated by ":"
# we plit them, and push all paths in bigftppath
- bigftppath=[]
+ bigftppath = []
for ipath in ftppath:
- splpath=ipath.split(":")
- bigftppath+=splpath
+ splpath = ipath.split(":")
+ bigftppath += splpath
for ftp_archive in bigftppath:
- try:
- # ftp_archive has the form ftp.xxx.yyy/dir1/dir2/...
- ftp_archive_split=ftp_archive.split("/")
- ftp_server=ftp_archive_split[0]
- ftp = FTP(ftp_server)
- logger.write(" Connect to ftp server %s\n" % ftp_server, 3)
- ftp.login()
- for directory in ftp_archive_split[1:]:
- logger.write(" Change directory to %s\n" % directory, 3)
- ftp.cwd(directory)
- if additional_dir:
- ftp.cwd(additional_dir)
- except:
- logger.error("while connecting to ftp server %s\n" % ftp_server)
- continue
-
- try: # get md5 file if it exists
- file_name_md5=file_name + ".md5"
- destination_md5=destination + ".md5"
- if ftp.size(file_name_md5) > 0:
- with open(destination_md5,'wb') as dest_file_md5:
- ftp.retrbinary("RETR "+file_name_md5, dest_file_md5.write)
- except:
- pass
-
- try:
- if ftp.size(file_name) > 0:
- # if file exists and is non empty
- with open(destination,'wb') as dest_file:
- ftp.retrbinary("RETR "+file_name, dest_file.write)
- logger.write(" Archive %s was retrieved and stored in %s\n" % (file_name, destination), 3)
- return destination
- except:
- logger.error("File not found in ftp_archive %s\n" % ftp_server)
+ try:
+ # ftp_archive has the form ftp.xxx.yyy/dir1/dir2/...
+ ftp_archive_split = ftp_archive.split("/")
+ ftp_server = ftp_archive_split[0]
+ ftp = FTP(ftp_server)
+ logger.write(" Connect to ftp server %s\n" % ftp_server, 3)
+ ftp.login()
+ for directory in ftp_archive_split[1:]:
+ logger.write(" Change directory to %s\n" % directory, 3)
+ ftp.cwd(directory)
+ if additional_dir:
+ ftp.cwd(additional_dir)
+ except:
+ logger.error("while connecting to ftp server %s\n" % ftp_server)
+ continue
+
+ try: # get md5 file if it exists
+ file_name_md5 = file_name + ".md5"
+ destination_md5 = destination + ".md5"
+ if ftp.size(file_name_md5) > 0:
+ with open(destination_md5, "wb") as dest_file_md5:
+ ftp.retrbinary("RETR " + file_name_md5, dest_file_md5.write)
+ except:
+ pass
+
+ try:
+ if ftp.size(file_name) > 0:
+ # if file exists and is non empty
+ with open(destination, "wb") as dest_file:
+ ftp.retrbinary("RETR " + file_name, dest_file.write)
+ logger.write(
+ " Archive %s was retrieved and stored in %s\n"
+ % (file_name, destination),
+ 3,
+ )
+ return destination
+ except:
+ logger.error("File not found in ftp_archive %s\n" % ftp_server)
return False
+
def handleRemoveReadonly(func, path, exc):
excvalue = exc[1]
if func in (os.rmdir, os.remove) and excvalue.errno == errno.EACCES:
- os.chmod(path, stat.S_IRWXU| stat.S_IRWXG| stat.S_IRWXO) # 0777
+ os.chmod(path, stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO) # 0777
func(path)
else:
raise
+
def deepcopy_list(input_list):
"""\
Do a deep copy of a list
res.append(elem)
return res
+
def remove_item_from_list(input_list, item):
"""\
Remove all occurences of item from input_list
res.append(elem)
return res
+
def parse_date(date):
"""\
Transform YYYYMMDD_hhmmss into YYYY-MM-DD hh:mm:ss.
"""
if len(date) != 15:
return date
- res = "%s-%s-%s %s:%s:%s" % (date[0:4],
- date[4:6],
- date[6:8],
- date[9:11],
- date[11:13],
- date[13:])
+ res = "%s-%s-%s %s:%s:%s" % (
+ date[0:4],
+ date[4:6],
+ date[6:8],
+ date[9:11],
+ date[11:13],
+ date[13:],
+ )
return res
+
def merge_dicts(*dict_args):
"""\
Given any number of dicts, shallow copy and merge into a new dict,
result.update(dictionary)
return result
+
def replace_in_file(filein, strin, strout):
"""Replace <strin> by <strout> in file <filein>"""
shutil.move(filein, filein + "_old")
- fileout= filein
+ fileout = filein
filein = filein + "_old"
fin = open(filein, "r")
fout = open(fileout, "w")
for line in fin:
fout.write(line.replace(strin, strout))
+
def get_property_in_product_cfg(product_cfg, pprty):
if not "properties" in product_cfg:
return None
return None
return product_cfg.properties[pprty]
+
def activate_mesa_property(config):
"""Add mesa property into application properties
:param config Config: The global configuration. It must have an application!
"""
# Verify the existence of the file
- if not 'properties' in config.APPLICATION:
- config.APPLICATION.addMapping( 'properties', pyconf.Mapping(), None )
- config.APPLICATION.properties.use_mesa="yes"
+ if not "properties" in config.APPLICATION:
+ config.APPLICATION.addMapping("properties", pyconf.Mapping(), None)
+ config.APPLICATION.properties.use_mesa = "yes"
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2013 CEA/DEN
#
# This library is free software; you can redistribute it and/or
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-'''
+"""
In this file : all the stuff that can change with the architecture
on which SAT is running
-'''
+"""
import os, sys
-from platform import system,python_version,release
+from platform import system, python_version, release
# linux_distribution is removed from platform module in python 3.8+
-# we have to use distro module, which is not standard.
+# we have to use distro module, which is not standard.
# write an error message if distro is not installed
try:
from platform import linux_distribution
try:
from distro import linux_distribution
except:
- print ("\nError :\n"
- " linux_distribution was removed from platform module in Python 3.8+\n"
- " For python 3.8+ sat requires distro module to get information on linux distribution.\n"
- " Please install distro module with : pip install distro")
+ print(
+ "\nError :\n"
+ " linux_distribution was removed from platform module in Python 3.8+\n"
+ " For python 3.8+ sat requires distro module to get information on linux distribution.\n"
+ " Please install distro module with : pip install distro"
+ )
sys.exit(-1)
def is_windows():
- '''method that checks windows OS
-
+ """method that checks windows OS
+
:rtype: boolean
- '''
- return system() == 'Windows'
+ """
+ return system() == "Windows"
+
def get_user():
- '''method that gets the username that launched sat
-
+ """method that gets the username that launched sat
+
:rtype: str
- '''
- try :
+ """
+ try:
if is_windows():
# In windows case, the USERNAME environment variable has to be set
- user_name=os.environ['USERNAME']
- else: # linux
+ user_name = os.environ["USERNAME"]
+ else: # linux
import pwd
- user_name=pwd.getpwuid(os.getuid())[0]
- except :
- user_name="Unknown"
+
+ user_name = pwd.getpwuid(os.getuid())[0]
+ except:
+ user_name = "Unknown"
return user_name
-
+
def get_distribution(codes):
- '''Gets the code for the distribution
-
+ """Gets the code for the distribution
+
:param codes L{Mapping}: The map containing distribution correlation table.
- :return: The distribution on which salomeTools is running, regarding the
+ :return: The distribution on which salomeTools is running, regarding the
distribution correlation table contained in codes variable.
:rtype: str
- '''
+ """
if is_windows():
return "W"
# else get linux distribution description from platform, and encode it with code
lin_distrib = linux_distribution()[0].lower()
- distrib="not found"
+ distrib = "not found"
for dist in codes:
if dist in lin_distrib:
distrib = codes[dist]
break
- if distrib=="not found":
+ if distrib == "not found":
sys.stderr.write(_(u"Unknown distribution: '%s'\n") % distrib)
- sys.stderr.write(_(u"Please add your distribution to src/internal_config/distrib.pyconf\n"))
+ sys.stderr.write(
+ _(u"Please add your distribution to src/internal_config/distrib.pyconf\n")
+ )
sys.exit(-1)
return distrib
+
def get_version_XY():
"""
Return major and minor version of the distribution
from a CentOS example, returns '7.6'
extracted from platform.linux_distribution()
"""
- dist_version=linux_distribution()[1].split('.')
- if len(dist_version)==1:
+ dist_version = linux_distribution()[1].split(".")
+ if len(dist_version) == 1:
version = dist_version[0]
else:
version = dist_version[0] + "." + dist_version[1]
- return version
+ return version
def get_distrib_version(distrib):
- '''Return the sat encoded version of the distribution
+ """Return the sat encoded version of the distribution
This code is used in config to apend the name of the application directories
withdistribution info"
-
+
:param distrib str: The distribution on which the version will be found.
- :return: The version of the distribution on which salomeTools is running,
- regarding the distribution correlation table contained in codes
+ :return: The version of the distribution on which salomeTools is running,
+ regarding the distribution correlation table contained in codes
variable.
:rtype: str
- '''
+ """
if is_windows():
return release()
# get version from platform
- dist_version=linux_distribution()[1].split('.')
+ dist_version = linux_distribution()[1].split(".")
# encode it (conform to src/internal_config/distrib.pyconf VERSIONS dist
if distrib == "CO":
- version=dist_version[0] # for centos, we only care for major version
+ version = dist_version[0] # for centos, we only care for major version
elif distrib == "UB":
# for ubuntu, we care for major + minor version
- version=dist_version[0] + "." + dist_version[1]
+ version = dist_version[0] + "." + dist_version[1]
elif distrib == "DB":
if len(dist_version[0]) == 1:
- version="0"+dist_version[0]
+ version = "0" + dist_version[0]
else:
- version=dist_version[0] # unstable, and version >= 10
+ version = dist_version[0] # unstable, and version >= 10
elif distrib == "MG":
- version="0"+dist_version[0]
+ version = "0" + dist_version[0]
else:
- version=dist_version[0]
-
+ version = dist_version[0]
+
return version
+
def get_python_version():
- '''Gets the version of the running python.
-
+ """Gets the version of the running python.
+
:return: the version of the running python.
:rtype: str
- '''
-
+ """
+
# The platform python module gives the answer
return python_version()
+
def get_nb_proc():
- '''Gets the number of processors of the machine
+ """Gets the number of processors of the machine
on which salomeTools is running.
-
+
:return: the number of processors.
:rtype: str
- '''
-
- try :
+ """
+
+ try:
import multiprocessing
- nb_proc=multiprocessing.cpu_count()
- except :
+
+ nb_proc = multiprocessing.cpu_count()
+ except:
if is_windows():
if os.environ.has_key("NUMBER_OF_PROCESSORS"):
nb_proc = int(os.environ["NUMBER_OF_PROCESSORS"])
else:
nb_proc = 1
else:
- nb_proc=int(os.sysconf('SC_NPROCESSORS_ONLN'))
+ nb_proc = int(os.sysconf("SC_NPROCESSORS_ONLN"))
return nb_proc
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# https://gist.github.com/techtonik/2151727
# Public Domain, i.e. feel free to copy/paste
##############################################################################
def caller_name_simple(skip=1):
- """
- Get a name of a caller in the format module.class.method
-
- 'skip' specifies how many levels of stack to skip while getting caller
- name. skip=1 means 'who calls me', skip=2 'who calls my caller' etc.
-
- An empty string is returned if skipped levels exceed stack height
- """
-
- def stack_(frame):
- framelist = []
- while frame:
- framelist.append(frame)
- frame = frame.f_back
- return framelist
-
- stack = stack_(sys._getframe(1))
- start = 0 + skip
- if len(stack) < start + 1:
- return ''
- parentframe = stack[start]
-
- name = []
- module = inspect.getmodule(parentframe)
- # `modname` can be None when frame is executed directly in console
- # TODO(techtonik): consider using __main__
- if module:
- name.append(module.__name__)
- # detect classname
- if 'self' in parentframe.f_locals:
- # I don't know any way to detect call from the object method
- # XXX: there seems to be no way to detect static method call - it will
- # be just a function call
- name.append(parentframe.f_locals['self'].__class__.__name__)
- codename = parentframe.f_code.co_name
-
- fr = inspect.currentframe().f_back
- for i in range(skip): # no more 20 for precaution
- fr = fr.f_back
- if fr is None:
- break
- lineno = fr.f_lineno
-
- if codename != '<module>': # top level usually
- name.append(codename)
-
- name[-1] += "[%s]" % str(lineno) # function or a method
- del parentframe
- return ".".join(name)
+ """
+ Get a name of a caller in the format module.class.method
+
+ 'skip' specifies how many levels of stack to skip while getting caller
+ name. skip=1 means 'who calls me', skip=2 'who calls my caller' etc.
+
+ An empty string is returned if skipped levels exceed stack height
+ """
+
+ def stack_(frame):
+ framelist = []
+ while frame:
+ framelist.append(frame)
+ frame = frame.f_back
+ return framelist
+
+ stack = stack_(sys._getframe(1))
+ start = 0 + skip
+ if len(stack) < start + 1:
+ return ""
+ parentframe = stack[start]
+
+ name = []
+ module = inspect.getmodule(parentframe)
+ # `modname` can be None when frame is executed directly in console
+ # TODO(techtonik): consider using __main__
+ if module:
+ name.append(module.__name__)
+ # detect classname
+ if "self" in parentframe.f_locals:
+ # I don't know any way to detect call from the object method
+ # XXX: there seems to be no way to detect static method call - it will
+ # be just a function call
+ name.append(parentframe.f_locals["self"].__class__.__name__)
+ codename = parentframe.f_code.co_name
+
+ fr = inspect.currentframe().f_back
+ for i in range(skip): # no more 20 for precaution
+ fr = fr.f_back
+ if fr is None:
+ break
+ lineno = fr.f_lineno
+
+ if codename != "<module>": # top level usually
+ name.append(codename)
+
+ name[-1] += "[%s]" % str(lineno) # function or a method
+ del parentframe
+ return ".".join(name)
##############################################################################
def caller_name_stack(skip=1):
- """
- Get a name of a caller in the format module[no].class[no].method[no]
- where [no] is line nunber in source file(s)
-
- 'skip' specifies how many levels of stack to skip while getting caller
- name. skip=1 means 'who calls me', skip=2 'who calls my caller' etc.
-
- An empty string is returned if skipped levels exceed stack height
- """
- def stack_(frame):
- framelist = []
- while frame:
- framelist.append(frame)
- frame = frame.f_back
- return framelist
-
- stack = stack_(sys._getframe(1))
- start = 0 + skip
- if len(stack) < start + 1:
- return ''
- parentframe = stack[start]
-
- name = []
- module = inspect.getmodule(parentframe)
- # `modname` can be None when frame is executed directly in console
- # TODO(techtonik): consider using __main__
- if module:
- name.append(module.__name__)
- # detect classname
- if 'self' in parentframe.f_locals:
- # I don't know any way to detect call from the object method
- # XXX: there seems to be no way to detect static method call - it will
- # be just a function call
- name.append(parentframe.f_locals['self'].__class__.__name__)
- codename = parentframe.f_code.co_name
-
- fr = inspect.currentframe().f_back
- lineno = [fr.f_lineno]
- for i in range(20): # no more 20 for precaution
- fr = fr.f_back
- if fr is None:
- break
- #print("*** frame locals %s" % str(fr.f_locals.keys()))
- #print("*** frame globals %s" % str(fr.f_globals.keys()))
- try:
- namesrc = fr.f_globals["__name__"]
- if namesrc == "__main__":
- namesrc = os.path.basename(fr.f_globals["__file__"])
- lineno.insert(0, (namesrc + "[%s]" % fr.f_lineno))
- except:
- lineno.insert(0, ("??", fr.f_lineno))
-
- if codename != '<module>': # top level usually
- name.append(codename) # function or a method
-
- #print("lineno", lineno)
- #print("name", name)
-
- name[-1] += " // STACK: %s" % " ".join(lineno[0:-1])
-
- del parentframe
- return ".".join(name)
+ """
+ Get a name of a caller in the format module[no].class[no].method[no]
+ where [no] is line nunber in source file(s)
+
+ 'skip' specifies how many levels of stack to skip while getting caller
+ name. skip=1 means 'who calls me', skip=2 'who calls my caller' etc.
+
+ An empty string is returned if skipped levels exceed stack height
+ """
+
+ def stack_(frame):
+ framelist = []
+ while frame:
+ framelist.append(frame)
+ frame = frame.f_back
+ return framelist
+
+ stack = stack_(sys._getframe(1))
+ start = 0 + skip
+ if len(stack) < start + 1:
+ return ""
+ parentframe = stack[start]
+
+ name = []
+ module = inspect.getmodule(parentframe)
+ # `modname` can be None when frame is executed directly in console
+ # TODO(techtonik): consider using __main__
+ if module:
+ name.append(module.__name__)
+ # detect classname
+ if "self" in parentframe.f_locals:
+ # I don't know any way to detect call from the object method
+ # XXX: there seems to be no way to detect static method call - it will
+ # be just a function call
+ name.append(parentframe.f_locals["self"].__class__.__name__)
+ codename = parentframe.f_code.co_name
+
+ fr = inspect.currentframe().f_back
+ lineno = [fr.f_lineno]
+ for i in range(20): # no more 20 for precaution
+ fr = fr.f_back
+ if fr is None:
+ break
+ # print("*** frame locals %s" % str(fr.f_locals.keys()))
+ # print("*** frame globals %s" % str(fr.f_globals.keys()))
+ try:
+ namesrc = fr.f_globals["__name__"]
+ if namesrc == "__main__":
+ namesrc = os.path.basename(fr.f_globals["__file__"])
+ lineno.insert(0, (namesrc + "[%s]" % fr.f_lineno))
+ except:
+ lineno.insert(0, ("??", fr.f_lineno))
+
+ if codename != "<module>": # top level usually
+ name.append(codename) # function or a method
+
+ # print("lineno", lineno)
+ # print("name", name)
+
+ name[-1] += " // STACK: %s" % " ".join(lineno[0:-1])
+
+ del parentframe
+ return ".".join(name)
##############################################################################
def example_of_use(toCall):
- """
- example of use caller_name_simple, or else
- """
- class Dummy:
- def one_method(self):
- print("4- call in class %s" % toCall(0))
+ """
+ example of use caller_name_simple, or else
+ """
- print("1- call in %s" % toCall(0)) # output from main to here
- print("2- call in %s" % toCall(0))
- print("3- call in %s" % toCall(1)) # output from main to caller
- tmp = Dummy()
- tmp.one_method()
+ class Dummy:
+ def one_method(self):
+ print("4- call in class %s" % toCall(0))
+
+ print("1- call in %s" % toCall(0)) # output from main to here
+ print("2- call in %s" % toCall(0))
+ print("3- call in %s" % toCall(1)) # output from main to caller
+ tmp = Dummy()
+ tmp.one_method()
##############################################################################
# main as an example
##############################################################################
if __name__ == "__main__":
- example_of_use(caller_name_simple)
- example_of_use(caller_name_stack)
+ example_of_use(caller_name_simple)
+ example_of_use(caller_name_stack)
"""
example of output
# here default caller_name is user choice...
-caller_name = caller_name_simple # not so verbose
+caller_name = caller_name_simple # not so verbose
# caller_name = caller_name_stack # more verbose, with stack
from .ansi import Fore, Back, Style, Cursor
from .ansitowin32 import AnsiToWin32
-__version__ = '0.3.7'
-
+__version__ = "0.3.7"
# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
-'''
+"""
This module generates ANSI character codes to printing colors to terminals.
See: http://en.wikipedia.org/wiki/ANSI_escape_code
-'''
+"""
-CSI = '\033['
-OSC = '\033]'
-BEL = '\007'
+CSI = "\033["
+OSC = "\033]"
+BEL = "\007"
def code_to_chars(code):
- return CSI + str(code) + 'm'
+ return CSI + str(code) + "m"
+
def set_title(title):
- return OSC + '2;' + title + BEL
+ return OSC + "2;" + title + BEL
+
def clear_screen(mode=2):
- return CSI + str(mode) + 'J'
+ return CSI + str(mode) + "J"
+
def clear_line(mode=2):
- return CSI + str(mode) + 'K'
+ return CSI + str(mode) + "K"
class AnsiCodes(object):
# Upon instantiation we define instance attributes, which are the same
# as the class attributes but wrapped with the ANSI escape sequence
for name in dir(self):
- if not name.startswith('_'):
+ if not name.startswith("_"):
value = getattr(self, name)
setattr(self, name, code_to_chars(value))
class AnsiCursor(object):
def UP(self, n=1):
- return CSI + str(n) + 'A'
+ return CSI + str(n) + "A"
+
def DOWN(self, n=1):
- return CSI + str(n) + 'B'
+ return CSI + str(n) + "B"
+
def FORWARD(self, n=1):
- return CSI + str(n) + 'C'
+ return CSI + str(n) + "C"
+
def BACK(self, n=1):
- return CSI + str(n) + 'D'
+ return CSI + str(n) + "D"
+
def POS(self, x=1, y=1):
- return CSI + str(y) + ';' + str(x) + 'H'
+ return CSI + str(y) + ";" + str(x) + "H"
class AnsiFore(AnsiCodes):
- BLACK = 30
- RED = 31
- GREEN = 32
- YELLOW = 33
- BLUE = 34
- MAGENTA = 35
- CYAN = 36
- WHITE = 37
- RESET = 39
+ BLACK = 30
+ RED = 31
+ GREEN = 32
+ YELLOW = 33
+ BLUE = 34
+ MAGENTA = 35
+ CYAN = 36
+ WHITE = 37
+ RESET = 39
# These are fairly well supported, but not part of the standard.
- LIGHTBLACK_EX = 90
- LIGHTRED_EX = 91
- LIGHTGREEN_EX = 92
- LIGHTYELLOW_EX = 93
- LIGHTBLUE_EX = 94
+ LIGHTBLACK_EX = 90
+ LIGHTRED_EX = 91
+ LIGHTGREEN_EX = 92
+ LIGHTYELLOW_EX = 93
+ LIGHTBLUE_EX = 94
LIGHTMAGENTA_EX = 95
- LIGHTCYAN_EX = 96
- LIGHTWHITE_EX = 97
+ LIGHTCYAN_EX = 96
+ LIGHTWHITE_EX = 97
class AnsiBack(AnsiCodes):
- BLACK = 40
- RED = 41
- GREEN = 42
- YELLOW = 43
- BLUE = 44
- MAGENTA = 45
- CYAN = 46
- WHITE = 47
- RESET = 49
+ BLACK = 40
+ RED = 41
+ GREEN = 42
+ YELLOW = 43
+ BLUE = 44
+ MAGENTA = 45
+ CYAN = 46
+ WHITE = 47
+ RESET = 49
# These are fairly well supported, but not part of the standard.
- LIGHTBLACK_EX = 100
- LIGHTRED_EX = 101
- LIGHTGREEN_EX = 102
- LIGHTYELLOW_EX = 103
- LIGHTBLUE_EX = 104
+ LIGHTBLACK_EX = 100
+ LIGHTRED_EX = 101
+ LIGHTGREEN_EX = 102
+ LIGHTYELLOW_EX = 103
+ LIGHTBLUE_EX = 104
LIGHTMAGENTA_EX = 105
- LIGHTCYAN_EX = 106
- LIGHTWHITE_EX = 107
+ LIGHTCYAN_EX = 106
+ LIGHTWHITE_EX = 107
class AnsiStyle(AnsiCodes):
- BRIGHT = 1
- DIM = 2
- NORMAL = 22
+ BRIGHT = 1
+ DIM = 2
+ NORMAL = 22
RESET_ALL = 0
-Fore = AnsiFore()
-Back = AnsiBack()
-Style = AnsiStyle()
+
+Fore = AnsiFore()
+Back = AnsiBack()
+Style = AnsiStyle()
Cursor = AnsiCursor()
def is_stream_closed(stream):
- return not hasattr(stream, 'closed') or stream.closed
+ return not hasattr(stream, "closed") or stream.closed
def is_a_tty(stream):
- return hasattr(stream, 'isatty') and stream.isatty()
+ return hasattr(stream, "isatty") and stream.isatty()
class StreamWrapper(object):
- '''
+ """
Wraps a stream (such as stdout), acting as a transparent proxy for all
attribute access apart from method 'write()', which is delegated to our
Converter instance.
- '''
+ """
+
def __init__(self, wrapped, converter):
# double-underscore everything to prevent clashes with names of
# attributes on the wrapped stream object.
class AnsiToWin32(object):
- '''
+ """
Implements a 'write()' method which, on Windows, will strip ANSI character
sequences from the text, and if outputting to a tty, will convert them into
win32 function calls.
- '''
- ANSI_CSI_RE = re.compile('\001?\033\[((?:\d|;)*)([a-zA-Z])\002?') # Control Sequence Introducer
- ANSI_OSC_RE = re.compile('\001?\033\]((?:.|;)*?)(\x07)\002?') # Operating System Command
+ """
+
+ ANSI_CSI_RE = re.compile(
+ "\001?\033\[((?:\d|;)*)([a-zA-Z])\002?"
+ ) # Control Sequence Introducer
+ ANSI_OSC_RE = re.compile(
+ "\001?\033\]((?:.|;)*?)(\x07)\002?"
+ ) # Operating System Command
def __init__(self, wrapped, convert=None, strip=None, autoreset=False):
# The wrapped stream (normally sys.stdout or sys.stderr)
# create the proxy wrapping our output stream
self.stream = StreamWrapper(wrapped, self)
- on_windows = os.name == 'nt'
+ on_windows = os.name == "nt"
# We test if the WinAPI works, because even if we are on Windows
# we may be using a terminal that doesn't support the WinAPI
# (e.g. Cygwin Terminal). In this case it's up to the terminal
# should we strip ANSI sequences from our output?
if strip is None:
- strip = conversion_supported or (not is_stream_closed(wrapped) and not is_a_tty(wrapped))
+ strip = conversion_supported or (
+ not is_stream_closed(wrapped) and not is_a_tty(wrapped)
+ )
self.strip = strip
# should we should convert ANSI sequences into win32 calls?
if convert is None:
- convert = conversion_supported and not is_stream_closed(wrapped) and is_a_tty(wrapped)
+ convert = (
+ conversion_supported
+ and not is_stream_closed(wrapped)
+ and is_a_tty(wrapped)
+ )
self.convert = convert
# dict of ansi codes to win32 functions and parameters
self.on_stderr = self.wrapped is sys.stderr
def should_wrap(self):
- '''
+ """
True if this class is actually needed. If false, then the output
stream will not be affected, nor will win32 calls be issued, so
wrapping stdout is not actually required. This will generally be
False on non-Windows platforms, unless optional functionality like
autoreset has been requested using kwargs to init()
- '''
+ """
return self.convert or self.strip or self.autoreset
def get_win32_calls(self):
if self.convert and winterm:
return {
- AnsiStyle.RESET_ALL: (winterm.reset_all, ),
+ AnsiStyle.RESET_ALL: (winterm.reset_all,),
AnsiStyle.BRIGHT: (winterm.style, WinStyle.BRIGHT),
AnsiStyle.DIM: (winterm.style, WinStyle.NORMAL),
AnsiStyle.NORMAL: (winterm.style, WinStyle.NORMAL),
AnsiFore.MAGENTA: (winterm.fore, WinColor.MAGENTA),
AnsiFore.CYAN: (winterm.fore, WinColor.CYAN),
AnsiFore.WHITE: (winterm.fore, WinColor.GREY),
- AnsiFore.RESET: (winterm.fore, ),
+ AnsiFore.RESET: (winterm.fore,),
AnsiFore.LIGHTBLACK_EX: (winterm.fore, WinColor.BLACK, True),
AnsiFore.LIGHTRED_EX: (winterm.fore, WinColor.RED, True),
AnsiFore.LIGHTGREEN_EX: (winterm.fore, WinColor.GREEN, True),
AnsiBack.MAGENTA: (winterm.back, WinColor.MAGENTA),
AnsiBack.CYAN: (winterm.back, WinColor.CYAN),
AnsiBack.WHITE: (winterm.back, WinColor.GREY),
- AnsiBack.RESET: (winterm.back, ),
+ AnsiBack.RESET: (winterm.back,),
AnsiBack.LIGHTBLACK_EX: (winterm.back, WinColor.BLACK, True),
AnsiBack.LIGHTRED_EX: (winterm.back, WinColor.RED, True),
AnsiBack.LIGHTGREEN_EX: (winterm.back, WinColor.GREEN, True),
if self.autoreset:
self.reset_all()
-
def reset_all(self):
if self.convert:
- self.call_win32('m', (0,))
+ self.call_win32("m", (0,))
elif not self.strip and not is_stream_closed(self.wrapped):
self.wrapped.write(Style.RESET_ALL)
-
def write_and_convert(self, text):
- '''
+ """
Write the given text to our wrapped stream, stripping any ANSI
sequences from the text, and optionally converting them into win32
calls.
- '''
+ """
cursor = 0
text = self.convert_osc(text)
for match in self.ANSI_CSI_RE.finditer(text):
cursor = end
self.write_plain_text(text, cursor, len(text))
-
def write_plain_text(self, text, start, end):
if start < end:
self.wrapped.write(text[start:end])
self.wrapped.flush()
-
def convert_ansi(self, paramstring, command):
if self.convert:
params = self.extract_params(command, paramstring)
self.call_win32(command, params)
-
def extract_params(self, command, paramstring):
- if command in 'Hf':
- params = tuple(int(p) if len(p) != 0 else 1 for p in paramstring.split(';'))
+ if command in "Hf":
+ params = tuple(int(p) if len(p) != 0 else 1 for p in paramstring.split(";"))
while len(params) < 2:
# defaults:
params = params + (1,)
else:
- params = tuple(int(p) for p in paramstring.split(';') if len(p) != 0)
+ params = tuple(int(p) for p in paramstring.split(";") if len(p) != 0)
if len(params) == 0:
# defaults:
- if command in 'JKm':
+ if command in "JKm":
params = (0,)
- elif command in 'ABCD':
+ elif command in "ABCD":
params = (1,)
return params
-
def call_win32(self, command, params):
- if command == 'm':
+ if command == "m":
for param in params:
if param in self.win32_calls:
func_args = self.win32_calls[param]
args = func_args[1:]
kwargs = dict(on_stderr=self.on_stderr)
func(*args, **kwargs)
- elif command in 'J':
+ elif command in "J":
winterm.erase_screen(params[0], on_stderr=self.on_stderr)
- elif command in 'K':
+ elif command in "K":
winterm.erase_line(params[0], on_stderr=self.on_stderr)
- elif command in 'Hf': # cursor position - absolute
+ elif command in "Hf": # cursor position - absolute
winterm.set_cursor_position(params, on_stderr=self.on_stderr)
- elif command in 'ABCD': # cursor position - relative
+ elif command in "ABCD": # cursor position - relative
n = params[0]
# A - up, B - down, C - forward, D - back
- x, y = {'A': (0, -n), 'B': (0, n), 'C': (n, 0), 'D': (-n, 0)}[command]
+ x, y = {"A": (0, -n), "B": (0, n), "C": (n, 0), "D": (-n, 0)}[command]
winterm.cursor_adjust(x, y, on_stderr=self.on_stderr)
-
def convert_osc(self, text):
for match in self.ANSI_OSC_RE.finditer(text):
start, end = match.span()
text = text[:start] + text[end:]
paramstring, command = match.groups()
- if command in '\x07': # \x07 = BEL
+ if command in "\x07": # \x07 = BEL
params = paramstring.split(";")
# 0 - change title and icon (we will only change title)
# 1 - change icon (we don't support this)
# 2 - change title
- if params[0] in '02':
+ if params[0] in "02":
winterm.set_title(params[1])
return text
def reset_all():
- if AnsiToWin32 is not None: # Issue #74: objects might become None at exit
+ if AnsiToWin32 is not None: # Issue #74: objects might become None at exit
AnsiToWin32(orig_stdout).reset_all()
def init(autoreset=False, convert=None, strip=None, wrap=True):
if not wrap and any([autoreset, convert, strip]):
- raise ValueError('wrap=False conflicts with any other arg=True')
+ raise ValueError("wrap=False conflicts with any other arg=True")
global wrapped_stdout, wrapped_stderr
global orig_stdout, orig_stderr
if sys.stdout is None:
wrapped_stdout = None
else:
- sys.stdout = wrapped_stdout = \
- wrap_stream(orig_stdout, convert, strip, autoreset, wrap)
+ sys.stdout = wrapped_stdout = wrap_stream(
+ orig_stdout, convert, strip, autoreset, wrap
+ )
if sys.stderr is None:
wrapped_stderr = None
else:
- sys.stderr = wrapped_stderr = \
- wrap_stream(orig_stderr, convert, strip, autoreset, wrap)
+ sys.stderr = wrapped_stderr = wrap_stream(
+ orig_stderr, convert, strip, autoreset, wrap
+ )
global atexit_done
if not atexit_done:
def wrap_stream(stream, convert, strip, autoreset, wrap):
if wrap:
- wrapper = AnsiToWin32(stream,
- convert=convert, strip=strip, autoreset=autoreset)
+ wrapper = AnsiToWin32(stream, convert=convert, strip=strip, autoreset=autoreset)
if wrapper.should_wrap():
stream = wrapper.stream
return stream
-
-
try:
import ctypes
from ctypes import LibraryLoader
+
windll = LibraryLoader(ctypes.WinDLL)
from ctypes import wintypes
except (AttributeError, ImportError):
class CONSOLE_SCREEN_BUFFER_INFO(Structure):
"""struct in wincon.h."""
+
_fields_ = [
("dwSize", COORD),
("dwCursorPosition", COORD),
("srWindow", wintypes.SMALL_RECT),
("dwMaximumWindowSize", COORD),
]
+
def __str__(self):
- return '(%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d)' % (
- self.dwSize.Y, self.dwSize.X
- , self.dwCursorPosition.Y, self.dwCursorPosition.X
- , self.wAttributes
- , self.srWindow.Top, self.srWindow.Left, self.srWindow.Bottom, self.srWindow.Right
- , self.dwMaximumWindowSize.Y, self.dwMaximumWindowSize.X
+ return "(%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d)" % (
+ self.dwSize.Y,
+ self.dwSize.X,
+ self.dwCursorPosition.Y,
+ self.dwCursorPosition.X,
+ self.wAttributes,
+ self.srWindow.Top,
+ self.srWindow.Left,
+ self.srWindow.Bottom,
+ self.srWindow.Right,
+ self.dwMaximumWindowSize.Y,
+ self.dwMaximumWindowSize.X,
)
_GetStdHandle = windll.kernel32.GetStdHandle
_FillConsoleOutputAttribute.restype = wintypes.BOOL
_SetConsoleTitleW = windll.kernel32.SetConsoleTitleA
- _SetConsoleTitleW.argtypes = [
- wintypes.LPCSTR
- ]
+ _SetConsoleTitleW.argtypes = [wintypes.LPCSTR]
_SetConsoleTitleW.restype = wintypes.BOOL
handles = {
def winapi_test():
handle = handles[STDOUT]
csbi = CONSOLE_SCREEN_BUFFER_INFO()
- success = _GetConsoleScreenBufferInfo(
- handle, byref(csbi))
+ success = _GetConsoleScreenBufferInfo(handle, byref(csbi))
return bool(success)
def GetConsoleScreenBufferInfo(stream_id=STDOUT):
handle = handles[stream_id]
csbi = CONSOLE_SCREEN_BUFFER_INFO()
- success = _GetConsoleScreenBufferInfo(
- handle, byref(csbi))
+ success = _GetConsoleScreenBufferInfo(handle, byref(csbi))
return csbi
def SetConsoleTextAttribute(stream_id, attrs):
num_written = wintypes.DWORD(0)
# Note that this is hard-coded for ANSI (vs wide) bytes.
success = _FillConsoleOutputCharacterA(
- handle, char, length, start, byref(num_written))
+ handle, char, length, start, byref(num_written)
+ )
return num_written.value
def FillConsoleOutputAttribute(stream_id, attr, length, start):
- ''' FillConsoleOutputAttribute( hConsole, csbi.wAttributes, dwConSize, coordScreen, &cCharsWritten )'''
+ """FillConsoleOutputAttribute( hConsole, csbi.wAttributes, dwConSize, coordScreen, &cCharsWritten )"""
handle = handles[stream_id]
attribute = wintypes.WORD(attr)
length = wintypes.DWORD(length)
num_written = wintypes.DWORD(0)
# Note that this is hard-coded for ANSI (vs wide) bytes.
return _FillConsoleOutputAttribute(
- handle, attribute, length, start, byref(num_written))
+ handle, attribute, length, start, byref(num_written)
+ )
def SetConsoleTitle(title):
return _SetConsoleTitleW(title)
# from wincon.h
class WinColor(object):
- BLACK = 0
- BLUE = 1
- GREEN = 2
- CYAN = 3
- RED = 4
+ BLACK = 0
+ BLUE = 1
+ GREEN = 2
+ CYAN = 3
+ RED = 4
MAGENTA = 5
- YELLOW = 6
- GREY = 7
+ YELLOW = 6
+ GREY = 7
+
# from wincon.h
class WinStyle(object):
- NORMAL = 0x00 # dim text, dim background
- BRIGHT = 0x08 # bright text, dim background
- BRIGHT_BACKGROUND = 0x80 # dim text, bright background
+ NORMAL = 0x00 # dim text, dim background
+ BRIGHT = 0x08 # bright text, dim background
+ BRIGHT_BACKGROUND = 0x80 # dim text, bright background
-class WinTerm(object):
+class WinTerm(object):
def __init__(self):
self._default = win32.GetConsoleScreenBufferInfo(win32.STDOUT).wAttributes
self.set_attrs(self._default)
# get the number of character cells in the current buffer
cells_in_screen = csbi.dwSize.X * csbi.dwSize.Y
# get number of character cells before current cursor position
- cells_before_cursor = csbi.dwSize.X * csbi.dwCursorPosition.Y + csbi.dwCursorPosition.X
+ cells_before_cursor = (
+ csbi.dwSize.X * csbi.dwCursorPosition.Y + csbi.dwCursorPosition.X
+ )
if mode == 0:
from_coord = csbi.dwCursorPosition
cells_to_erase = cells_in_screen - cells_before_cursor
from_coord = win32.COORD(0, 0)
cells_to_erase = cells_in_screen
# fill the entire screen with blanks
- win32.FillConsoleOutputCharacter(handle, ' ', cells_to_erase, from_coord)
+ win32.FillConsoleOutputCharacter(handle, " ", cells_to_erase, from_coord)
# now set the buffer's attributes accordingly
- win32.FillConsoleOutputAttribute(handle, self.get_attrs(), cells_to_erase, from_coord)
+ win32.FillConsoleOutputAttribute(
+ handle, self.get_attrs(), cells_to_erase, from_coord
+ )
if mode == 2:
# put the cursor where needed
win32.SetConsoleCursorPosition(handle, (1, 1))
from_coord = win32.COORD(0, csbi.dwCursorPosition.Y)
cells_to_erase = csbi.dwSize.X
# fill the entire screen with blanks
- win32.FillConsoleOutputCharacter(handle, ' ', cells_to_erase, from_coord)
+ win32.FillConsoleOutputCharacter(handle, " ", cells_to_erase, from_coord)
# now set the buffer's attributes accordingly
- win32.FillConsoleOutputAttribute(handle, self.get_attrs(), cells_to_erase, from_coord)
+ win32.FillConsoleOutputAttribute(
+ handle, self.get_attrs(), cells_to_erase, from_coord
+ )
def set_title(self, title):
win32.SetConsoleTitle(title)
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2013 CEA/DEN
#
# This library is free software; you can redistribute it and/or
import src
-C_COMPILE_ENV_LIST = ["CC",
- "CXX",
- "F77",
- "CFLAGS",
- "CXXFLAGS",
- "LIBS",
- "LDFLAGS"]
+C_COMPILE_ENV_LIST = ["CC", "CXX", "F77", "CFLAGS", "CXXFLAGS", "LIBS", "LDFLAGS"]
+
class Builder:
- """Class to handle all construction steps, like cmake, configure, make, ...
- """
- def __init__(self,
- config,
- logger,
- product_name,
- product_info,
- options = src.options.OptResult(),
- check_src=True):
+ """Class to handle all construction steps, like cmake, configure, make, ..."""
+
+ def __init__(
+ self,
+ config,
+ logger,
+ product_name,
+ product_info,
+ options=src.options.OptResult(),
+ check_src=True,
+ ):
self.config = config
self.logger = logger
self.options = options
# create build dir
self.build_dir.make()
- self.log(' build_dir = %s\n' % str(self.build_dir), 4)
- self.log(' install_dir = %s\n' % str(self.install_dir), 4)
- self.log('\n', 4)
+ self.log(" build_dir = %s\n" % str(self.build_dir), 4)
+ self.log(" install_dir = %s\n" % str(self.install_dir), 4)
+ self.log("\n", 4)
# add products in depend and opt_depend list recursively
- environ_info = src.product.get_product_dependencies(self.config,
- self.product_name,
- self.product_info)
- #environ_info.append(self.product_info.name)
+ environ_info = src.product.get_product_dependencies(
+ self.config, self.product_name, self.product_info
+ )
+ # environ_info.append(self.product_info.name)
# create build environment
- self.build_environ = src.environment.SalomeEnviron(self.config,
- src.environment.Environ(dict(os.environ)),
- True)
- self.build_environ.silent = (self.config.USER.output_verbose_level < 5)
+ self.build_environ = src.environment.SalomeEnviron(
+ self.config, src.environment.Environ(dict(os.environ)), True
+ )
+ self.build_environ.silent = self.config.USER.output_verbose_level < 5
self.build_environ.set_full_environ(self.logger, environ_info)
-
+
if add_env_launch:
- # create runtime environment
- self.launch_environ = src.environment.SalomeEnviron(self.config,
- src.environment.Environ(dict(os.environ)),
- False)
- self.launch_environ.silent = True # no need to show here
+ # create runtime environment
+ self.launch_environ = src.environment.SalomeEnviron(
+ self.config, src.environment.Environ(dict(os.environ)), False
+ )
+ self.launch_environ.silent = True # no need to show here
self.launch_environ.set_full_environ(self.logger, environ_info)
for ee in C_COMPILE_ENV_LIST:
cmake_option = options
# cmake_option +=' -DCMAKE_VERBOSE_MAKEFILE=ON -DSALOME_CMAKE_DEBUG=ON'
- if 'cmake_options' in self.product_info:
- cmake_option += " %s " % " ".join(
- self.product_info.cmake_options.split())
+ if "cmake_options" in self.product_info:
+ cmake_option += " %s " % " ".join(self.product_info.cmake_options.split())
# add debug option
if self.debug_mode:
cmake_option += " -DCMAKE_BUILD_TYPE=Debug"
- else :
+ else:
cmake_option += " -DCMAKE_BUILD_TYPE=Release"
# add verbose option if specified in application for this product.
if self.verbose_mode:
cmake_option += " -DCMAKE_VERBOSE_MAKEFILE=ON"
- # In case CMAKE_GENERATOR is defined in environment,
+ # In case CMAKE_GENERATOR is defined in environment,
# use it in spite of automatically detect it
- if 'cmake_generator' in self.config.APPLICATION:
- cmake_option += " -DCMAKE_GENERATOR=\"%s\"" \
- % self.config.APPLICATION.cmake_generator
- command = ("cmake %s -DCMAKE_INSTALL_PREFIX=%s %s" %
- (cmake_option, self.install_dir, self.source_dir))
+ if "cmake_generator" in self.config.APPLICATION:
+ cmake_option += (
+ ' -DCMAKE_GENERATOR="%s"' % self.config.APPLICATION.cmake_generator
+ )
+ command = "cmake %s -DCMAKE_INSTALL_PREFIX=%s %s" % (
+ cmake_option,
+ self.install_dir,
+ self.source_dir,
+ )
self.log_command(command)
# for key in sorted(self.build_environ.environ.environ.keys()):
- # print key, " ", self.build_environ.environ.environ[key]
- res = subprocess.call(command,
- shell=True,
- cwd=str(self.build_dir),
- env=self.build_environ.environ.environ,
- stdout=self.logger.logTxtFile,
- stderr=subprocess.STDOUT)
+ # print key, " ", self.build_environ.environ.environ[key]
+ res = subprocess.call(
+ command,
+ shell=True,
+ cwd=str(self.build_dir),
+ env=self.build_environ.environ.environ,
+ stdout=self.logger.logTxtFile,
+ stderr=subprocess.STDOUT,
+ )
self.put_txt_log_in_appli_log_dir("cmake")
if res == 0:
# Runs build_configure with the given options.
def build_configure(self, options=""):
- if 'buildconfigure_options' in self.product_info:
+ if "buildconfigure_options" in self.product_info:
options += " %s " % self.product_info.buildconfigure_options
- command = str('%s/build_configure') % (self.source_dir)
+ command = str("%s/build_configure") % (self.source_dir)
command = command + " " + options
self.log_command(command)
- res = subprocess.call(command,
- shell=True,
- cwd=str(self.build_dir),
- env=self.build_environ.environ.environ,
- stdout=self.logger.logTxtFile,
- stderr=subprocess.STDOUT)
+ res = subprocess.call(
+ command,
+ shell=True,
+ cwd=str(self.build_dir),
+ env=self.build_environ.environ.environ,
+ stdout=self.logger.logTxtFile,
+ stderr=subprocess.STDOUT,
+ )
self.put_txt_log_in_appli_log_dir("build_configure")
if res == 0:
return res
# Runs configure with the given options.
def configure(self, options=""):
- if 'configure_options' in self.product_info:
+ if "configure_options" in self.product_info:
options += " %s " % self.product_info.configure_options
- command = "%s/configure --prefix=%s" % (self.source_dir,
- str(self.install_dir))
+ command = "%s/configure --prefix=%s" % (self.source_dir, str(self.install_dir))
command = command + " " + options
self.log_command(command)
- res = subprocess.call(command,
- shell=True,
- cwd=str(self.build_dir),
- env=self.build_environ.environ.environ,
- stdout=self.logger.logTxtFile,
- stderr=subprocess.STDOUT)
-
+ res = subprocess.call(
+ command,
+ shell=True,
+ cwd=str(self.build_dir),
+ env=self.build_environ.environ.environ,
+ stdout=self.logger.logTxtFile,
+ stderr=subprocess.STDOUT,
+ )
+
self.put_txt_log_in_appli_log_dir("configure")
if res == 0:
return res
return 1
def hack_libtool(self):
- if not os.path.exists(str(self.build_dir + 'libtool')):
+ if not os.path.exists(str(self.build_dir + "libtool")):
return
- lf = open(os.path.join(str(self.build_dir), "libtool"), 'r')
+ lf = open(os.path.join(str(self.build_dir), "libtool"), "r")
for line in lf.readlines():
- if 'hack_libtool' in line:
+ if "hack_libtool" in line:
return
# fix libtool by replacing CC="<compil>" with hack_libtool function
- hack_command='''sed -i "s%^CC=\\"\(.*\)\\"%hack_libtool() { \\n\\
+ hack_command = """sed -i "s%^CC=\\"\(.*\)\\"%hack_libtool() { \\n\\
if test \\"\$(echo \$@ | grep -E '\\\\\\-L/usr/lib(/../lib)?(64)? ')\\" == \\\"\\\" \\n\\
then\\n\\
cmd=\\"\\1 \$@\\"\\n\\
fi\\n\\
\$cmd\\n\\
}\\n\\
-CC=\\"hack_libtool\\"%g" libtool'''
+CC=\\"hack_libtool\\"%g" libtool"""
self.log_command(hack_command)
- subprocess.call(hack_command,
- shell=True,
- cwd=str(self.build_dir),
- env=self.build_environ.environ.environ,
- stdout=self.logger.logTxtFile,
- stderr=subprocess.STDOUT)
-
+ subprocess.call(
+ hack_command,
+ shell=True,
+ cwd=str(self.build_dir),
+ env=self.build_environ.environ.environ,
+ stdout=self.logger.logTxtFile,
+ stderr=subprocess.STDOUT,
+ )
##
# Runs make to build the module.
def make(self, nb_proc, make_opt=""):
# make
- command = 'make'
+ command = "make"
command = command + " -j" + str(nb_proc)
command = command + " " + make_opt
self.log_command(command)
- res = subprocess.call(command,
- shell=True,
- cwd=str(self.build_dir),
- env=self.build_environ.environ.environ,
- stdout=self.logger.logTxtFile,
- stderr=subprocess.STDOUT)
+ res = subprocess.call(
+ command,
+ shell=True,
+ cwd=str(self.build_dir),
+ env=self.build_environ.environ.environ,
+ stdout=self.logger.logTxtFile,
+ stderr=subprocess.STDOUT,
+ )
self.put_txt_log_in_appli_log_dir("make")
if res == 0:
return res
else:
return 1
-
+
##
# Runs msbuild to build the module.
- def wmake(self,nb_proc, opt_nb_proc = None):
+ def wmake(self, nb_proc, opt_nb_proc=None):
- hh = 'MSBUILD /m:%s' % str(nb_proc)
+ hh = "MSBUILD /m:%s" % str(nb_proc)
if self.debug_mode:
hh += " " + src.printcolors.printcWarning("DEBUG")
# make
- command = 'msbuild'
+ command = "msbuild"
command = command + " /maxcpucount:" + str(nb_proc)
if self.debug_mode:
command = command + " /p:Configuration=Debug /p:Platform=x64 "
command = command + " ALL_BUILD.vcxproj"
self.log_command(command)
- res = subprocess.call(command,
- shell=True,
- cwd=str(self.build_dir),
- env=self.build_environ.environ.environ,
- stdout=self.logger.logTxtFile,
- stderr=subprocess.STDOUT)
-
+ res = subprocess.call(
+ command,
+ shell=True,
+ cwd=str(self.build_dir),
+ env=self.build_environ.environ.environ,
+ stdout=self.logger.logTxtFile,
+ stderr=subprocess.STDOUT,
+ )
+
self.put_txt_log_in_appli_log_dir("make")
if res == 0:
return res
# Runs 'make install'.
def install(self):
if src.architecture.is_windows():
- command = 'msbuild INSTALL.vcxproj'
+ command = "msbuild INSTALL.vcxproj"
if self.debug_mode:
command = command + " /p:Configuration=Debug /p:Platform=x64 "
else:
command = command + " /p:Configuration=Release /p:Platform=x64 "
- else :
- command = 'make install'
+ else:
+ command = "make install"
self.log_command(command)
- res = subprocess.call(command,
- shell=True,
- cwd=str(self.build_dir),
- env=self.build_environ.environ.environ,
- stdout=self.logger.logTxtFile,
- stderr=subprocess.STDOUT)
-
- res_check=self.check_install()
- if res_check > 0 :
- self.log_command("Error in sat check install - some files are not installed!")
+ res = subprocess.call(
+ command,
+ shell=True,
+ cwd=str(self.build_dir),
+ env=self.build_environ.environ.environ,
+ stdout=self.logger.logTxtFile,
+ stderr=subprocess.STDOUT,
+ )
+
+ res_check = self.check_install()
+ if res_check > 0:
+ self.log_command(
+ "Error in sat check install - some files are not installed!"
+ )
self.put_txt_log_in_appli_log_dir("makeinstall")
- res+=res_check
+ res += res_check
if res == 0:
return res
else:
return 1
- # this function checks wether a list of file patterns (specified by check_install keyword)
+ # this function checks wether a list of file patterns (specified by check_install keyword)
# exixts after the make install. The objective is to ensure the installation is complete.
# patterns are given relatively to the install dir of the product
def check_install(self):
- res=0
+ res = 0
if "check_install" in self.product_info:
self.log_command("Check installation of files")
for pattern in self.product_info.check_install:
# pattern is given relatively to the install dir
- complete_pattern=os.path.join(self.product_info.install_dir, pattern)
+ complete_pattern = os.path.join(self.product_info.install_dir, pattern)
self.log_command(" -> check %s" % complete_pattern)
# expansion of pattern : takes into account environment variables and unix shell rules
- list_of_path=glob.glob(os.path.expandvars(complete_pattern))
+ list_of_path = glob.glob(os.path.expandvars(complete_pattern))
if not list_of_path:
# we expect to find at least one entry, if not we consider the test failed
- res+=1
- self.logger.write("Error, sat check install failed for file pattern %s\n" % complete_pattern, 1)
- self.log_command("Error, sat check install failed for file pattern %s" % complete_pattern)
+ res += 1
+ self.logger.write(
+ "Error, sat check install failed for file pattern %s\n"
+ % complete_pattern,
+ 1,
+ )
+ self.log_command(
+ "Error, sat check install failed for file pattern %s"
+ % complete_pattern
+ )
return res
##
# Runs 'make_check'.
def check(self, command=""):
if src.architecture.is_windows():
- cmd = 'msbuild RUN_TESTS.vcxproj /p:Configuration=Release /p:Platform=x64 '
- else :
- if self.product_info.build_source=="autotools" :
- cmd = 'make check'
+ cmd = "msbuild RUN_TESTS.vcxproj /p:Configuration=Release /p:Platform=x64 "
+ else:
+ if self.product_info.build_source == "autotools":
+ cmd = "make check"
else:
- cmd = 'make test'
-
+ cmd = "make test"
+
if command:
cmd = command
-
+
self.log_command(cmd)
self.log_command("For more detailed logs, see test logs in %s" % self.build_dir)
- res = subprocess.call(cmd,
- shell=True,
- cwd=str(self.build_dir),
- env=self.launch_environ.environ.environ,
- stdout=self.logger.logTxtFile,
- stderr=subprocess.STDOUT)
+ res = subprocess.call(
+ cmd,
+ shell=True,
+ cwd=str(self.build_dir),
+ env=self.launch_environ.environ.environ,
+ stdout=self.logger.logTxtFile,
+ stderr=subprocess.STDOUT,
+ )
self.put_txt_log_in_appli_log_dir("makecheck")
if res == 0:
return res
else:
return 1
-
+
##
# Performs a default build for this module.
- def do_default_build(self,
- build_conf_options="",
- configure_options="",
- show_warning=True):
+ def do_default_build(
+ self, build_conf_options="", configure_options="", show_warning=True
+ ):
use_autotools = False
- if 'use_autotools' in self.product_info:
+ if "use_autotools" in self.product_info:
uc = self.product_info.use_autotools
- if uc in ['always', 'yes']:
+ if uc in ["always", "yes"]:
use_autotools = True
- elif uc == 'option':
+ elif uc == "option":
use_autotools = self.options.autotools
-
self.use_autotools = use_autotools
use_ctest = False
- if 'use_ctest' in self.product_info:
+ if "use_ctest" in self.product_info:
uc = self.product_info.use_ctest
- if uc in ['always', 'yes']:
+ if uc in ["always", "yes"]:
use_ctest = True
- elif uc == 'option':
+ elif uc == "option":
use_ctest = self.options.ctest
self.use_ctest = use_ctest
if show_warning:
cmd = ""
- if use_autotools: cmd = "(autotools)"
- if use_ctest: cmd = "(ctest)"
-
+ if use_autotools:
+ cmd = "(autotools)"
+ if use_ctest:
+ cmd = "(ctest)"
+
self.log("\n", 4, False)
- self.log("%(module)s: Run default compilation method %(cmd)s\n" % \
- { "module": self.module, "cmd": cmd }, 4)
+ self.log(
+ "%(module)s: Run default compilation method %(cmd)s\n"
+ % {"module": self.module, "cmd": cmd},
+ 4,
+ )
if use_autotools:
- if not self.prepare(): return self.get_result()
- if not self.build_configure(
- build_conf_options): return self.get_result()
- if not self.configure(configure_options): return self.get_result()
- if not self.make(): return self.get_result()
- if not self.install(): return self.get_result()
- if not self.clean(): return self.get_result()
-
- else: # CMake
- if self.config.VARS.dist_name=='Win':
- if not self.wprepare(): return self.get_result()
- if not self.cmake(): return self.get_result()
- if not self.wmake(): return self.get_result()
- if not self.install(): return self.get_result()
- if not self.clean(): return self.get_result()
- else :
- if not self.prepare(): return self.get_result()
- if not self.cmake(): return self.get_result()
- if not self.make(): return self.get_result()
- if not self.install(): return self.get_result()
- if not self.clean(): return self.get_result()
+ if not self.prepare():
+ return self.get_result()
+ if not self.build_configure(build_conf_options):
+ return self.get_result()
+ if not self.configure(configure_options):
+ return self.get_result()
+ if not self.make():
+ return self.get_result()
+ if not self.install():
+ return self.get_result()
+ if not self.clean():
+ return self.get_result()
+
+ else: # CMake
+ if self.config.VARS.dist_name == "Win":
+ if not self.wprepare():
+ return self.get_result()
+ if not self.cmake():
+ return self.get_result()
+ if not self.wmake():
+ return self.get_result()
+ if not self.install():
+ return self.get_result()
+ if not self.clean():
+ return self.get_result()
+ else:
+ if not self.prepare():
+ return self.get_result()
+ if not self.cmake():
+ return self.get_result()
+ if not self.make():
+ return self.get_result()
+ if not self.install():
+ return self.get_result()
+ if not self.clean():
+ return self.get_result()
return self.get_result()
# Performs a build with a script.
def do_python_script_build(self, script, nb_proc):
# script found
- self.logger.write(_("Compile %(product)s using script %(script)s\n") % \
- { 'product': self.product_info.name,
- 'script': src.printcolors.printcLabel(script) }, 4)
+ self.logger.write(
+ _("Compile %(product)s using script %(script)s\n")
+ % {
+ "product": self.product_info.name,
+ "script": src.printcolors.printcLabel(script),
+ },
+ 4,
+ )
try:
import imp
+
product = self.product_info.name
pymodule = imp.load_source(product + "_compile_script", script)
self.nb_proc = nb_proc
__, exceptionValue, exceptionTraceback = sys.exc_info()
self.logger.write(str(exceptionValue), 1)
import traceback
+
traceback.print_tb(exceptionTraceback)
traceback.print_exc()
retcode = 1
def complete_environment(self, make_options):
assert self.build_environ is not None
- # pass additional variables to environment
+ # pass additional variables to environment
# (may be used by the build script)
self.build_environ.set("APPLICATION_NAME", self.config.APPLICATION.name)
self.build_environ.set("SOURCE_DIR", str(self.source_dir))
self.build_environ.set("DIST_VERSION", self.config.VARS.dist_version)
self.build_environ.set("DIST", self.config.VARS.dist)
self.build_environ.set("VERSION", self.product_info.version)
- # if product is in hpc mode, set SAT_HPC to 1
+ # if product is in hpc mode, set SAT_HPC to 1
# in order for the compilation script to take it into account
if src.product.product_is_hpc(self.product_info):
self.build_environ.set("SAT_HPC", "1")
if self.verbose_mode:
self.build_environ.set("SAT_VERBOSE", "1")
-
def do_batch_script_build(self, script, nb_proc):
if src.architecture.is_windows():
make_options = "/maxcpucount:%s" % nb_proc
- else :
+ else:
make_options = "-j%s" % nb_proc
self.log_command(" " + _("Run build script %s\n") % script)
self.complete_environment(make_options)
-
- res = subprocess.call(script,
- shell=True,
- stdout=self.logger.logTxtFile,
- stderr=subprocess.STDOUT,
- cwd=str(self.build_dir),
- env=self.build_environ.environ.environ)
-
- res_check=self.check_install()
- if res_check > 0 :
- self.log_command("Error in sat check install - some files are not installed!")
+
+ res = subprocess.call(
+ script,
+ shell=True,
+ stdout=self.logger.logTxtFile,
+ stderr=subprocess.STDOUT,
+ cwd=str(self.build_dir),
+ env=self.build_environ.environ.environ,
+ )
+
+ res_check = self.check_install()
+ if res_check > 0:
+ self.log_command(
+ "Error in sat check install - some files are not installed!"
+ )
self.put_txt_log_in_appli_log_dir("script")
res += res_check
return res
else:
return 1
-
+
def do_script_build(self, script, number_of_proc=0):
# define make options (may not be used by the script)
- if number_of_proc==0:
- nb_proc = src.get_cfg_param(self.product_info,"nb_proc", 0)
- if nb_proc == 0:
+ if number_of_proc == 0:
+ nb_proc = src.get_cfg_param(self.product_info, "nb_proc", 0)
+ if nb_proc == 0:
nb_proc = self.config.VARS.nb_proc
else:
nb_proc = min(number_of_proc, self.config.VARS.nb_proc)
-
- extension = script.split('.')[-1]
- if extension in ["bat","sh"]:
+
+ extension = script.split(".")[-1]
+ if extension in ["bat", "sh"]:
return self.do_batch_script_build(script, nb_proc)
if extension == "py":
return self.do_python_script_build(script, nb_proc)
-
+
msg = _("The script %s must have .sh, .bat or .py extension." % script)
raise src.SatException(msg)
-
+
def put_txt_log_in_appli_log_dir(self, file_name):
- '''Put the txt log (that contain the system logs, like make command
+ """Put the txt log (that contain the system logs, like make command
output) in the directory <APPLICATION DIR>/LOGS/<product_name>/
-
+
:param file_name Str: the name of the file to write
- '''
+ """
if self.logger.logTxtFile == sys.__stdout__:
return
- dir_where_to_put = os.path.join(self.config.APPLICATION.workdir,
- "LOGS",
- self.product_info.name)
+ dir_where_to_put = os.path.join(
+ self.config.APPLICATION.workdir, "LOGS", self.product_info.name
+ )
file_path = os.path.join(dir_where_to_put, file_name)
src.ensure_path_exists(dir_where_to_put)
- # write the logTxtFile copy it to the destination, and then recreate
+ # write the logTxtFile copy it to the destination, and then recreate
# it as it was
self.logger.logTxtFile.close()
shutil.move(self.logger.txtFilePath, file_path)
- self.logger.logTxtFile = open(str(self.logger.txtFilePath), 'w')
+ self.logger.logTxtFile = open(str(self.logger.txtFilePath), "w")
self.logger.logTxtFile.write(open(file_path, "r").read())
-
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2018 CEA/DEN
#
except ImportError:
from io import StringIO
-_debug = [False] #support push/pop for temporary activate debug outputs
+_debug = [False] # support push/pop for temporary activate debug outputs
def isDeveloper():
else:
return False
-def indent(text, amount=2, ch=' '):
+
+def indent(text, amount=2, ch=" "):
"""indent multi lines message"""
padding = amount * ch
- return ''.join(padding + line for line in text.splitlines(True))
+ return "".join(padding + line for line in text.splitlines(True))
+
def isTypeConfig(var):
"""To know if var is instance from Config/pyconf"""
typ = str(type(var))
# print "isTypeConfig" ,type, dir(var)
- if ".pyconf.Config" in typ: return True
- if ".pyconf.Mapping" in typ: return True
- if ".pyconf.Sequence" in typ: return True
+ if ".pyconf.Config" in typ:
+ return True
+ if ".pyconf.Mapping" in typ:
+ return True
+ if ".pyconf.Sequence" in typ:
+ return True
# print "NOT isTypeConfig %s" % typ
return False
-
+
+
def write(title, var="", force=None, fmt=" %s:\n%s\n####\n"):
"""write sys.stderr a message if _debug[-1]==True or optionaly force=True"""
if _debug[-1] or force:
- callerframerecord = inspect.stack()[1] # get info of the caller
- frame = callerframerecord[0]
- info = inspect.getframeinfo(frame)
- sys.stderr.write("\n#### DEBUG - %s:%s (%s) ####\n" % (info.filename, info.lineno, info.function))
- tvar = type(var)
- typ = str(tvar)
- if isTypeConfig(var):
- sys.stderr.write(fmt % (title, indent(getStrConfigDbg(var))))
- return
- if 'UnittestStream' in typ:
- sys.stderr.write(fmt % (title, indent(var.getLogs())))
- return
- if tvar is not str and tvar is not unicode:
- sys.stderr.write(fmt % (title, indent(PP.pformat(var))))
+ callerframerecord = inspect.stack()[1] # get info of the caller
+ frame = callerframerecord[0]
+ info = inspect.getframeinfo(frame)
+ sys.stderr.write(
+ "\n#### DEBUG - %s:%s (%s) ####\n"
+ % (info.filename, info.lineno, info.function)
+ )
+ tvar = type(var)
+ typ = str(tvar)
+ if isTypeConfig(var):
+ sys.stderr.write(fmt % (title, indent(getStrConfigDbg(var))))
+ return
+ if "UnittestStream" in typ:
+ sys.stderr.write(fmt % (title, indent(var.getLogs())))
+ return
+ if tvar is not str and tvar is not unicode:
+ sys.stderr.write(fmt % (title, indent(PP.pformat(var))))
+ return
+ sys.stderr.write(fmt % (title, indent(var)))
return
- sys.stderr.write(fmt % (title, indent(var)))
- return
return
+
def tofix(title, var="", force=None):
"""
write sys.stderr a message if _debug[-1]==True or optionaly force=True
use this only if no logger accessible for classic logger.warning(message)
"""
if _debug[-1] or isDeveloper():
- callerframerecord = inspect.stack()[1] # get info of the caller
+ callerframerecord = inspect.stack()[1] # get info of the caller
frame = callerframerecord[0]
info = inspect.getframeinfo(frame)
- fmt = "#### TOFIX - " + str(info.filename) + ":" + str(info.lineno) +\
- " (" + str(info.function) + ") ####\n %s:\n%s\n"
+ fmt = (
+ "#### TOFIX - "
+ + str(info.filename)
+ + ":"
+ + str(info.lineno)
+ + " ("
+ + str(info.function)
+ + ") ####\n %s:\n%s\n"
+ )
write(title, var, force, fmt)
+
def push_debug(aBool):
"""set debug outputs activated, or not"""
_debug.append(aBool)
+
def pop_debug():
"""restore previous debug outputs status"""
if len(_debug) > 1:
def format_exception(msg, limit=None, trace=None):
- """
- Format a stack trace and the exception information.
- as traceback.format_exception(), without color
- with traceback only if (_debug) or (DBG.isDeveloper())
- """
- etype, value, tb = sys.exc_info()
- res = msg
- if tb:
- res += "\nTraceback (most recent call last):\n"
- res += "".join(traceback.format_tb(tb, limit)) # [:-1])
- res += "\n"
- res += "\n".join(traceback.format_exception_only(etype, value))
- return res
-
-def format_color_exception(msg, limit=None, trace=None):
- """
- Format a stack trace and the exception information.
- as traceback.format_exception(), with color
- with traceback only if _debug or isDeveloper())
- """
- etype, value, tb = sys.exc_info()
- if _debug[-1] or isDeveloper():
- res = "<red>" + msg
+ """
+ Format a stack trace and the exception information.
+ as traceback.format_exception(), without color
+ with traceback only if (_debug) or (DBG.isDeveloper())
+ """
+ etype, value, tb = sys.exc_info()
+ res = msg
if tb:
- res += "<yellow>\nTraceback (most recent call last):\n"
- res += "".join(traceback.format_tb(tb, limit)) # [:-1])
- res += "\n<red>"
+ res += "\nTraceback (most recent call last):\n"
+ res += "".join(traceback.format_tb(tb, limit)) # [:-1])
+ res += "\n"
res += "\n".join(traceback.format_exception_only(etype, value))
- return res + "<reset>"
- else:
- res = "<red>" + msg # + "<bright>"
- res += "".join(traceback.format_exception_only(etype, value))
- return res + "<reset>"
+ return res
+
+
+def format_color_exception(msg, limit=None, trace=None):
+ """
+ Format a stack trace and the exception information.
+ as traceback.format_exception(), with color
+ with traceback only if _debug or isDeveloper())
+ """
+ etype, value, tb = sys.exc_info()
+ if _debug[-1] or isDeveloper():
+ res = "<red>" + msg
+ if tb:
+ res += "<yellow>\nTraceback (most recent call last):\n"
+ res += "".join(traceback.format_tb(tb, limit)) # [:-1])
+ res += "\n<red>"
+ res += "\n".join(traceback.format_exception_only(etype, value))
+ return res + "<reset>"
+ else:
+ res = "<red>" + msg # + "<bright>"
+ res += "".join(traceback.format_exception_only(etype, value))
+ return res + "<reset>"
###############################################
# utilitaires divers pour debug
###############################################
+
class OutStream(StringIO):
"""
utility class for pyconf.Config output iostream
"""
+
def close(self):
- """
- because Config.__save__ calls close() stream as file
- keep value before lost as self.value
- """
- self.value = self.getvalue()
- StringIO.close(self)
-
+ """
+ because Config.__save__ calls close() stream as file
+ keep value before lost as self.value
+ """
+ self.value = self.getvalue()
+ StringIO.close(self)
+
+
class InStream(StringIO):
"""utility class for pyconf.Config input iostream"""
+
pass
+
def getLocalEnv():
"""get string for environment variables representation"""
res = ""
res += "%s : %s\n" % (i, os.environ[i])
return res
-# save as initial Config.save() moved as Config.__save__()
+
+# save as initial Config.save() moved as Config.__save__()
def saveConfigStd(config, aStream):
"""returns as file .pyconf"""
- indent = 0
- config.__save__(aStream, indent)
+ indent = 0
+ config.__save__(aStream, indent)
+
def getStrConfigStd(config):
"""set string as saveConfigStd, as file .pyconf"""
saveConfigStd(config, outStream)
return outStream.value
+
def getStrConfigDbg(config):
"""
- set string as saveConfigDbg,
+ set string as saveConfigDbg,
as (path expression evaluation) for debug
"""
outStream = OutStream()
saveConfigDbg(config, outStream)
return outStream.value
+
def saveConfigDbg(config, aStream, indent=0, path=""):
"""pyconf returns multilines (path expression evaluation) for debug"""
_saveConfigRecursiveDbg(config, aStream, indent, path, 0)
- aStream.close() # as config.__save__()
+ aStream.close() # as config.__save__()
+
def _saveConfigRecursiveDbg(config, aStream, indent, path, nb):
"""pyconf inspired from Mapping.__save__"""
debug = False
- nbp = nb + 1 # depth recursive
- if indent <= 0:
- indentp = 0
+ nbp = nb + 1 # depth recursive
+ if indent <= 0:
+ indentp = 0
else:
- indentp = indent + 2
-
- if nbp > 10: # protection
- # raise Exception("!!! ERROR: Circular reference after %s" % aStream.getvalue())
- # raise Exception("!!! ERROR: Circular reference %s" % path)
- aStream.write("<red>!!! ERROR: Circular reference after %s<reset>\n" % path)
- return
-
- indstr = indent * ' ' # '':no indent, ' ':indent
+ indentp = indent + 2
+
+ if nbp > 10: # protection
+ # raise Exception("!!! ERROR: Circular reference after %s" % aStream.getvalue())
+ # raise Exception("!!! ERROR: Circular reference %s" % path)
+ aStream.write("<red>!!! ERROR: Circular reference after %s<reset>\n" % path)
+ return
+
+ indstr = indent * " " # '':no indent, ' ':indent
strType = str(type(config))
- if debug: print("saveDbg Type %s %s" % (path, strType))
-
+ if debug:
+ print("saveDbg Type %s %s" % (path, strType))
+
if "Sequence" in strType:
- for i in range(len(config)):
- _saveConfigRecursiveDbg(config[i], aStream, indentp, path+"[%i]" % i, nbp)
- return
- '''
+ for i in range(len(config)):
+ _saveConfigRecursiveDbg(config[i], aStream, indentp, path + "[%i]" % i, nbp)
+ return
+ """
if "Reference" in strType:
try:
#evaluate = value.resolve(config)
except Exception as e:
aStream.write("<header>%s%s<reset> : <red>!!! ERROR: %s !!!<reset>\n" % (indstr, path, str(e)))
return
- '''
-
- try: #type config, mapping
- order = object.__getattribute__(config, 'order')
- data = object.__getattribute__(config, 'data')
+ """
+
+ try: # type config, mapping
+ order = object.__getattribute__(config, "order")
+ data = object.__getattribute__(config, "data")
except:
- aStream.write("%s%s : '%s'\n" % (indstr, path, str(config)))
- return
- for key in sorted(data): #order): # data as sort alphabetical, order as initial order
- value = data[key]
- strType = str(type(value))
- if debug: print('strType %s %s %s' % (path, key, strType))
- if "Config" in strType:
- _saveConfigRecursiveDbg(value, aStream, indentp, path+"."+key, nbp)
- continue
- if "Mapping" in strType:
- _saveConfigRecursiveDbg(value, aStream, indentp, path+"."+key, nbp)
- continue
- if "Sequence" in strType:
- for i in range(len(value)):
- _saveConfigRecursiveDbg(value.data[i], aStream, indentp, path+"."+key+"[%i]" % i, nbp)
- continue
- if "Expression" in strType:
- try:
- evaluate = value.evaluate(config)
- aStream.write("%s%s.%s : %s --> '%s'\n" % (indstr, path, key, str(value), evaluate))
- except Exception as e:
- aStream.write("%s%s.%s : !!! ERROR: %s !!!\n" % (indstr, path, key, str(e)))
- continue
- if "Reference" in strType:
+ aStream.write("%s%s : '%s'\n" % (indstr, path, str(config)))
+ return
+ for key in sorted(
+ data
+ ): # order): # data as sort alphabetical, order as initial order
+ value = data[key]
+ strType = str(type(value))
+ if debug:
+ print("strType %s %s %s" % (path, key, strType))
+ if "Config" in strType:
+ _saveConfigRecursiveDbg(value, aStream, indentp, path + "." + key, nbp)
+ continue
+ if "Mapping" in strType:
+ _saveConfigRecursiveDbg(value, aStream, indentp, path + "." + key, nbp)
+ continue
+ if "Sequence" in strType:
+ for i in range(len(value)):
+ _saveConfigRecursiveDbg(
+ value.data[i], aStream, indentp, path + "." + key + "[%i]" % i, nbp
+ )
+ continue
+ if "Expression" in strType:
+ try:
+ evaluate = value.evaluate(config)
+ aStream.write(
+ "%s%s.%s : %s --> '%s'\n"
+ % (indstr, path, key, str(value), evaluate)
+ )
+ except Exception as e:
+ aStream.write(
+ "%s%s.%s : !!! ERROR: %s !!!\n" % (indstr, path, key, str(e))
+ )
+ continue
+ if "Reference" in strType:
+ try:
+ evaluate = value.resolve(config)
+ aStream.write(
+ "%s%s.%s : %s --> '%s'\n"
+ % (indstr, path, key, str(value), evaluate)
+ )
+ except Exception as e:
+ aStream.write(
+ "%s%s.%s : !!! ERROR: %s !!!\n" % (indstr, path, key, str(e))
+ )
+ continue
+ if type(value) in [str, bool, int, type(None), unicode]:
+ aStream.write("%s%s.%s : '%s'\n" % (indstr, path, key, str(value)))
+ continue
try:
- evaluate = value.resolve(config)
- aStream.write("%s%s.%s : %s --> '%s'\n" % (indstr, path, key, str(value), evaluate))
- except Exception as e:
- aStream.write("%s%s.%s : !!! ERROR: %s !!!\n" % (indstr, path, key, str(e)))
- continue
- if type(value) in [str, bool, int, type(None), unicode]:
- aStream.write("%s%s.%s : '%s'\n" % (indstr, path, key, str(value)))
- continue
- try:
- aStream.write("!!! TODO fix that %s %s%s.%s : %s\n" % (type(value), indstr, path, key, str(value)))
- except Exception as e:
- aStream.write("%s%s.%s : !!! %s\n" % (indstr, path, key, str(e)))
+ aStream.write(
+ "!!! TODO fix that %s %s%s.%s : %s\n"
+ % (type(value), indstr, path, key, str(value))
+ )
+ except Exception as e:
+ aStream.write("%s%s.%s : !!! %s\n" % (indstr, path, key, str(e)))
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2013 CEA/DEN
#
# This library is free software; you can redistribute it and/or
"""\
Class to manage the environment context
"""
+
def __init__(self, environ=None):
"""Initialization. If the environ argument is passed, the environment
will be add to it, else it is the external environment.
-
- :param environ dict:
+
+ :param environ dict:
"""
if environ is not None:
self.environ = environ
else:
delim = "$"
if delim in value:
- # The string.Template class is a string class
+ # The string.Template class is a string class
# for supporting $-substitutions
zt = string.Template(value)
zt.delimiter = delim
value = zt.substitute(self.environ)
except KeyError as exc:
pass
- #raise src.SatException(_("Missing definition "
+ # raise src.SatException(_("Missing definition "
# "in environment: %s") % str(exc))
return value
:param sep str: the separator string
"""
# check that value so no contain the system separator
- separator=os.pathsep
+ separator = os.pathsep
if separator in value:
- raise Exception("Environ append key '%s' value '%s' contains forbidden character '%s'" % (key, value, separator))
+ raise Exception(
+ "Environ append key '%s' value '%s' contains forbidden character '%s'"
+ % (key, value, separator)
+ )
# check if the key is already in the environment
if key in self.environ:
:param sep str: the separator string
"""
# check that value so no contain the system separator
- separator=os.pathsep
+ separator = os.pathsep
if separator in value:
- raise Exception("Environ append key '%s' value '%s' contains forbidden character '%s'" % (key, value, separator))
+ raise Exception(
+ "Environ append key '%s' value '%s' contains forbidden character '%s'"
+ % (key, value, separator)
+ )
# check if the key is already in the environment
if key in self.environ:
:param sep str: the separator string
"""
if isinstance(value, list):
- for v in reversed(value): # prepend list, first item at last to stay first
+ for v in reversed(value): # prepend list, first item at last to stay first
self.prepend_value(key, v, sep)
else:
self.prepend_value(key, value, sep)
return self.get(key)
-
class SalomeEnviron:
"""\
Class to manage the environment of SALOME.
"""
- def __init__(self,
- cfg,
- environ,
- forBuild=False,
- for_package=None,
- enable_simple_env_script = True):
+
+ def __init__(
+ self,
+ cfg,
+ environ,
+ forBuild=False,
+ for_package=None,
+ enable_simple_env_script=True,
+ ):
"""\
Initialization.
def __repr__(self):
"""easy almost exhaustive quick resume for debug print"""
res = {
- "environ" : self.environ,
- "forBuild" : self.forBuild,
- "for_package" : self.for_package,
+ "environ": self.environ,
+ "forBuild": self.forBuild,
+ "for_package": self.for_package,
}
return "%s(\n%s\n)" % (self.__class__.__name__, PP.pformat(res))
def __set_sorted_products_list(self):
all_products_infos = src.product.get_products_infos(
- self.cfg.APPLICATION.products,
- self.cfg)
-
- from compile import get_dependencies_graph,depth_first_topo_graph
- all_products_graph=get_dependencies_graph(all_products_infos, self.forBuild)
- visited_nodes=[]
- sorted_nodes=[]
+ self.cfg.APPLICATION.products, self.cfg
+ )
+
+ from compile import get_dependencies_graph, depth_first_topo_graph
+
+ all_products_graph = get_dependencies_graph(all_products_infos, self.forBuild)
+ visited_nodes = []
+ sorted_nodes = []
for n in all_products_graph:
if n not in visited_nodes:
- visited_nodes,sorted_nodes=depth_first_topo_graph(
- all_products_graph,
- n,
- visited_nodes,
- sorted_nodes)
- self.sorted_product_list=sorted_nodes
- self.all_products_graph=all_products_graph
-
+ visited_nodes, sorted_nodes = depth_first_topo_graph(
+ all_products_graph, n, visited_nodes, sorted_nodes
+ )
+ self.sorted_product_list = sorted_nodes
+ self.all_products_graph = all_products_graph
def append(self, key, value, sep=os.pathsep):
"""\
"""
# check if value needs to be evaluated
if value is not None and value.startswith("`") and value.endswith("`"):
- res = subprocess.Popen("echo %s" % value,
- shell=True,
- stdout=subprocess.PIPE).communicate()
+ res = subprocess.Popen(
+ "echo %s" % value, shell=True, stdout=subprocess.PIPE
+ ).communicate()
value = res[0].strip()
return self.environ.set(key, value)
:param nb_line int: the number of empty lines to add
"""
- if 'add_line' in dir(self.environ):
+ if "add_line" in dir(self.environ):
self.environ.add_line(nb_line)
def add_comment(self, comment):
:param comment str: the commentary to add
"""
- if 'add_comment' in dir(self.environ):
+ if "add_comment" in dir(self.environ):
self.environ.add_comment(comment)
def add_warning(self, warning):
:param warning str: the warning to add
"""
- if 'add_warning' in dir(self.environ):
+ if "add_warning" in dir(self.environ):
self.environ.add_warning(warning)
def finish(self):
:param required bool: Do nothing if required is False
"""
- if 'finish' in dir(self.environ):
+ if "finish" in dir(self.environ):
self.environ.add_line(1)
# what for ?
# self.environ.add_comment("clean all the path")
def set_python_libdirs(self):
"""Set some generic variables for python library paths"""
- ver = self.get('PYTHON_VERSION')
- self.set('PYTHON_LIBDIR', os.path.join('lib',
- 'python' + ver,
- 'site-packages'))
- self.python_lib = self.get('PYTHON_LIBDIR')
+ ver = self.get("PYTHON_VERSION")
+ self.set("PYTHON_LIBDIR", os.path.join("lib", "python" + ver, "site-packages"))
+ self.python_lib = self.get("PYTHON_LIBDIR")
self.has_python = True
def set_application_env(self, logger):
:param logger Logger: The logger instance to display messages
"""
-
+
if self.for_package:
- if src.architecture.is_windows():
- self.set("PRODUCT_ROOT_DIR", "%out_dir_Path%")
- else:
- self.set("PRODUCT_ROOT_DIR", "out_dir_Path")
+ if src.architecture.is_windows():
+ self.set("PRODUCT_ROOT_DIR", "%out_dir_Path%")
+ else:
+ self.set("PRODUCT_ROOT_DIR", "out_dir_Path")
else:
- self.cfg.APPLICATION.environ.PRODUCT_ROOT_DIR = src.pyconf.Reference(self.cfg, src.pyconf.DOLLAR, "workdir")
-
+ self.cfg.APPLICATION.environ.PRODUCT_ROOT_DIR = src.pyconf.Reference(
+ self.cfg, src.pyconf.DOLLAR, "workdir"
+ )
# Set the variables defined in the "environ" section
- if 'environ' in self.cfg.APPLICATION:
- # we write PRODUCT environment it in order to conform to
+ if "environ" in self.cfg.APPLICATION:
+ # we write PRODUCT environment it in order to conform to
# parseConfigFile.py
- self.add_comment("PRODUCT environment")
+ self.add_comment("PRODUCT environment")
self.load_cfg_environment(self.cfg.APPLICATION.environ)
if self.forBuild and "build" in self.cfg.APPLICATION.environ:
self.load_cfg_environment(self.cfg.APPLICATION.environ.build)
self.load_cfg_environment(self.cfg.APPLICATION.environ.launch)
self.add_line(1)
-
def set_salome_minimal_product_env(self, product_info, logger):
"""\
Sets the minimal environment for a SALOME product.
# set root dir
root_dir = product_info.name + "_ROOT_DIR"
-
+
if src.product.product_is_configuration(product_info):
# configuration modules are not installed, root_dir points at source dir
if not self.for_package:
self.set(root_dir, product_info.source_dir)
else:
- self.set(root_dir, os.path.join("out_dir_Path",
- "SOURCES",
- os.path.basename(product_info.source_dir)))
- elif 'install_dir' in product_info and product_info.install_dir:
+ self.set(
+ root_dir,
+ os.path.join(
+ "out_dir_Path",
+ "SOURCES",
+ os.path.basename(product_info.source_dir),
+ ),
+ )
+ elif "install_dir" in product_info and product_info.install_dir:
self.set(root_dir, product_info.install_dir)
elif not self.silent:
- logger.write(" " + _("No install_dir for product %s\n") %
- product_info.name, 5)
-
- source_in_package = src.get_property_in_product_cfg(product_info,
- "sources_in_package")
+ logger.write(
+ " " + _("No install_dir for product %s\n") % product_info.name, 5
+ )
+
+ source_in_package = src.get_property_in_product_cfg(
+ product_info, "sources_in_package"
+ )
if not self.for_package or source_in_package == "yes":
# set source dir, unless no source dir
if not src.product.product_is_fixed(product_info):
if not self.for_package:
self.set(src_dir, product_info.source_dir)
else:
- self.set(src_dir, os.path.join("out_dir_Path",
- "SOURCES",
- os.path.basename(product_info.source_dir)))
+ self.set(
+ src_dir,
+ os.path.join(
+ "out_dir_Path",
+ "SOURCES",
+ os.path.basename(product_info.source_dir),
+ ),
+ )
def expand_salome_modules(self, pi):
- if 'component_name' in pi:
+ if "component_name" in pi:
compo_name = pi.component_name
else:
compo_name = pi.name
- self.append('SALOME_MODULES', compo_name, ',')
-
-
+ self.append("SALOME_MODULES", compo_name, ",")
+
def set_salome_generic_product_env(self, pi):
"""\
Sets the generic environment for a SALOME product.
env_root_dir = self.get(pi.name + "_ROOT_DIR")
l_binpath_libpath = []
# create additional ROOT_DIR for CPP components
- if 'component_name' in pi:
+ if "component_name" in pi:
compo_name = pi.component_name
if compo_name + "CPP" == pi.name:
compo_root_dir = compo_name + "_ROOT_DIR"
envcompo_root_dir = os.path.join(
- self.cfg.TOOLS.common.install_root, compo_name )
- self.set(compo_root_dir , envcompo_root_dir)
- bin_path = os.path.join(envcompo_root_dir, 'bin', 'salome')
- lib_path = os.path.join(envcompo_root_dir, 'lib', 'salome')
- l_binpath_libpath.append( (bin_path, lib_path) )
-
+ self.cfg.TOOLS.common.install_root, compo_name
+ )
+ self.set(compo_root_dir, envcompo_root_dir)
+ bin_path = os.path.join(envcompo_root_dir, "bin", "salome")
+ lib_path = os.path.join(envcompo_root_dir, "lib", "salome")
+ l_binpath_libpath.append((bin_path, lib_path))
if src.get_property_in_product_cfg(pi, "fhs"):
- lib_path = os.path.join(env_root_dir, 'lib')
- bin_path = os.path.join(env_root_dir, 'bin')
+ lib_path = os.path.join(env_root_dir, "lib")
+ bin_path = os.path.join(env_root_dir, "bin")
if self.has_python:
- # if the application doesn't include python, we don't need these two lines
+ # if the application doesn't include python, we don't need these two lines
pylib_path = os.path.join(env_root_dir, self.python_lib)
else:
- lib_path = os.path.join(env_root_dir, 'lib', 'salome')
- bin_path = os.path.join(env_root_dir, 'bin', 'salome')
+ lib_path = os.path.join(env_root_dir, "lib", "salome")
+ bin_path = os.path.join(env_root_dir, "bin", "salome")
if self.has_python:
- # if the application doesn't include python, we don't need these two lines
- pylib_path = os.path.join(env_root_dir, self.python_lib, 'salome')
+ # if the application doesn't include python, we don't need these two lines
+ pylib_path = os.path.join(env_root_dir, self.python_lib, "salome")
- # Construct the paths to prepend to PATH and LD_LIBRARY_PATH and
+ # Construct the paths to prepend to PATH and LD_LIBRARY_PATH and
# PYTHONPATH
- l_binpath_libpath.append( (bin_path, lib_path) )
+ l_binpath_libpath.append((bin_path, lib_path))
for bin_path, lib_path in l_binpath_libpath:
if not self.forBuild:
- self.prepend('PATH', bin_path)
+ self.prepend("PATH", bin_path)
if src.architecture.is_windows():
- self.prepend('PATH', lib_path)
- else :
- self.prepend('LD_LIBRARY_PATH', lib_path)
+ self.prepend("PATH", lib_path)
+ else:
+ self.prepend("LD_LIBRARY_PATH", lib_path)
- l = [ bin_path, lib_path ]
+ l = [bin_path, lib_path]
if not src.product.product_is_wheel(pi):
if self.has_python:
l.append(pylib_path)
- self.prepend('PYTHONPATH', l)
+ self.prepend("PYTHONPATH", l)
def set_cpp_env(self, product_info):
"""\
env_root_dir = self.get(product_info.name + "_ROOT_DIR")
l_binpath_libpath = []
- # Construct the paths to prepend to PATH and LD_LIBRARY_PATH and
+ # Construct the paths to prepend to PATH and LD_LIBRARY_PATH and
# PYTHONPATH
- bin_path = os.path.join(env_root_dir, 'bin')
- lib_path = os.path.join(env_root_dir, 'lib')
- l_binpath_libpath.append( (bin_path, lib_path) )
+ bin_path = os.path.join(env_root_dir, "bin")
+ lib_path = os.path.join(env_root_dir, "lib")
+ l_binpath_libpath.append((bin_path, lib_path))
for bin_path, lib_path in l_binpath_libpath:
if not self.forBuild:
- self.prepend('PATH', bin_path)
+ self.prepend("PATH", bin_path)
if src.architecture.is_windows():
- self.prepend('PATH', lib_path)
- else :
- self.prepend('LD_LIBRARY_PATH', lib_path)
+ self.prepend("PATH", lib_path)
+ else:
+ self.prepend("LD_LIBRARY_PATH", lib_path)
- l = [ bin_path, lib_path ]
+ l = [bin_path, lib_path]
if self.has_python:
l.append(os.path.join(env_root_dir, self.python_lib))
- self.prepend('PYTHONPATH', l)
+ self.prepend("PYTHONPATH", l)
def load_cfg_environment(self, cfg_env):
"""\
# Loop on cfg_env values
for env_def in cfg_env:
val = cfg_env[env_def]
-
+
# if it is env_script, do not do anything (reserved keyword)
if env_def == "env_script":
continue
-
+
# if it is a dict, do not do anything
if isinstance(val, src.pyconf.Mapping):
continue
# "_" means that the value must be prepended
if env_def.startswith("_"):
# separator exception for PV_PLUGIN_PATH
- if env_def[1:] == 'PV_PLUGIN_PATH':
- self.prepend(env_def[1:], val, ';')
+ if env_def[1:] == "PV_PLUGIN_PATH":
+ self.prepend(env_def[1:], val, ";")
else:
self.prepend(env_def[1:], val)
elif env_def.endswith("_"):
# separator exception for PV_PLUGIN_PATH
- if env_def[:-1] == 'PV_PLUGIN_PATH':
- self.append(env_def[:-1], val, ';')
+ if env_def[:-1] == "PV_PLUGIN_PATH":
+ self.append(env_def[:-1], val, ";")
else:
self.append(env_def[:-1], val)
else:
# Get the informations corresponding to the product
pi = src.product.get_product_config(self.cfg, product)
- # skip compile time products at run time
+ # skip compile time products at run time
if not self.forBuild:
if src.product.product_is_compile_time(pi):
return
else:
- if src.product.product_is_native(pi) :
- self.set("SAT_%s_IS_NATIVE"%pi.name, "1")
-
+ if src.product.product_is_native(pi):
+ self.set("SAT_%s_IS_NATIVE" % pi.name, "1")
- # skip pip products when pip is activated and installation is done in python
- #if (src.appli_test_property(self.cfg,"pip", "yes") and
+ # skip pip products when pip is activated and installation is done in python
+ # if (src.appli_test_property(self.cfg,"pip", "yes") and
# src.product.product_test_property(pi,"pip", "yes") and
# src.appli_test_property(self.cfg,"pip_install_dir", "python") ):
# return
- # skip mesa products (if any) at run time,
+ # skip mesa products (if any) at run time,
# unless use_mesa property was activated
if not self.forBuild:
- if not ("APPLICATION" in self.cfg and
- "properties" in self.cfg.APPLICATION and
- "use_mesa" in self.cfg.APPLICATION.properties and
- self.cfg.APPLICATION.properties.use_mesa == "yes") :
- if ("properties" in pi and
- "is_mesa" in pi.properties and
- pi.properties.is_mesa == "yes") :
+ if not (
+ "APPLICATION" in self.cfg
+ and "properties" in self.cfg.APPLICATION
+ and "use_mesa" in self.cfg.APPLICATION.properties
+ and self.cfg.APPLICATION.properties.use_mesa == "yes"
+ ):
+ if (
+ "properties" in pi
+ and "is_mesa" in pi.properties
+ and pi.properties.is_mesa == "yes"
+ ):
logger.write(_("Skip mesa product %s\n") % pi.name, 4)
return
-
-
+
if self.for_package:
- prod_base_name=os.path.basename(pi.install_dir)
+ prod_base_name = os.path.basename(pi.install_dir)
if prod_base_name.startswith("config"):
# case of a products installed in base. We remove "config-i"
- prod_base_name=os.path.basename(os.path.dirname(pi.install_dir))
+ prod_base_name = os.path.basename(os.path.dirname(pi.install_dir))
pi.install_dir = os.path.join(
- "out_dir_Path",
- self.for_package,
- prod_base_name)
+ "out_dir_Path", self.for_package, prod_base_name
+ )
if not self.silent:
logger.write(_("Setting environment for %s\n") % product, 4)
self.add_line(1)
- self.add_comment('setting environ for ' + product)
-
+ self.add_comment("setting environ for " + product)
+
# Do not define environment if the product is native
if src.product.product_is_native(pi):
if src.product.product_has_env_script(pi):
self.run_env_script(pi, native=True)
return
-
+
# Set an additional environment for SALOME products
if src.product.product_is_salome(pi):
# set environment using definition of the product
self.set_salome_minimal_product_env(pi, logger)
self.set_salome_generic_product_env(pi)
-
-
+
# Expand SALOME_MODULES variable for products which have a salome gui
if src.product.product_has_salome_gui(pi):
self.expand_salome_modules(pi)
# use variable LICENCE_FILE to communicate the licence file name to the environment script
- licence_file_name = src.product.product_has_licence(pi, self.cfg.PATHS.LICENCEPATH)
+ licence_file_name = src.product.product_has_licence(
+ pi, self.cfg.PATHS.LICENCEPATH
+ )
if licence_file_name:
- logger.write("licence file found for product %s : %s\n" % (pi.name, licence_file_name), 5)
+ logger.write(
+ "licence file found for product %s : %s\n"
+ % (pi.name, licence_file_name),
+ 5,
+ )
self.set("LICENCE_FILE", licence_file_name)
if src.product.product_is_cpp(pi):
# set a specific environment for cpp modules
self.set_salome_minimal_product_env(pi, logger)
self.set_cpp_env(pi)
-
+
if src.product.product_is_generated(pi):
if "component_name" in pi:
- # hack the source and install directories in order to point
+ # hack the source and install directories in order to point
# on the generated product source install directories
install_dir_save = pi.install_dir
source_dir_save = pi.source_dir
name_save = pi.name
- pi.install_dir = os.path.join(self.cfg.APPLICATION.workdir,
- self.cfg.INTERNAL.config.install_dir,
- pi.component_name)
+ pi.install_dir = os.path.join(
+ self.cfg.APPLICATION.workdir,
+ self.cfg.INTERNAL.config.install_dir,
+ pi.component_name,
+ )
if self.for_package:
- pi.install_dir = os.path.join("out_dir_Path",
- self.for_package,
- pi.component_name)
- pi.source_dir = os.path.join(self.cfg.APPLICATION.workdir,
- "GENERATED",
- pi.component_name)
+ pi.install_dir = os.path.join(
+ "out_dir_Path", self.for_package, pi.component_name
+ )
+ pi.source_dir = os.path.join(
+ self.cfg.APPLICATION.workdir, "GENERATED", pi.component_name
+ )
pi.name = pi.component_name
self.set_salome_minimal_product_env(pi, logger)
self.set_salome_generic_product_env(pi)
-
+
# Put original values
pi.install_dir = install_dir_save
pi.source_dir = source_dir_save
pi.name = name_save
-
+
# Put the environment define in the configuration of the product
if "environ" in pi:
self.load_cfg_environment(pi.environ)
if not self.forBuild and "launch" in pi.environ:
self.load_cfg_environment(pi.environ.launch)
# if product_info defines a env_scripts, load it
- if 'env_script' in pi.environ:
+ if "env_script" in pi.environ:
self.run_env_script(pi, logger)
-
-
-
def run_env_script(self, product_info, logger=None, native=False):
"""\
Runs an environment script.
env_script = product_info.environ.env_script
# Check that the script exists
if not os.path.exists(env_script):
- raise src.SatException(_("Environment script not found: %s") %
- env_script)
+ raise src.SatException(_("Environment script not found: %s") % env_script)
if not self.silent and logger is not None:
logger.write(" ** load %s\n" % env_script, 4)
# import the script and run the set_env function
try:
import imp
- pyproduct = imp.load_source(product_info.name + "_env_script",
- env_script)
+
+ pyproduct = imp.load_source(product_info.name + "_env_script", env_script)
if not native:
if self.forBuild and "set_env_build" in dir(pyproduct):
- pyproduct.set_env_build(self,
- product_info.install_dir,
- product_info.version)
+ pyproduct.set_env_build(
+ self, product_info.install_dir, product_info.version
+ )
elif (not self.forBuild) and "set_env_launch" in dir(pyproduct):
- pyproduct.set_env_launch(self,
- product_info.install_dir,
- product_info.version)
+ pyproduct.set_env_launch(
+ self, product_info.install_dir, product_info.version
+ )
else:
# at least this one is mandatory,
# if set_env_build and set_env_build are not defined
- pyproduct.set_env(self,
- product_info.install_dir,
- product_info.version)
+ pyproduct.set_env(
+ self, product_info.install_dir, product_info.version
+ )
else:
# not mandatory, if set_nativ_env not defined, we do nothing
if "set_nativ_env" in dir(pyproduct):
__, exceptionValue, exceptionTraceback = sys.exc_info()
print(exceptionValue)
import traceback
+
traceback.print_tb(exceptionTraceback)
traceback.print_exc()
:param src_root src: the application working directory
"""
self.add_line(1)
- self.add_comment('setting environ for all products')
+ self.add_comment("setting environ for all products")
# Make sure that the python lib dirs are set after python
if "Python" in self.sorted_product_list:
if product == "Python":
continue
self.set_a_product(product, logger)
-
+
def set_full_environ(self, logger, env_info):
"""\
Sets the full environment for products, with their dependencies
# set product environ
self.set_application_env(logger)
- # use the sorted list of all products to sort the list of products
+ # use the sorted list of all products to sort the list of products
# we have to set
- visited=[]
- from compile import depth_search_graph # to get the dependencies
+ visited = []
+ from compile import depth_search_graph # to get the dependencies
+
for p_name in env_info:
- visited=depth_search_graph(self.all_products_graph, p_name, visited)
- sorted_product_list=[]
+ visited = depth_search_graph(self.all_products_graph, p_name, visited)
+ sorted_product_list = []
for n in self.sorted_product_list:
if n in visited:
sorted_product_list.append(n)
continue
self.set_a_product(product, logger)
+
class FileEnvWriter:
"""\
Class to dump the environment to a file.
"""
+
def __init__(self, config, logger, out_dir, src_root, env_info=None):
"""\
Initialization.
self.config = config
self.logger = logger
self.out_dir = out_dir
- self.src_root= src_root
+ self.src_root = src_root
self.silent = True
self.env_info = env_info
- def write_tcl_files(self,
- forBuild,
- shell,
- for_package = None,
- no_path_init=False,
- additional_env = {}):
+ def write_tcl_files(
+ self, forBuild, shell, for_package=None, no_path_init=False, additional_env={}
+ ):
"""\
Create tcl environment files for environment module.
"""
# get the products informations
- all_products=self.config.APPLICATION.products
- products_infos = src.product.get_products_infos(all_products, self.config)
+ all_products = self.config.APPLICATION.products
+ products_infos = src.product.get_products_infos(all_products, self.config)
# set a global environment (we need it to resolve variable references
# between dependent products
- global_environ = src.environment.SalomeEnviron(self.config,
- src.environment.Environ(additional_env),
- False)
+ global_environ = src.environment.SalomeEnviron(
+ self.config, src.environment.Environ(additional_env), False
+ )
global_environ.set_products(self.logger)
-
+
# The loop on the products
for product in all_products:
# create one file per product
if "base" not in pi: # we write tcl files only for products in base
continue
- # get the global environment, and complete it with sat_ prefixed
- # prefixed variables which are used to transfer info to
- # TclFileEnviron class
+ # get the global environment, and complete it with sat_ prefixed
+ # prefixed variables which are used to transfer info to
+ # TclFileEnviron class
product_env = copy.deepcopy(global_environ.environ)
product_env.environ["sat_product_name"] = pi.name
product_env.environ["sat_product_version"] = pi.version
- product_env.environ["sat_product_base_path"] = src.get_base_path(self.config)
+ product_env.environ["sat_product_base_path"] = src.get_base_path(
+ self.config
+ )
product_env.environ["sat_product_base_name"] = pi.base
-
+
# store infos in sat_product_load_depend to set dependencies in tcl file
- sat_product_load_depend=""
- for p_name,p_info in products_infos:
+ sat_product_load_depend = ""
+ for p_name, p_info in products_infos:
if p_name in pi.depend:
- sat_product_load_depend+="module load %s/%s/%s;" % (pi.base,
- p_info.name,
- p_info.version)
- if len(sat_product_load_depend)>0:
+ sat_product_load_depend += "module load %s/%s/%s;" % (
+ pi.base,
+ p_info.name,
+ p_info.version,
+ )
+ if len(sat_product_load_depend) > 0:
# if there are dependencies, store the module to load (get rid of trailing ;)
- product_env.environ["sat_product_load_depend"]=sat_product_load_depend[0:-1]
-
-
- env_file_name = os.path.join(product_env.environ["sat_product_base_path"],
- "modulefiles",
- product_env.environ["sat_product_base_name"],
- product_env.environ["sat_product_name"],
- product_env.environ["sat_product_version"])
- prod_dir_name=os.path.dirname(env_file_name)
+ product_env.environ[
+ "sat_product_load_depend"
+ ] = sat_product_load_depend[0:-1]
+
+ env_file_name = os.path.join(
+ product_env.environ["sat_product_base_path"],
+ "modulefiles",
+ product_env.environ["sat_product_base_name"],
+ product_env.environ["sat_product_name"],
+ product_env.environ["sat_product_version"],
+ )
+ prod_dir_name = os.path.dirname(env_file_name)
if not os.path.isdir(prod_dir_name):
os.makedirs(prod_dir_name)
env_file = open(env_file_name, "w")
- file_environ = src.fileEnviron.get_file_environ(env_file,
- "tcl", product_env)
- env = SalomeEnviron(self.config,
- file_environ,
- False,
- for_package=for_package)
+ file_environ = src.fileEnviron.get_file_environ(
+ env_file, "tcl", product_env
+ )
+ env = SalomeEnviron(
+ self.config, file_environ, False, for_package=for_package
+ )
if "Python" in pi.depend:
# short cut, env.python_lib is required by set_a_product for salome modules
- env.has_python="True"
- env.python_lib=global_environ.get("PYTHON_LIBDIR")
+ env.has_python = "True"
+ env.python_lib = global_environ.get("PYTHON_LIBDIR")
env.set_a_product(product, self.logger)
env_file.close()
if not self.silent:
- self.logger.write(_(" Create tcl module environment file %s\n") %
- src.printcolors.printcLabel(env_file_name), 3)
-
-
- def write_env_file(self,
- filename,
- forBuild,
- shell,
- for_package = None,
- no_path_init=False,
- additional_env = {}):
+ self.logger.write(
+ _(" Create tcl module environment file %s\n")
+ % src.printcolors.printcLabel(env_file_name),
+ 3,
+ )
+
+ def write_env_file(
+ self,
+ filename,
+ forBuild,
+ shell,
+ for_package=None,
+ no_path_init=False,
+ additional_env={},
+ ):
"""\
Create an environment file.
:return: The path to the generated file
:rtype: str
"""
- additional_env["sat_dist"]=self.config.VARS.dist
+ additional_env["sat_dist"] = self.config.VARS.dist
if not self.silent:
- self.logger.write(_("Create environment file %s\n") %
- src.printcolors.printcLabel(filename), 3)
+ self.logger.write(
+ _("Create environment file %s\n")
+ % src.printcolors.printcLabel(filename),
+ 3,
+ )
# create then env object
env_file = open(os.path.join(self.out_dir, filename), "w")
# we duplicate additional_env, and transmit it to fileEnviron, which will use its sat_ prefixed variables.
# the other variables of additional_env are added to the environement file at the end of this function.
salome_env = copy.deepcopy(additional_env)
- file_environ = src.fileEnviron.get_file_environ(env_file,
- shell,
- src.environment.Environ(salome_env))
+ file_environ = src.fileEnviron.get_file_environ(
+ env_file, shell, src.environment.Environ(salome_env)
+ )
if no_path_init:
# specify we don't want to reinitialise paths
# path will keep the inherited value, which will be appended with new values.
file_environ.set_no_init_path()
- env = SalomeEnviron(self.config,
- file_environ,
- forBuild,
- for_package=for_package)
+ env = SalomeEnviron(
+ self.config, file_environ, forBuild, for_package=for_package
+ )
env.silent = self.silent
# set env from the APPLICATION
env.set_application_env(self.logger)
# set the products
- env.set_products(self.logger,
- src_root=self.src_root)
+ env.set_products(self.logger, src_root=self.src_root)
# Add the additional environment if it is not empty
if len(additional_env) != 0:
env.add_line(1)
env.add_comment("[APPLI variables]")
for variable in additional_env:
if not variable.startswith("sat_"):
- # by convention variables starting with sat_ are used to transfer information,
+ # by convention variables starting with sat_ are used to transfer information,
# not to be written in env
env.set(variable, additional_env[variable])
env_file.close()
return env_file.name
-
+
class Shell:
"""\
Definition of a Shell.
"""
+
def __init__(self, name, extension):
"""\
Initialization.
self.name = name
self.extension = extension
+
def load_environment(config, build, logger):
"""\
Loads the environment (used to run the tests, for example).
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2013 CEA/DEN
#
# This library is free software; you can redistribute it and/or
import src.architecture
import src.environment
+
def get_file_environ(output, shell, environ=None):
"""Instantiate correct FileEnvironment sub-class.
-
+
:param output file: the output file stream.
:param shell str: the type of shell syntax to use.
:param environ dict: a potential additional environment.
"""
if environ == None:
- environ=src.environment.Environ({})
+ environ = src.environment.Environ({})
if shell == "bash":
return BashFileEnviron(output, environ)
if shell == "tcl":
return ContextFileEnviron(output, environ)
raise Exception("FileEnviron: Unknown shell = %s" % shell)
+
class FileEnviron(object):
"""\
Base class for shell environment
"""
+
def __init__(self, output, environ=None):
"""\
Initialization
"""\
easy non exhaustive quick resume for debug print"""
res = {
- "output" : self.output,
- "environ" : self.environ,
+ "output": self.output,
+ "environ": self.environ,
}
return "%s(\n%s\n)" % (self.__class__.__name__, PP.pformat(res))
-
def _do_init(self, output, environ=None):
"""\
:param environ dict: a potential additional environment.
"""
self.output = output
- self.init_path=True # by default we initialise all paths, except PATH
+ self.init_path = True # by default we initialise all paths, except PATH
if environ is not None:
self.environ = environ
else:
:param sep str: the separator string
"""
# check that value so no contain the system separator
- separator=os.pathsep
+ separator = os.pathsep
if separator in value:
- raise Exception("FileEnviron append key '%s' value '%s' contains forbidden character '%s'" % (key, value, separator))
- do_append=True
+ raise Exception(
+ "FileEnviron append key '%s' value '%s' contains forbidden character '%s'"
+ % (key, value, separator)
+ )
+ do_append = True
if self.environ.is_defined(key):
value_list = self.environ.get(key).split(sep)
if self.environ._expandvars(value) in value_list:
- do_append=False # value is already in key path : we don't append it again
-
+ do_append = (
+ False # value is already in key path : we don't append it again
+ )
+
if do_append:
- self.environ.append_value(key, value,sep)
+ self.environ.append_value(key, value, sep)
self.set(key, self.get(key) + sep + value)
def append(self, key, value, sep=os.pathsep):
:param sep str: the separator string
"""
# check that value so no contain the system separator
- separator=os.pathsep
+ separator = os.pathsep
if separator in value:
- raise Exception("FileEnviron append key '%s' value '%s' contains forbidden character '%s'" % (key, value, separator))
+ raise Exception(
+ "FileEnviron append key '%s' value '%s' contains forbidden character '%s'"
+ % (key, value, separator)
+ )
- do_not_prepend=False
+ do_not_prepend = False
if self.environ.is_defined(key):
value_list = self.environ.get(key).split(sep)
- exp_val=self.environ._expandvars(value)
+ exp_val = self.environ._expandvars(value)
if exp_val in value_list:
- do_not_prepend=True
+ do_not_prepend = True
if not do_not_prepend:
- self.environ.prepend_value(key, value,sep)
+ self.environ.prepend_value(key, value, sep)
self.set(key, value + sep + self.get(key))
def prepend(self, key, value, sep=os.pathsep):
:param sep str: the separator string
"""
if isinstance(value, list):
- for v in reversed(value): # prepend list, first item at last to stay first
+ for v in reversed(value): # prepend list, first item at last to stay first
self.prepend_value(key, v, sep)
else:
self.prepend_value(key, value, sep)
:param key str: the environment variable
"""
if src.architecture.is_windows():
- return '%' + key + '%'
+ return "%" + key + "%"
else:
- return '${%s}' % key
+ return "${%s}" % key
def get_value(self, key):
"""Get the real value of the environment variable "key"
def finish(self):
"""Add a final instruction in the out file (in case of file generation)
-
+
:param required bool: Do nothing if required is False
"""
return
def set_no_init_path(self):
"""Set the no initialisation mode for all paths.
- By default only PATH is not reinitialised. All others paths are
- (LD_LIBRARY_PATH, PYTHONPATH, ...)
- After the call to these function ALL PATHS ARE NOT REINITIALISED.
- There initial value is inherited from the environment
+ By default only PATH is not reinitialised. All others paths are
+ (LD_LIBRARY_PATH, PYTHONPATH, ...)
+ After the call to these function ALL PATHS ARE NOT REINITIALISED.
+ There initial value is inherited from the environment
"""
- self.init_path=False
+ self.init_path = False
def value_filter(self, value):
- res=value
+ res = value
return res
"""\
Class for tcl shell.
"""
+
def __init__(self, output, environ=None):
"""Initialization
-
+
:param output file: the output file stream.
:param environ dict: a potential additional environment.
"""
self._do_init(output, environ)
- self.output.write(tcl_header.replace("<module_name>",
- self.environ.get("sat_product_name")))
- self.output.write("\nset software %s\n" % self.environ.get("sat_product_name") )
- self.output.write("set version %s\n" % self.environ.get("sat_product_version") )
- root=os.path.join(self.environ.get("sat_product_base_path"),
- "apps",
- self.environ.get("sat_product_base_name"),
- "$software",
- "$version")
- self.output.write("set root %s\n" % root)
- modules_to_load=self.environ.get("sat_product_load_depend")
- if len(modules_to_load)>0:
+ self.output.write(
+ tcl_header.replace("<module_name>", self.environ.get("sat_product_name"))
+ )
+ self.output.write("\nset software %s\n" % self.environ.get("sat_product_name"))
+ self.output.write("set version %s\n" % self.environ.get("sat_product_version"))
+ root = os.path.join(
+ self.environ.get("sat_product_base_path"),
+ "apps",
+ self.environ.get("sat_product_base_name"),
+ "$software",
+ "$version",
+ )
+ self.output.write("set root %s\n" % root)
+ modules_to_load = self.environ.get("sat_product_load_depend")
+ if len(modules_to_load) > 0:
# write module load commands for product dependencies
self.output.write("\n")
for module_to_load in modules_to_load.split(";"):
- self.output.write(module_to_load+"\n")
+ self.output.write(module_to_load + "\n")
def set(self, key, value):
"""Set the environment variable "key" to value "value"
-
+
:param key str: the environment variable to set
:param value str: the value
"""
self.output.write('setenv %s "%s"\n' % (key, value))
self.environ.set(key, value)
-
+
def get(self, key):
"""\
Get the value of the environment variable "key"
def append_value(self, key, value, sep=os.pathsep):
"""append value to key using sep
-
+
:param key str: the environment variable to append
:param value str: the value to append to key
:param sep str: the separator string
"""
- if sep==os.pathsep:
- self.output.write('append-path %s %s\n' % (key, value))
+ if sep == os.pathsep:
+ self.output.write("append-path %s %s\n" % (key, value))
else:
- self.output.write('append-path --delim=\%c %s %s\n' % (sep, key, value))
+ self.output.write("append-path --delim=\%c %s %s\n" % (sep, key, value))
def prepend_value(self, key, value, sep=os.pathsep):
"""prepend value to key using sep
-
+
:param key str: the environment variable to prepend
:param value str: the value to prepend to key
:param sep str: the separator string
"""
- if sep==os.pathsep:
- self.output.write('prepend-path %s %s\n' % (key, value))
+ if sep == os.pathsep:
+ self.output.write("prepend-path %s %s\n" % (key, value))
else:
- self.output.write('prepend-path --delim=\%c %s %s\n' % (sep, key, value))
+ self.output.write("prepend-path --delim=\%c %s %s\n" % (sep, key, value))
+
-
class BashFileEnviron(FileEnviron):
"""\
Class for bash shell.
"""
+
def __init__(self, output, environ=None):
"""Initialization
-
+
:param output file: the output file stream.
:param environ dict: a potential additional environment.
"""
def set(self, key, value):
"""Set the environment variable "key" to value "value"
-
+
:param key str: the environment variable to set
:param value str: the value
"""
self.output.write('export %s="%s"\n' % (key, value))
self.environ.set(key, value)
-
-
+
class BatFileEnviron(FileEnviron):
"""\
for Windows batch shell.
"""
+
def __init__(self, output, environ=None):
"""Initialization
-
+
:param output file: the output file stream.
:param environ dict: a potential additional environment.
"""
def add_comment(self, comment):
"""Add a comment in the shell file
-
+
:param comment str: the comment to add
"""
self.output.write("rem %s\n" % comment)
-
+
def get(self, key):
"""Get the value of the environment variable "key"
-
+
:param key str: the environment variable
"""
- return '%%%s%%' % key
-
+ return "%%%s%%" % key
+
def set(self, key, value):
"""Set the environment variable "key" to value "value"
-
+
:param key str: the environment variable to set
:param value str: the value
"""
- self.output.write('set %s=%s\n' % (key, self.value_filter(value)))
+ self.output.write("set %s=%s\n" % (key, self.value_filter(value)))
self.environ.set(key, value)
class ContextFileEnviron(FileEnviron):
- """Class for a salome context configuration file.
- """
+ """Class for a salome context configuration file."""
+
def __init__(self, output, environ=None):
"""Initialization
-
+
:param output file: the output file stream.
:param environ dict: a potential additional environment.
"""
def set(self, key, value):
"""Set the environment variable "key" to value "value"
-
+
:param key str: the environment variable to set
:param value str: the value
"""
def get(self, key):
"""Get the value of the environment variable "key"
-
+
:param key str: the environment variable
"""
- return '%({0})s'.format(key)
+ return "%({0})s".format(key)
def add_echo(self, text):
"""Add a comment
-
+
:param text str: the comment to add
"""
self.add_comment(text)
def add_warning(self, warning):
"""Add a warning
-
+
:param text str: the warning to add
"""
- self.add_comment("WARNING %s" % warning)
+ self.add_comment("WARNING %s" % warning)
def prepend_value(self, key, value, sep=os.pathsep):
"""prepend value to key using sep
-
+
:param key str: the environment variable to prepend
:param value str: the value to prepend to key
:param sep str: the separator string
"""
- do_append=True
+ do_append = True
if self.environ.is_defined(key):
value_list = self.environ.get(key).split(sep)
- #value cannot be expanded (unlike bash/bat case) - but it doesn't matter.
+ # value cannot be expanded (unlike bash/bat case) - but it doesn't matter.
if value in value_list:
- do_append=False # value is already in key path : we don't append it again
-
+ do_append = (
+ False # value is already in key path : we don't append it again
+ )
+
if do_append:
- self.environ.append_value(key, value,sep)
- self.output.write('ADD_TO_%s: %s\n' % (key, value))
+ self.environ.append_value(key, value, sep)
+ self.output.write("ADD_TO_%s: %s\n" % (key, value))
def append_value(self, key, value, sep=os.pathsep):
"""append value to key using sep
-
+
:param key str: the environment variable to append
:param value str: the value to append to key
:param sep str: the separator string
Class to generate a launcher file script
(in python syntax) SalomeContext API
"""
+
def __init__(self, output, environ=None):
"""Initialization
-
+
:param output file: the output file stream.
:param environ dict: a potential additional environment.
"""
self._do_init(output, environ)
- self.python_version=self.environ.get("sat_python_version")
- self.bin_kernel_root_dir=self.environ.get("sat_bin_kernel_install_dir")
+ self.python_version = self.environ.get("sat_python_version")
+ self.bin_kernel_root_dir = self.environ.get("sat_bin_kernel_install_dir")
# four whitespaces for first indentation in a python script
- self.indent=" "
- self.prefix="context."
- self.setVarEnv="setVariable"
- self.begin=self.indent+self.prefix
+ self.indent = " "
+ self.prefix = "context."
+ self.setVarEnv = "setVariable"
+ self.begin = self.indent + self.prefix
# write the begining of launcher file.
- # choose the template version corresponding to python version
+ # choose the template version corresponding to python version
# and substitute BIN_KERNEL_INSTALL_DIR (the path to salomeContext.py)
if self.python_version == 2:
- launcher_header=launcher_header2
+ launcher_header = launcher_header2
else:
- launcher_header=launcher_header3
+ launcher_header = launcher_header3
# in case of Windows OS, Python scripts are not executable. PyExe ?
if src.architecture.is_windows():
- launcher_header = launcher_header.replace("#! /usr/bin/env python3",'')
- self.output.write(launcher_header\
- .replace("BIN_KERNEL_INSTALL_DIR", self.bin_kernel_root_dir))
+ launcher_header = launcher_header.replace("#! /usr/bin/env python3", "")
+ self.output.write(
+ launcher_header.replace("BIN_KERNEL_INSTALL_DIR", self.bin_kernel_root_dir)
+ )
# for these path, we use specialired functions in salomeContext api
- self.specialKeys={"PATH": "Path",
- "LD_LIBRARY_PATH": "LdLibraryPath",
- "PYTHONPATH": "PythonPath"}
+ self.specialKeys = {
+ "PATH": "Path",
+ "LD_LIBRARY_PATH": "LdLibraryPath",
+ "PYTHONPATH": "PythonPath",
+ }
# we do not want to reinitialise PATH.
# for that we make sure PATH is in self.environ
# and therefore we will not use setVariable for PATH
if not self.environ.is_defined("PATH"):
- self.environ.set("PATH","")
+ self.environ.set("PATH", "")
def add_echo(self, text):
"""Add a comment
-
+
:param text str: the comment to add
"""
self.output.write('# %s"\n' % text)
def add_warning(self, warning):
"""Add a warning
-
+
:param text str: the warning to add
"""
self.output.write('# "WARNING %s"\n' % warning)
def append_value(self, key, value, sep=os.pathsep):
"""append value to key using sep,
if value contains ":" or ";" then raise error
-
+
:param key str: the environment variable to prepend
:param value str: the value to prepend to key
:param sep str: the separator string
"""
# check that value so no contain the system separator
- separator=os.pathsep
- msg="LauncherFileEnviron append key '%s' value '%s' contains forbidden character '%s'"
+ separator = os.pathsep
+ msg = "LauncherFileEnviron append key '%s' value '%s' contains forbidden character '%s'"
if separator in value:
raise Exception(msg % (key, value, separator))
- is_key_defined=self.environ.is_defined(key)
- conditional_reinit=False
- if (self.init_path and (not is_key_defined)):
+ is_key_defined = self.environ.is_defined(key)
+ conditional_reinit = False
+ if self.init_path and (not is_key_defined):
# reinitialisation mode set to true (the default)
# for the first occurrence of key, we set it.
# therefore key will not be inherited from environment
- self.output.write(self.indent+'if reinitialise_paths:\n'+self.indent)
+ self.output.write(self.indent + "if reinitialise_paths:\n" + self.indent)
self.set(key, value)
- self.output.write(self.indent+'else:\n'+self.indent)
- conditional_reinit=True # in this case do not register value in self.environ a second time
+ self.output.write(self.indent + "else:\n" + self.indent)
+ conditional_reinit = (
+ True # in this case do not register value in self.environ a second time
+ )
# in all other cases we use append (except if value is already the key
- do_append=True
+ do_append = True
if is_key_defined:
value_list = self.environ.get(key).split(sep)
# rem : value cannot be expanded (unlike bash/bat case) - but it doesn't matter.
if value in value_list:
- do_append=False # value is already in key path : we don't append it again
-
+ do_append = (
+ False # value is already in key path : we don't append it again
+ )
+
if do_append:
if not conditional_reinit:
- self.environ.append_value(key, value,sep) # register value in self.environ
+ self.environ.append_value(
+ key, value, sep
+ ) # register value in self.environ
if key in self.specialKeys.keys():
- #for these special keys we use the specific salomeContext function
- self.output.write(self.begin+'addTo%s(r"%s")\n' %
- (self.specialKeys[key], self.value_filter(value)))
+ # for these special keys we use the specific salomeContext function
+ self.output.write(
+ self.begin
+ + 'addTo%s(r"%s")\n'
+ % (self.specialKeys[key], self.value_filter(value))
+ )
else:
# else we use the general salomeContext addToVariable function
- self.output.write(self.begin+'appendVariable(r"%s", r"%s",separator="%s")\n'
- % (key, self.value_filter(value), sep))
+ self.output.write(
+ self.begin
+ + 'appendVariable(r"%s", r"%s",separator="%s")\n'
+ % (key, self.value_filter(value), sep)
+ )
def append(self, key, value, sep=":"):
"""Same as append_value but the value argument can be a list
-
+
:param key str: the environment variable to append
:param value str or list: the value(s) to append to key
:param sep str: the separator string
def prepend_value(self, key, value, sep=os.pathsep):
"""prepend value to key using sep,
if value contains ":" or ";" then raise error
-
+
:param key str: the environment variable to prepend
:param value str: the value to prepend to key
:param sep str: the separator string
"""
# check that value so no contain the system separator
- separator=os.pathsep
- msg="LauncherFileEnviron append key '%s' value '%s' contains forbidden character '%s'"
+ separator = os.pathsep
+ msg = "LauncherFileEnviron append key '%s' value '%s' contains forbidden character '%s'"
if separator in value:
raise Exception(msg % (key, value, separator))
- is_key_defined=self.environ.is_defined(key)
- conditional_reinit=False
- if (self.init_path and (not is_key_defined)):
+ is_key_defined = self.environ.is_defined(key)
+ conditional_reinit = False
+ if self.init_path and (not is_key_defined):
# reinitialisation mode set to true (the default)
# for the first occurrence of key, we set it.
# therefore key will not be inherited from environment
- self.output.write(self.indent+'if reinitialise_paths:\n'+self.indent)
+ self.output.write(self.indent + "if reinitialise_paths:\n" + self.indent)
self.set(key, value)
- self.output.write(self.indent+'else:\n'+self.indent)
- conditional_reinit=True # in this case do not register value in self.environ a second time
+ self.output.write(self.indent + "else:\n" + self.indent)
+ conditional_reinit = (
+ True # in this case do not register value in self.environ a second time
+ )
# in all other cases we use append (except if value is already the key
- do_append=True
+ do_append = True
if is_key_defined:
value_list = self.environ.get(key).split(sep)
# rem : value cannot be expanded (unlike bash/bat case) - but it doesn't matter.
if value in value_list:
- do_append=False # value is already in key path : we don't append it again
-
+ do_append = (
+ False # value is already in key path : we don't append it again
+ )
+
if do_append:
if not conditional_reinit:
- self.environ.append_value(key, value,sep) # register value in self.environ
+ self.environ.append_value(
+ key, value, sep
+ ) # register value in self.environ
if key in self.specialKeys.keys():
- #for these special keys we use the specific salomeContext function
- self.output.write(self.begin+'addTo%s(r"%s")\n' %
- (self.specialKeys[key], self.value_filter(value)))
+ # for these special keys we use the specific salomeContext function
+ self.output.write(
+ self.begin
+ + 'addTo%s(r"%s")\n'
+ % (self.specialKeys[key], self.value_filter(value))
+ )
else:
# else we use the general salomeContext addToVariable function
- self.output.write(self.begin+'addToVariable(r"%s", r"%s",separator="%s")\n'
- % (key, self.value_filter(value), sep))
-
+ self.output.write(
+ self.begin
+ + 'addToVariable(r"%s", r"%s",separator="%s")\n'
+ % (key, self.value_filter(value), sep)
+ )
def prepend(self, key, value, sep=":"):
"""Same as prepend_value but the value argument can be a list
-
+
:param key str: the environment variable to prepend
:param value str or list: the value(s) to prepend to key
:param sep str: the separator string
else:
self.prepend_value(key, value, sep)
-
def set(self, key, value):
"""Set the environment variable "key" to value "value"
-
+
:param key str: the environment variable to set
:param value str: the value
"""
- self.output.write(self.begin+self.setVarEnv+
- '(r"%s", r"%s", overwrite=True)\n' %
- (key, self.value_filter(value)))
- self.environ.set(key,value)
-
+ self.output.write(
+ self.begin
+ + self.setVarEnv
+ + '(r"%s", r"%s", overwrite=True)\n' % (key, self.value_filter(value))
+ )
+ self.environ.set(key, value)
def add_comment(self, comment):
# Special comment in case of the DISTENE licence
- if comment=="DISTENE license":
- self.output.write(self.indent+
- "#"+
- self.prefix+
- self.setVarEnv+
- '(r"%s", r"%s", overwrite=True)\n' %
- ('DISTENE_LICENSE_FILE', 'Use global envvar: DLIM8VAR'))
- self.output.write(self.indent+
- "#"+
- self.prefix+
- self.setVarEnv+
- '(r"%s", r"%s", overwrite=True)\n' %
- ('DLIM8VAR', '<your licence>'))
+ if comment == "DISTENE license":
+ self.output.write(
+ self.indent
+ + "#"
+ + self.prefix
+ + self.setVarEnv
+ + '(r"%s", r"%s", overwrite=True)\n'
+ % ("DISTENE_LICENSE_FILE", "Use global envvar: DLIM8VAR")
+ )
+ self.output.write(
+ self.indent
+ + "#"
+ + self.prefix
+ + self.setVarEnv
+ + '(r"%s", r"%s", overwrite=True)\n' % ("DLIM8VAR", "<your licence>")
+ )
return
if "setting environ for" in comment:
- self.output.write(self.indent+"#[%s]\n" %
- comment.split("setting environ for ")[1])
+ self.output.write(
+ self.indent + "#[%s]\n" % comment.split("setting environ for ")[1]
+ )
return
- self.output.write(self.indent+"# %s\n" % comment)
+ self.output.write(self.indent + "# %s\n" % comment)
def finish(self):
"""\
:param required bool: Do nothing if required is False
"""
if self.python_version == 2:
- launcher_tail=launcher_tail_py2
+ launcher_tail = launcher_tail_py2
else:
- launcher_tail=launcher_tail_py3
+ launcher_tail = launcher_tail_py3
self.output.write(launcher_tail)
return
+
class ScreenEnviron(FileEnviron):
def __init__(self, output, environ=None):
self._do_init(output, environ)
def write(self, command, name, value, sign="="):
import src
- self.output.write(" %s%s %s %s %s\n" % \
- (src.printcolors.printcLabel(command),
- " " * (12 - len(command)),
- src.printcolors.printcInfo(name), sign, value))
+
+ self.output.write(
+ " %s%s %s %s %s\n"
+ % (
+ src.printcolors.printcLabel(command),
+ " " * (12 - len(command)),
+ src.printcolors.printcInfo(name),
+ sign,
+ value,
+ )
+ )
def is_defined(self, name):
return name in self.defined
#
# Headers
#
-bat_header="""\
+bat_header = """\
@echo off
rem The following variables are used only in case of a sat package
set out_dir_Path=%~dp0
"""
-tcl_header="""\
+tcl_header = """\
#%Module -*- tcl -*-
#
# <module_name> module for use with 'environment-modules' package
#
"""
-bash_header="""\
+bash_header = """\
#!/bin/bash
if [ "$BASH" = "" ]
then
###########################################################################
"""
-cfg_header="""\
+cfg_header = """\
[SALOME Configuration]
"""
-launcher_header2="""\
+launcher_header2 = """\
#! /usr/bin/env python
################################################################
context.getLogger().setLevel(40)
"""
-launcher_header3="""\
+launcher_header3 = """\
#! /usr/bin/env python3
################################################################
context.getLogger().setLevel(40)
"""
-launcher_tail_py2="""\
+launcher_tail_py2 = """\
#[hook to integrate in launcher additionnal user modules]
# Load all files extra.env.d/*.py and call the module's init routine]
#
"""
-launcher_tail_py3="""\
+launcher_tail_py3 = """\
#[hook to integrate in launcher additionnal user modules]
# Load all files extra.env.d/*.py and call the module's init routine]
main(args)
#
"""
-
-
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2013 CEA/DEN
#
# This library is free software; you can redistribute it and/or
# OP
import src
+
def show_progress(logger, top, delai, ss=""):
"""shortcut function to display the progression
-
+
:param logger Logger: The logging instance
:param top int: the number to display
:param delai int: the number max
:param ss str: the string to display
"""
- logger.write("\r%s\r%s timeout %s / %s stay %s s " % ((" " * 30), ss, top, delai, (delai - top)), 4, False)
+ logger.write(
+ "\r%s\r%s timeout %s / %s stay %s s "
+ % ((" " * 30), ss, top, delai, (delai - top)),
+ 4,
+ False,
+ )
logger.flush()
+
def write_back(logger, message, level):
"""shortcut function to write at the begin of the line
-
+
:param logger Logger: The logging instance
:param message str: the text to display
:param level int: the level of verbosity
"""
logger.write("\r%s\r%s" % ((" " * 40), message), level)
+
# Launch command
# --------------
def launch_command(cmd, logger, cwd, args=[], log=None):
# Add Windows case
if src.architecture.is_windows():
- prs = subprocess.Popen(cmd,
- shell=True,
- stdout=log,
- stderr=subprocess.STDOUT,
- cwd=cwd)
+ prs = subprocess.Popen(
+ cmd, shell=True, stdout=log, stderr=subprocess.STDOUT, cwd=cwd
+ )
else:
- prs = subprocess.Popen(cmd,
- shell=True,
- stdout=log,
- stderr=subprocess.STDOUT,
- cwd=cwd,
- executable='/bin/bash')
+ prs = subprocess.Popen(
+ cmd,
+ shell=True,
+ stdout=log,
+ stderr=subprocess.STDOUT,
+ cwd=cwd,
+ executable="/bin/bash",
+ )
return prs
+
# Launch a batch
# --------------
def batch(cmd, logger, cwd, args=[], log=None, delai=20, sommeil=1):
if top == delai:
logger.write("batch: time out KILL\n", 3)
import signal
+
os.kill(proc.pid, signal.SIGTERM)
break
else:
# Launch a salome process
# -----------------------
-def batch_salome(cmd, logger, cwd, args, getTmpDir,
- pendant="SALOME_Session_Server", fin="killSalome.py",
- log=None, delai=20, sommeil=1, delaiapp=0):
+def batch_salome(
+ cmd,
+ logger,
+ cwd,
+ args,
+ getTmpDir,
+ pendant="SALOME_Session_Server",
+ fin="killSalome.py",
+ log=None,
+ delai=20,
+ sommeil=1,
+ delaiapp=0,
+):
beginTime = time.time()
launch_command(cmd, logger, cwd, args, log)
foundSalome = "batch salome not seen"
tmp_dir = getTmpDir()
# print("batch_salome %s %s / %s sommeil %s:\n%s" % (tmp_dir, delai, delaiapp, sommeil, cmd))
- while (not found and top < delaiapp):
+ while not found and top < delaiapp:
if os.path.exists(tmp_dir):
listFile = os.listdir(tmp_dir)
listFile = [f for f in listFile if f.endswith("_pidict")]
time.sleep(sommeil)
top += 1
- show_progress(logger, top, delaiapp, "launching salome or appli found=%s:" % found)
+ show_progress(
+ logger, top, delaiapp, "launching salome or appli found=%s:" % found
+ )
# continue or not
if found:
logger.write("\nbatch_salome: supposed started\n", 5)
else:
- logger.write("\nbatch_salome: seems FAILED to launch salome or appli : %s\n" % foundSalome, 3)
+ logger.write(
+ "\nbatch_salome: seems FAILED to launch salome or appli : %s\n"
+ % foundSalome,
+ 3,
+ )
return False, -1
# salome launched run the script
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# %% LICENSE_SALOME_CEA_BEGIN
# Copyright (C) 2008-2018 CEA/DEN
-#
+#
# 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, or (at your option) any later version.
-#
+#
# 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
# %% LICENSE_END
verbose = False
+
class TestCase(unittest.TestCase):
-
- def test_001(self):
- # first load resources for internationalization
- gettext.install('salomeTools', os.path.realpath(os.path.dirname(__file__)))
-
- def test_005(self):
- res = _("Harvey writes '%(1)s' for %(2)s.") % {"1": "hello", "2": "test_005"}
- if verbose: print(res)
- self.assertEqual(res, "pour test_005 Hervé écrit 'hello'.")
-
- def test_010(self):
- res = _("Harvey writes '%(1)s' for %(2)s.") % {"1": _("hello"), "2": "test_010"}
- if verbose: print(res)
- self.assertEqual(res, "pour test_010 Hervé écrit 'bonjour'.")
-
- def test_020(self):
- # keep Ooops inexisting in salomeTools.po as no translation
- res = _("Harvey writes '%(1)s' for %(2)s.") % {"1": _("Ooops"), "2": "test_020"}
- if verbose: print(res)
- self.assertEqual(res, "pour test_020 Hervé écrit 'Ooops'.")
-
-if __name__ == '__main__':
- verbose = False
- unittest.main()
- pass
+ def test_001(self):
+ # first load resources for internationalization
+ gettext.install("salomeTools", os.path.realpath(os.path.dirname(__file__)))
+
+ def test_005(self):
+ res = _("Harvey writes '%(1)s' for %(2)s.") % {"1": "hello", "2": "test_005"}
+ if verbose:
+ print(res)
+ self.assertEqual(res, "pour test_005 Hervé écrit 'hello'.")
+
+ def test_010(self):
+ res = _("Harvey writes '%(1)s' for %(2)s.") % {"1": _("hello"), "2": "test_010"}
+ if verbose:
+ print(res)
+ self.assertEqual(res, "pour test_010 Hervé écrit 'bonjour'.")
+
+ def test_020(self):
+ # keep Ooops inexisting in salomeTools.po as no translation
+ res = _("Harvey writes '%(1)s' for %(2)s.") % {"1": _("Ooops"), "2": "test_020"}
+ if verbose:
+ print(res)
+ self.assertEqual(res, "pour test_020 Hervé écrit 'Ooops'.")
+
+
+if __name__ == "__main__":
+ verbose = False
+ unittest.main()
+ pass
"""
import polib
-po = polib.pofile('fr/LC_MESSAGES/salomeTools.po', encoding='utf-8')
-po.save_as_mofile('fr/LC_MESSAGES/salomeTools.mo')
+
+po = polib.pofile("fr/LC_MESSAGES/salomeTools.po", encoding="utf-8")
+po.save_as_mofile("fr/LC_MESSAGES/salomeTools.mo")
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2012 CEA/DEN
#
# This library is free software; you can redistribute it and/or
log_macro_command_file_expression = "^[0-9]{8}_+[0-9]{6}_+.*\.xml$"
log_all_command_file_expression = "^.*[0-9]{8}_+[0-9]{6}_+.*\.xml$"
-verbose = True # cvw TODO
+verbose = True # cvw TODO
+
class Logger(object):
"""\
Class to handle log mechanism.
"""
- def __init__(self,
- config= None,
- silent_sysstd=False,
- all_in_terminal=False,
- micro_command = False):
+
+ def __init__(
+ self,
+ config=None,
+ silent_sysstd=False,
+ all_in_terminal=False,
+ micro_command=False,
+ ):
"""Initialization
-
+
:param config pyconf.Config: The global configuration.
:param silent_sysstd boolean: if True, do not write anything
in terminal.
self.config = config
self.default_level = 3
self.silentSysStd = silent_sysstd
-
+
# Construct xml log file location for sat prints.
prefix = ""
if micro_command:
prefix = "micro_"
- hour_command_host = (config.VARS.datehour + "_" +
- config.VARS.command + "_" +
- config.VARS.hostname)
+ hour_command_host = (
+ config.VARS.datehour
+ + "_"
+ + config.VARS.command
+ + "_"
+ + config.VARS.hostname
+ )
logFileName = prefix + hour_command_host + ".xml"
log_dir = src.get_log_path(config)
logFilePath = os.path.join(log_dir, logFileName)
- # Construct txt file location in order to log
+ # Construct txt file location in order to log
# the external commands calls (cmake, make, git clone, etc...)
txtFileName = prefix + hour_command_host + ".txt"
txtFilePath = os.path.join(log_dir, "OUT", txtFileName)
aDirLog = os.path.dirname(logFilePath)
if not os.path.exists(aDirLog):
- print("create log dir %s" % aDirLog)
- src.ensure_path_exists(aDirLog)
- # sometimes other users make 'sat log' and create hat.xml file...
- os.chmod(aDirLog,
- stat.S_IRUSR |
- stat.S_IRGRP |
- stat.S_IROTH |
- stat.S_IWUSR |
- stat.S_IWGRP |
- stat.S_IWOTH |
- stat.S_IXUSR |
- stat.S_IXGRP |
- stat.S_IXOTH)
+ print("create log dir %s" % aDirLog)
+ src.ensure_path_exists(aDirLog)
+ # sometimes other users make 'sat log' and create hat.xml file...
+ os.chmod(
+ aDirLog,
+ stat.S_IRUSR
+ | stat.S_IRGRP
+ | stat.S_IROTH
+ | stat.S_IWUSR
+ | stat.S_IWGRP
+ | stat.S_IWOTH
+ | stat.S_IXUSR
+ | stat.S_IXGRP
+ | stat.S_IXOTH,
+ )
src.ensure_path_exists(os.path.dirname(txtFilePath))
-
- # The path of the log files (one for sat traces, and the other for
+
+ # The path of the log files (one for sat traces, and the other for
# the system commands traces)
self.logFileName = logFileName
self.logFilePath = logFilePath
self.txtFileName = txtFileName
self.txtFilePath = txtFilePath
-
+
# The list of all log files corresponding to the current command and
# the commands called by the current command
self.l_logFiles = [logFilePath, txtFilePath]
-
- # Initialize xml instance and put first fields
- # like beginTime, user, command, etc...
- self.xmlFile = xmlManager.XmlLogFile(logFilePath, "SATcommand",
- attrib = {"application" : config.VARS.application})
+
+ # Initialize xml instance and put first fields
+ # like beginTime, user, command, etc...
+ self.xmlFile = xmlManager.XmlLogFile(
+ logFilePath, "SATcommand", attrib={"application": config.VARS.application}
+ )
self.put_initial_xml_fields()
# Initialize the txt file for reading
try:
- self.logTxtFile = open(str(self.txtFilePath), 'w')
+ self.logTxtFile = open(str(self.txtFilePath), "w")
except IOError:
- #msg1 = _("WARNING! Trying to write to a file that"
+ # msg1 = _("WARNING! Trying to write to a file that"
# " is not accessible:")
- #msg2 = _("The logs won't be written.")
- #print("%s\n%s\n%s\n" % (src.printcolors.printcWarning(msg1),
+ # msg2 = _("The logs won't be written.")
+ # print("%s\n%s\n%s\n" % (src.printcolors.printcWarning(msg1),
# src.printcolors.printcLabel(str(self.txtFilePath)),
# src.printcolors.printcWarning(msg2) ))
self.logTxtFile = tempfile.TemporaryFile()
-
+
# If the option all_in_terminal was called, all the system commands
# are redirected to the terminal
if all_in_terminal:
self.logTxtFile = sys.__stdout__
-
+
def put_initial_xml_fields(self):
"""\
Called at class initialization: Put all fields
corresponding to the command context (user, time, ...)
"""
# command name
- self.xmlFile.add_simple_node("Site", attrib={"command" :
- self.config.VARS.command})
+ self.xmlFile.add_simple_node(
+ "Site", attrib={"command": self.config.VARS.command}
+ )
# version of salomeTools
- self.xmlFile.append_node_attrib("Site", attrib={"satversion" :
- src.get_salometool_version(self.config)})
+ self.xmlFile.append_node_attrib(
+ "Site", attrib={"satversion": src.get_salometool_version(self.config)}
+ )
# machine name on which the command has been launched
- self.xmlFile.append_node_attrib("Site", attrib={"hostname" :
- self.config.VARS.hostname})
+ self.xmlFile.append_node_attrib(
+ "Site", attrib={"hostname": self.config.VARS.hostname}
+ )
# Distribution of the machine
- self.xmlFile.append_node_attrib("Site", attrib={"OS" :
- self.config.VARS.dist})
+ self.xmlFile.append_node_attrib("Site", attrib={"OS": self.config.VARS.dist})
# The user that have launched the command
- self.xmlFile.append_node_attrib("Site", attrib={"user" :
- self.config.VARS.user})
+ self.xmlFile.append_node_attrib("Site", attrib={"user": self.config.VARS.user})
# The time when command was launched
Y, m, dd, H, M, S = date_to_datetime(self.config.VARS.datehour)
date_hour = "%4s/%2s/%2s %2sh%2sm%2ss" % (Y, m, dd, H, M, S)
- self.xmlFile.append_node_attrib("Site", attrib={"beginTime" :
- date_hour})
+ self.xmlFile.append_node_attrib("Site", attrib={"beginTime": date_hour})
# The application if any
if "APPLICATION" in self.config:
- self.xmlFile.append_node_attrib("Site",
- attrib={"application" : self.config.VARS.application})
+ self.xmlFile.append_node_attrib(
+ "Site", attrib={"application": self.config.VARS.application}
+ )
# The initialization of the trace node
- self.xmlFile.add_simple_node("Log",text="")
+ self.xmlFile.add_simple_node("Log", text="")
# The system commands logs
- self.xmlFile.add_simple_node("OutLog",
- text=os.path.join("OUT", self.txtFileName))
- # The initialization of the node where
+ self.xmlFile.add_simple_node(
+ "OutLog", text=os.path.join("OUT", self.txtFileName)
+ )
+ # The initialization of the node where
# to put the links to the other sat commands that can be called by any
- # command
+ # command
self.xmlFile.add_simple_node("Links")
- def add_link(self,
- log_file_name,
- command_name,
- command_res,
- full_launched_command):
+ def add_link(self, log_file_name, command_name, command_res, full_launched_command):
"""Add a link to another log file.
-
+
:param log_file_name str: The file name of the link.
:param command_name str: The name of the command linked.
:param command_res str: The result of the command linked. "0" or "1"
- :parma full_launched_command str: The full lanch command
+ :parma full_launched_command str: The full lanch command
("sat command ...")
"""
xmlLinks = self.xmlFile.xmlroot.find("Links")
flc = src.xmlManager.escapeSequence(full_launched_command)
- att = {"command" : command_name, "passed" : str(command_res), "launchedCommand" : flc}
- src.xmlManager.add_simple_node(xmlLinks, "link", text = log_file_name, attrib = att)
+ att = {
+ "command": command_name,
+ "passed": str(command_res),
+ "launchedCommand": flc,
+ }
+ src.xmlManager.add_simple_node(xmlLinks, "link", text=log_file_name, attrib=att)
def write(self, message, level=None, screenOnly=False):
"""\
# do not write message starting with \r to log file
if not message.startswith("\r") and not screenOnly:
- self.xmlFile.append_node_text("Log",
- printcolors.cleancolor(message))
+ self.xmlFile.append_node_text("Log", printcolors.cleancolor(message))
# get user or option output level
current_output_verbose_level = self.config.USER.output_verbose_level
- if not ('isatty' in dir(sys.stdout) and sys.stdout.isatty()):
+ if not ("isatty" in dir(sys.stdout) and sys.stdout.isatty()):
# clean the message color if the terminal is redirected by user
# ex: sat compile appli > log.txt
message = printcolors.cleancolor(message)
-
+
# Print message regarding the output level value
if level:
if level <= current_output_verbose_level and not self.silentSysStd:
sys.stdout.write(message)
else:
- if self.default_level <= current_output_verbose_level and not self.silentSysStd:
+ if (
+ self.default_level <= current_output_verbose_level
+ and not self.silentSysStd
+ ):
sys.stdout.write(message)
self.flush()
def error(self, message, prefix="ERROR: "):
- """Print an error.
+ """Print an error.
- :param message str: The message to print.
- """
- # Print in the log file
- self.xmlFile.append_node_text("traces", prefix + message)
+ :param message str: The message to print.
+ """
+ # Print in the log file
+ self.xmlFile.append_node_text("traces", prefix + message)
- # Print in the terminal and clean colors if the terminal
- # is redirected by user
- if not ('isatty' in dir(sys.stderr) and sys.stderr.isatty()):
- sys.stderr.write(printcolors.printcError(prefix + message + "\n"))
- else:
- sys.stderr.write(prefix + message + "\n")
+ # Print in the terminal and clean colors if the terminal
+ # is redirected by user
+ if not ("isatty" in dir(sys.stderr) and sys.stderr.isatty()):
+ sys.stderr.write(printcolors.printcError(prefix + message + "\n"))
+ else:
+ sys.stderr.write(prefix + message + "\n")
def step(self, message):
- """Print an step message.
+ """Print an step message.
- :param message str: The message to print.
- """
- self.write('STEP: ' + message, level=4)
+ :param message str: The message to print.
+ """
+ self.write("STEP: " + message, level=4)
def trace(self, message):
- """Print an trace message.
+ """Print an trace message.
- :param message str: The message to print.
- """
- self.write('TRACE: ' + message, level=5)
+ :param message str: The message to print.
+ """
+ self.write("TRACE: " + message, level=5)
def debug(self, message):
- """Print an debug message.
+ """Print an debug message.
- :param message str: The message to print.
- """
- self.write('DEBUG: ' + message, level=6)
+ :param message str: The message to print.
+ """
+ self.write("DEBUG: " + message, level=6)
def warning(self, message):
- """Print an warning message.
+ """Print an warning message.
- :param message str: The message to print.
- """
- self.error(message, prefix="WARNING: ")
+ :param message str: The message to print.
+ """
+ self.error(message, prefix="WARNING: ")
def critical(self, message):
- """Print an critical message.
-
- :param message str: The message to print.
- """
- self.error(message, prefix="CRITICAL: ")
-
+ """Print an critical message.
+ :param message str: The message to print.
+ """
+ self.error(message, prefix="CRITICAL: ")
def flush(self):
"""Flush terminal"""
sys.stdout.flush()
self.logTxtFile.flush()
-
+
def end_write(self, attribute):
"""\
Called just after command end: Put all fields
And display the command to launch to get the log
:param attribute dict: the attribute to add to the node "Site".
- """
+ """
# Get current time (end of command) and format it
dt = datetime.datetime.now()
Y, m, dd, H, M, S = date_to_datetime(self.config.VARS.datehour)
delta = tf - t0
total_time = timedelta_total_seconds(delta)
hours = int(total_time / 3600)
- minutes = int((total_time - hours*3600) / 60)
- seconds = total_time - hours*3600 - minutes*60
+ minutes = int((total_time - hours * 3600) / 60)
+ seconds = total_time - hours * 3600 - minutes * 60
# Add the fields corresponding to the end time
# and the total time of command
- endtime = dt.strftime('%Y/%m/%d %Hh%Mm%Ss')
- self.xmlFile.append_node_attrib("Site", attrib={"endTime" : endtime})
- self.xmlFile.append_node_attrib("Site",
- attrib={"TotalTime" : "%ih%im%is" % (hours, minutes, seconds)})
-
+ endtime = dt.strftime("%Y/%m/%d %Hh%Mm%Ss")
+ self.xmlFile.append_node_attrib("Site", attrib={"endTime": endtime})
+ self.xmlFile.append_node_attrib(
+ "Site", attrib={"TotalTime": "%ih%im%is" % (hours, minutes, seconds)}
+ )
+
# Add the attribute passed to the method
self.xmlFile.append_node_attrib("Site", attrib=attribute)
-
+
# Call the method to write the xml file on the hard drive
- self.xmlFile.write_tree(stylesheet = "command.xsl")
+ self.xmlFile.write_tree(stylesheet="command.xsl")
# so unconditionnaly copy stylesheet file(s)
- xslDir = os.path.join(self.config.VARS.srcDir, 'xsl')
+ xslDir = os.path.join(self.config.VARS.srcDir, "xsl")
xslCommand = "command.xsl"
# xslHat = "hat.xsl" # have to be completed (one time at end)
xsltest = "test.xsl"
# OP We use copy instead of copy2 to update the creation date
# So we can clean the LOGS directories easily
for f in files_to_copy:
- f_init = os.path.join(xslDir, f)
- f_target = os.path.join(logDir, f)
- if not os.path.isfile(f_target): # do not overrride
- shutil.copy(f_init, logDir)
-
+ f_init = os.path.join(xslDir, f)
+ f_target = os.path.join(logDir, f)
+ if not os.path.isfile(f_target): # do not overrride
+ shutil.copy(f_init, logDir)
+
# Dump the config in a pyconf file in the log directory
- dumpedPyconfFileName = (self.config.VARS.datehour
- + "_"
- + self.config.VARS.command
- + ".pyconf")
- dumpedPyconfFilePath = os.path.join(logDir, 'OUT', dumpedPyconfFileName)
+ dumpedPyconfFileName = (
+ self.config.VARS.datehour + "_" + self.config.VARS.command + ".pyconf"
+ )
+ dumpedPyconfFilePath = os.path.join(logDir, "OUT", dumpedPyconfFileName)
try:
- f = open(dumpedPyconfFilePath, 'w')
+ f = open(dumpedPyconfFilePath, "w")
self.config.__save__(f)
f.close()
except IOError:
pass
+
def date_to_datetime(date):
"""\
From a string date in format YYYYMMDD_HHMMSS
S = date[13:15]
return Y, m, dd, H, M, S
+
def timedelta_total_seconds(timedelta):
"""\
Replace total_seconds from datetime module
:rtype: float
"""
return (
- timedelta.microseconds + 0.0 +
- (timedelta.seconds + timedelta.days * 24 * 3600) * 10 ** 6) / 10 ** 6
-
+ timedelta.microseconds
+ + 0.0
+ + (timedelta.seconds + timedelta.days * 24 * 3600) * 10 ** 6
+ ) / 10 ** 6
+
+
def show_command_log(logFilePath, cmd, application, notShownCommands):
"""\
Used in updateHatXml.
# Do not show
if cmd in notShownCommands:
return False, None, None
-
+
# Get the application of the log file
try:
logFileXml = src.xmlManager.ReadXmlFile(logFilePath)
return False, None, None
try:
- if 'application' in logFileXml.xmlroot.keys():
- appliLog = logFileXml.xmlroot.get('application')
- launched_cmd = logFileXml.xmlroot.find('Site').attrib['launchedCommand']
- # if it corresponds, then the log has to be shown
- if appliLog == application:
- return True, appliLog, launched_cmd
- elif application != 'None':
- return False, appliLog, launched_cmd
-
- return True, appliLog, launched_cmd
+ if "application" in logFileXml.xmlroot.keys():
+ appliLog = logFileXml.xmlroot.get("application")
+ launched_cmd = logFileXml.xmlroot.find("Site").attrib["launchedCommand"]
+ # if it corresponds, then the log has to be shown
+ if appliLog == application:
+ return True, appliLog, launched_cmd
+ elif application != "None":
+ return False, appliLog, launched_cmd
+
+ return True, appliLog, launched_cmd
except Exception as e:
msg = _("WARNING: the log file %s cannot be parsed:" % logFilePath)
sys.stdout.write(printcolors.printcWarning("%s\n%s\n" % (msg, e)))
return False, None, None
- if application == 'None':
- return True, None, None
-
+ if application == "None":
+ return True, None, None
+
return False, None, None
+
def list_log_file(dirPath, expression):
"""Find all files corresponding to expression in dirPath
-
+
:param dirPath str: the directory where to search the files
:param expression str: the regular expression of files to find
:return: the list of files path and informations about it
if oExpr.search(fileName):
file_name = fileName
if fileName.startswith("micro_"):
- file_name = fileName[len("micro_"):]
+ file_name = fileName[len("micro_") :]
# get date and hour and format it
- date_hour_cmd_host = file_name.split('_')
+ date_hour_cmd_host = file_name.split("_")
date_not_formated = date_hour_cmd_host[0]
- date = "%s/%s/%s" % (date_not_formated[6:8],
- date_not_formated[4:6],
- date_not_formated[0:4])
+ date = "%s/%s/%s" % (
+ date_not_formated[6:8],
+ date_not_formated[4:6],
+ date_not_formated[0:4],
+ )
hour_not_formated = date_hour_cmd_host[1]
- hour = "%s:%s:%s" % (hour_not_formated[0:2],
- hour_not_formated[2:4],
- hour_not_formated[4:6])
+ hour = "%s:%s:%s" % (
+ hour_not_formated[0:2],
+ hour_not_formated[2:4],
+ hour_not_formated[4:6],
+ )
if len(date_hour_cmd_host) < 4:
- cmd = date_hour_cmd_host[2][:-len('.xml')]
+ cmd = date_hour_cmd_host[2][: -len(".xml")]
host = ""
else:
cmd = date_hour_cmd_host[2]
- host = date_hour_cmd_host[3][:-len('.xml')]
- lRes.append((os.path.join(dirPath, fileName),
- date_not_formated,
- date,
- hour_not_formated,
- hour,
- cmd,
- host))
+ host = date_hour_cmd_host[3][: -len(".xml")]
+ lRes.append(
+ (
+ os.path.join(dirPath, fileName),
+ date_not_formated,
+ date,
+ hour_not_formated,
+ hour,
+ cmd,
+ host,
+ )
+ )
return lRes
-def update_hat_xml(logDir, application=None, notShownCommands = []):
+
+def update_hat_xml(logDir, application=None, notShownCommands=[]):
"""\
Create the xml file in logDir that contain all the xml file
and have a name like YYYYMMDD_HHMMSS_namecmd.xml
:param application str: the name of the application if there is any
"""
# Create an instance of XmlLogFile class to create hat.xml file
- xmlHatFilePath = os.path.join(logDir, 'hat.xml')
- xmlHat = src.xmlManager.XmlLogFile(xmlHatFilePath, "LOGlist", {"application" : application})
- # parse the log directory to find all the command logs,
+ xmlHatFilePath = os.path.join(logDir, "hat.xml")
+ xmlHat = src.xmlManager.XmlLogFile(
+ xmlHatFilePath, "LOGlist", {"application": application}
+ )
+ # parse the log directory to find all the command logs,
# then add it to the xml file
lLogFile = list_log_file(logDir, log_macro_command_file_expression)
for filePath, __, date, __, hour, cmd, __ in lLogFile:
- showLog, cmdAppli, full_cmd = show_command_log(filePath, cmd,
- application, notShownCommands)
- #if cmd not in notShownCommands:
+ showLog, cmdAppli, full_cmd = show_command_log(
+ filePath, cmd, application, notShownCommands
+ )
+ # if cmd not in notShownCommands:
if showLog:
# add a node to the hat.xml file
- xmlHat.add_simple_node("LogCommand",
- text=os.path.basename(filePath),
- attrib = {"date" : date,
- "hour" : hour,
- "cmd" : cmd,
- "application" : cmdAppli,
- "full_command" : full_cmd})
-
+ xmlHat.add_simple_node(
+ "LogCommand",
+ text=os.path.basename(filePath),
+ attrib={
+ "date": date,
+ "hour": hour,
+ "cmd": cmd,
+ "application": cmdAppli,
+ "full_command": full_cmd,
+ },
+ )
+
# Write the file on the hard drive
- xmlHat.write_tree('hat.xsl')
+ xmlHat.write_tree("hat.xsl")
# Sometimes other users will make 'sat log' and update this file
- os.chmod(xmlHatFilePath,
- stat.S_IRUSR |
- stat.S_IRGRP |
- stat.S_IROTH |
- stat.S_IWUSR |
- stat.S_IWGRP |
- stat.S_IWOTH )
-
+ os.chmod(
+ xmlHatFilePath,
+ stat.S_IRUSR
+ | stat.S_IRGRP
+ | stat.S_IROTH
+ | stat.S_IWUSR
+ | stat.S_IWGRP
+ | stat.S_IWOTH,
+ )
# TODO for future
# suppose only one logger in sat5.1
_currentLogger = []
+
def getCurrentLogger():
- """get current logging logger, set as DefaultLogger if not set yet"""
- if len(_currentLogger) == 0:
+ """get current logging logger, set as DefaultLogger if not set yet"""
+ if len(_currentLogger) == 0:
+ import src.loggingSimple as LOGSI
+
+ logger = LOGSI.getDefaultLogger()
+ _currentLogger.append(logger)
+ logger.warning("set by default current logger as %s" % logger.name)
+ return _currentLogger[0]
+
+
+def getDefaultLogger():
+ """get simple logging logger DefaultLogger, set it as current"""
import src.loggingSimple as LOGSI
+
logger = LOGSI.getDefaultLogger()
- _currentLogger.append(logger)
- logger.warning("set by default current logger as %s" % logger.name)
- return _currentLogger[0]
+ setCurrentLogger(logger) # set it as current
+ return logger
-def getDefaultLogger():
- """get simple logging logger DefaultLogger, set it as current"""
- import src.loggingSimple as LOGSI
- logger = LOGSI.getDefaultLogger()
- setCurrentLogger(logger) # set it as current
- return logger
def getUnittestLogger():
- """get simple logging logger UnittestLogger, set it as current"""
- import src.loggingSimple as LOGSI
- logger = LOGSI.getUnittestLogger()
- setCurrentLogger(logger) # set it as current
- return logger
+ """get simple logging logger UnittestLogger, set it as current"""
+ import src.loggingSimple as LOGSI
+
+ logger = LOGSI.getUnittestLogger()
+ setCurrentLogger(logger) # set it as current
+ return logger
+
def setCurrentLogger(logger):
- """temporary send all in stdout as simple logging logger"""
- if len(_currentLogger) == 0:
- _currentLogger.append(logger)
- logger.debug("set current logger as %s" % logger.name)
- else:
- if _currentLogger[0].name != logger.name:
- # logger.debug("quit current logger as default %s" % _currentLogger[0].name)
- _currentLogger[0] = logger
- logger.warning("change current logger as %s" % logger.name)
- return _currentLogger[0]
+ """temporary send all in stdout as simple logging logger"""
+ if len(_currentLogger) == 0:
+ _currentLogger.append(logger)
+ logger.debug("set current logger as %s" % logger.name)
+ else:
+ if _currentLogger[0].name != logger.name:
+ # logger.debug("quit current logger as default %s" % _currentLogger[0].name)
+ _currentLogger[0] = logger
+ logger.warning("change current logger as %s" % logger.name)
+ return _currentLogger[0]
+
def isCurrentLoggerUnittest():
logger = getCurrentLogger()
if "Unittest" in logger.name:
- res = True
+ res = True
else:
- res = False
- #DBG.write("isCurrentLoggerUnittest %s" % logger.name, res)
+ res = False
+ # DBG.write("isCurrentLoggerUnittest %s" % logger.name, res)
return res
+
def sendMessageToCurrentLogger(message, level):
"""
assume relay from obsolescent
"""
logger = getCurrentLogger()
if level is None:
- lev = 2
+ lev = 2
else:
- lev = level
+ lev = level
if lev <= 1:
- logger.critical(message)
- return
+ logger.critical(message)
+ return
if lev == 2:
- logger.warning(message)
- return
+ logger.warning(message)
+ return
if lev == 3:
- logger.info(message)
- return
+ logger.info(message)
+ return
if lev == 4:
- logger.step(message)
- return
+ logger.step(message)
+ return
if lev == 5:
- logger.trace(message)
- return
+ logger.trace(message)
+ return
if lev >= 6:
- logger.debug(message)
- return
+ logger.debug(message)
+ return
msg = "What is this level: '%s' for message:\n%s" % (level, message)
logger.warning(msg)
return
_verbose = False
_name = "loggingSimple"
-_loggerDefaultName = 'SimpleDefaultLogger'
-_loggerUnittestName = 'SimpleUnittestLogger'
+_loggerDefaultName = "SimpleDefaultLogger"
+_loggerUnittestName = "SimpleUnittestLogger"
_STEP = LOGI.INFO - 1 # step level is just below INFO
_TRACE = LOGI.INFO - 2 # trace level is just below STEP
# utilities methods
#################################################################
+
def filterLevel(aLevel):
- """
- filter levels logging values from firsts characters levels.
- No case sensitive
-
- | example:
- | 'i' -> 'INFO'
- | 'cRiT' -> 'CRITICAL'
- """
- aLev = aLevel.upper()
- knownLevels = _knownLevels
- maxLen = max([len(i) for i in knownLevels])
- for i in range(maxLen):
- for lev in knownLevels:
- if aLev == lev[:i]:
- # DBG.write("filterLevel", "%s -> %s" % (aLevel, lev))
- return lev
- msg = "Unknown level '%s', accepted are:\n%s" % (aLev, ", ".join(knownLevels))
- return msg
- # raise Exception(msg)
+ """
+ filter levels logging values from firsts characters levels.
+ No case sensitive
+
+ | example:
+ | 'i' -> 'INFO'
+ | 'cRiT' -> 'CRITICAL'
+ """
+ aLev = aLevel.upper()
+ knownLevels = _knownLevels
+ maxLen = max([len(i) for i in knownLevels])
+ for i in range(maxLen):
+ for lev in knownLevels:
+ if aLev == lev[:i]:
+ # DBG.write("filterLevel", "%s -> %s" % (aLevel, lev))
+ return lev
+ msg = "Unknown level '%s', accepted are:\n%s" % (aLev, ", ".join(knownLevels))
+ return msg
+ # raise Exception(msg)
def indent(msg, nb, car=" "):
- """indent nb car (spaces) multi lines message except first one"""
- s = msg.split("\n")
- res = ("\n" + car * nb).join(s)
- return res
+ """indent nb car (spaces) multi lines message except first one"""
+ s = msg.split("\n")
+ res = ("\n" + car * nb).join(s)
+ return res
def indentUnittest(msg, prefix=" | "):
- """
- indent multi lines message except first one with prefix.
- prefix default is designed for less spaces for size logs files
- and keep logs human eye readable
- """
- s = msg.split("\n")
- res = ("\n" + prefix).join(s)
- return res
+ """
+ indent multi lines message except first one with prefix.
+ prefix default is designed for less spaces for size logs files
+ and keep logs human eye readable
+ """
+ s = msg.split("\n")
+ res = ("\n" + prefix).join(s)
+ return res
def log(msg, force=False):
- """elementary log when no logging.Logger yet"""
- prefix = "---- %s.log: " % _name
- nb = len(prefix)
- if _verbose or force:
- print(prefix + indent(msg, nb))
+ """elementary log when no logging.Logger yet"""
+ prefix = "---- %s.log: " % _name
+ nb = len(prefix)
+ if _verbose or force:
+ print(prefix + indent(msg, nb))
# just for debug info where is import logging
def getStrDirLogger(logger):
- """
- Returns multi line string for logger description, with dir(logger).
- Used for debug
- """
- lgr = logger # shortcut
- msg = "%s(name=%s, dateLogger=%s):\n%s\n"
- cName = lgr.__class__.__name__
- res = msg % (cName, lgr.name, lgr.dateLogger, PP.pformat(dir(lgr)))
- return res
+ """
+ Returns multi line string for logger description, with dir(logger).
+ Used for debug
+ """
+ lgr = logger # shortcut
+ msg = "%s(name=%s, dateLogger=%s):\n%s\n"
+ cName = lgr.__class__.__name__
+ res = msg % (cName, lgr.name, lgr.dateLogger, PP.pformat(dir(lgr)))
+ return res
def getStrHandler(handler):
- """
- Returns one line string for handler description
- (as inexisting __repr__)
- to avoid create inherited classe(s) handler
- """
- h = handler # shortcut
- msg = "%s(name=%s)"
- cName = h.__class__.__name__
- # get_name absent in logging 0.5.0.5 python 2.6
- res = msg % (cName, h._name)
- return res
+ """
+ Returns one line string for handler description
+ (as inexisting __repr__)
+ to avoid create inherited classe(s) handler
+ """
+ h = handler # shortcut
+ msg = "%s(name=%s)"
+ cName = h.__class__.__name__
+ # get_name absent in logging 0.5.0.5 python 2.6
+ res = msg % (cName, h._name)
+ return res
def getStrShort(msg):
- """Returns short string for msg (as first caracters without line feed"""
- # log("getStrShort " + str(msg), True)
- res = msg.replace("\n", "//")[0:30]
- return res
+ """Returns short string for msg (as first caracters without line feed"""
+ # log("getStrShort " + str(msg), True)
+ res = msg.replace("\n", "//")[0:30]
+ return res
def getStrLogRecord(logRecord):
- """
- Returns one line string for simple logging LogRecord description
- """
- msg = "LogRecord(level='%s', msg='%s...')"
- shortMsg = getStrShort(logRecord.msg)
- levelName = logRecord.levelname
- res = msg % (levelName, shortMsg)
- return res
+ """
+ Returns one line string for simple logging LogRecord description
+ """
+ msg = "LogRecord(level='%s', msg='%s...')"
+ shortMsg = getStrShort(logRecord.msg)
+ levelName = logRecord.levelname
+ res = msg % (levelName, shortMsg)
+ return res
def getListOfStrLogRecord(listOfLogRecord):
- """
- Returns one line string for logging LogRecord description
- """
- res = [getStrLogRecord(l) for l in listOfLogRecord]
- return res
+ """
+ Returns one line string for logging LogRecord description
+ """
+ res = [getStrLogRecord(l) for l in listOfLogRecord]
+ return res
#################################################################
#################################################################
try:
- unicode
- _unicode = True
+ unicode
+ _unicode = True
except NameError:
- _unicode = False
+ _unicode = False
def getMessage(self):
- """
- modified from logging.__init__.LogRecord.getMessage,
- better message on format error
- Return the message for this LogRecord.
-
- Return the message for this LogRecord after merging any user-supplied
- arguments with the message.
- """
- if not _unicode: # if no unicode support...
- msg = str(self.msg)
- else:
- msg = self.msg
- if not isinstance(msg, basestring):
- try:
+ """
+ modified from logging.__init__.LogRecord.getMessage,
+ better message on format error
+ Return the message for this LogRecord.
+
+ Return the message for this LogRecord after merging any user-supplied
+ arguments with the message.
+ """
+ if not _unicode: # if no unicode support...
msg = str(self.msg)
- except UnicodeError:
- msg = self.msg # Defer encoding till later
- if self.args:
- try: # better message on format error
- msg = msg % self.args
- except Exception as e:
- msg = "ERROR: %s with args %s" % (msg, PP.pformat(self.args))
- log(msg, True)
- return msg
+ else:
+ msg = self.msg
+ if not isinstance(msg, basestring):
+ try:
+ msg = str(self.msg)
+ except UnicodeError:
+ msg = self.msg # Defer encoding till later
+ if self.args:
+ try: # better message on format error
+ msg = msg % self.args
+ except Exception as e:
+ msg = "ERROR: %s with args %s" % (msg, PP.pformat(self.args))
+ log(msg, True)
+ return msg
LOGI.LogRecord.getMessage = getMessage # better message if error
#################################################################
-class LoggerSimple(LOGI.Logger, object): # object force new-style classes in logging 0.5.0.5 python 2.6
- """
- Inherited class logging.Logger for logger salomeTools
-
- | add a level STEP as log.step(msg)
- | add a level TRACE as log.trace(msg)
- | below log.info(msg)
- | above log.debug(msg)
- | to assume message step inside files xml 'command's internal traces'
- | to assume store long log asci in files txt outside files xml
- |
- | see: /usr/lib64/python2.7/logging/__init__.py etc.
- """
-
- def __init__(self, name, level=LOGI.INFO):
- """
- Initialize the logger with a name and an optional level.
- """
- super(LoggerSimple, self).__init__(name, level)
- LOGI.addLevelName(_STEP, "STEP")
- LOGI.addLevelName(_TRACE, "TRACE")
- self.dateLogger = "NoDateLogger"
- self.dateHour = None # datehour of main command
- self.isClosed = False
- self.STEP = _STEP
- self.TRACE = _TRACE
-
- def close(self):
+class LoggerSimple(
+ LOGI.Logger, object
+): # object force new-style classes in logging 0.5.0.5 python 2.6
"""
- final stuff for logger, done at end salomeTools
- flushed and closed xml files have to be not overriden/appended
+ Inherited class logging.Logger for logger salomeTools
+
+ | add a level STEP as log.step(msg)
+ | add a level TRACE as log.trace(msg)
+ | below log.info(msg)
+ | above log.debug(msg)
+ | to assume message step inside files xml 'command's internal traces'
+ | to assume store long log asci in files txt outside files xml
+ |
+ | see: /usr/lib64/python2.7/logging/__init__.py etc.
"""
- if self.isClosed:
- raise Exception("logger closed yet: %s" % self)
- log("close stuff logger %s" % self) # getStrDirLogger(self)
- for handl in list(self.handlers): # get original list
- log("close stuff handler %s" % getStrHandler(handl))
- handl.close() # Tidy up any resources used by the handler.
- self.removeHandler(handl)
- # todo etc
- self.isClosed = True # done at end of execution
- return
- def __repr__(self):
- """one line string representation"""
- msg = "%s(name=%s, dateLogger=%s, handlers=%s)"
- cName = self.__class__.__name__
- h = [getStrHandler(h) for h in self.handlers]
- h = "[" + ", ".join(h) + "]"
- res = msg % (cName, self.name, self.dateLogger, h)
- return res
+ def __init__(self, name, level=LOGI.INFO):
+ """
+ Initialize the logger with a name and an optional level.
+ """
+ super(LoggerSimple, self).__init__(name, level)
+ LOGI.addLevelName(_STEP, "STEP")
+ LOGI.addLevelName(_TRACE, "TRACE")
+ self.dateLogger = "NoDateLogger"
+ self.dateHour = None # datehour of main command
+ self.isClosed = False
+ self.STEP = _STEP
+ self.TRACE = _TRACE
+
+ def close(self):
+ """
+ final stuff for logger, done at end salomeTools
+ flushed and closed xml files have to be not overriden/appended
+ """
+ if self.isClosed:
+ raise Exception("logger closed yet: %s" % self)
+ log("close stuff logger %s" % self) # getStrDirLogger(self)
+ for handl in list(self.handlers): # get original list
+ log("close stuff handler %s" % getStrHandler(handl))
+ handl.close() # Tidy up any resources used by the handler.
+ self.removeHandler(handl)
+ # todo etc
+ self.isClosed = True # done at end of execution
+ return
+
+ def __repr__(self):
+ """one line string representation"""
+ msg = "%s(name=%s, dateLogger=%s, handlers=%s)"
+ cName = self.__class__.__name__
+ h = [getStrHandler(h) for h in self.handlers]
+ h = "[" + ", ".join(h) + "]"
+ res = msg % (cName, self.name, self.dateLogger, h)
+ return res
+
+ def trace(self, msg, *args, **kwargs):
+ """
+ Log 'msg % args' with severity '_TRACE'.
+ """
+ log("trace stuff logger '%s' msg '%s...'" % (self.name, getStrShort(msg)))
+ if self.isEnabledFor(_TRACE):
+ self._log(_TRACE, msg, args, **kwargs)
+
+ def step(self, msg, *args, **kwargs):
+ """
+ Log 'msg % args' with severity '_STEP'.
+ """
+ log("step stuff logger '%s' msg '%s...'" % (self.name, getStrShort(msg)))
+ if self.isEnabledFor(_STEP):
+ self._log(_STEP, msg, args, **kwargs)
+
+ def setLevelMainHandler(self, level):
+ handl = self.handlers[0] # get main handler
+ log("setLevelMainHandler %s" % level)
+ handl.setLevel(level)
- def trace(self, msg, *args, **kwargs):
- """
- Log 'msg % args' with severity '_TRACE'.
- """
- log("trace stuff logger '%s' msg '%s...'" % (self.name, getStrShort(msg)))
- if self.isEnabledFor(_TRACE):
- self._log(_TRACE, msg, args, **kwargs)
- def step(self, msg, *args, **kwargs):
+#################################################################
+class UnittestFormatter(
+ LOGI.Formatter, object
+): # object force new-style classes in logging 0.5.0.5 python 2.6
"""
- Log 'msg % args' with severity '_STEP'.
+ this formatter prefixes level name and indents all messages
"""
- log("step stuff logger '%s' msg '%s...'" % (self.name, getStrShort(msg)))
- if self.isEnabledFor(_STEP):
- self._log(_STEP, msg, args, **kwargs)
- def setLevelMainHandler(self, level):
- handl = self.handlers[0] # get main handler
- log("setLevelMainHandler %s" % level)
- handl.setLevel(level)
+ def format(self, record):
+ # print "", record.levelname #type(record), dir(record)
+ # nb = len("2018-03-17 12:15:41 :: INFO :: ")
+ res = super(UnittestFormatter, self).format(record)
+ res = indentUnittest(res)
+ return res
#################################################################
-class UnittestFormatter(LOGI.Formatter, object): # object force new-style classes in logging 0.5.0.5 python 2.6
- """
- this formatter prefixes level name and indents all messages
- """
- def format(self, record):
- # print "", record.levelname #type(record), dir(record)
- # nb = len("2018-03-17 12:15:41 :: INFO :: ")
- res = super(UnittestFormatter, self).format(record)
- res = indentUnittest(res)
- return res
+class DefaultFormatter(
+ LOGI.Formatter, object
+): # object force new-style classes in logging 0.5.0.5 python 2.6
+ """
+ this formatter prefixes level name and indents all messages but INFO stay "as it"
+ """
-#################################################################
-class DefaultFormatter(LOGI.Formatter, object): # object force new-style classes in logging 0.5.0.5 python 2.6
- """
- this formatter prefixes level name and indents all messages but INFO stay "as it"
- """
- def format(self, record):
- # print "", record.levelname #type(record), dir(record)
- # nb = len("2018-03-17 12:15:41 :: INFO :: ")
- if record.levelname == "INFO":
- res = record.getMessage()
- else:
- res = super(DefaultFormatter, self).format(record)
- res = indentUnittest(res)
- return res
+ def format(self, record):
+ # print "", record.levelname #type(record), dir(record)
+ # nb = len("2018-03-17 12:15:41 :: INFO :: ")
+ if record.levelname == "INFO":
+ res = record.getMessage()
+ else:
+ res = super(DefaultFormatter, self).format(record)
+ res = indentUnittest(res)
+ return res
#################################################################
class UnittestStream(object):
- """
- write my stream class
- only write and flush are used for the streaming
+ """
+ write my stream class
+ only write and flush are used for the streaming
- | https://docs.python.org/2/library/logging.handlers.html
- | https://stackoverflow.com/questions/31999627/storing-logger-messages-in-a-string
- """
+ | https://docs.python.org/2/library/logging.handlers.html
+ | https://stackoverflow.com/questions/31999627/storing-logger-messages-in-a-string
+ """
- def __init__(self):
- self._logs = ''
+ def __init__(self):
+ self._logs = ""
- def getLogs(self):
- return self._logs
+ def getLogs(self):
+ return self._logs
- def getLogsAndClear(self):
- res = self._logs
- self._logs = ''
- return res
+ def getLogsAndClear(self):
+ res = self._logs
+ self._logs = ""
+ return res
- def write(self, astr):
- """final method called when message is logged"""
- # log("UnittestStream.write('%s')" % astr, True) # for debug ...
- self._logs += astr
+ def write(self, astr):
+ """final method called when message is logged"""
+ # log("UnittestStream.write('%s')" % astr, True) # for debug ...
+ self._logs += astr
- def flush(self):
- pass
+ def flush(self):
+ pass
- def __str__(self):
- return self._logs
+ def __str__(self):
+ return self._logs
#################################################################
-class StreamHandlerSimple(LOGI.StreamHandler, object): # object force new-style classes in logging 0.5.0.5 python 2.6
- """
- A handler class which writes logging records, appropriately formatted,
- to a stream. Note that this class does not close the stream, as
- sys.stdout or sys.stderr may be used.
-
- from logging.StreamHandler class,
- modified for 'no return' mode line if '...' at end of record message
- """
-
- def emit(self, record):
+class StreamHandlerSimple(
+ LOGI.StreamHandler, object
+): # object force new-style classes in logging 0.5.0.5 python 2.6
"""
- Emit a record.
-
- If a formatter is specified, it is used to format the record.
- The record is then written to the stream with a trailing newline. If
- exception information is present, it is formatted using
- traceback.print_exception and appended to the stream. If the stream
- has an 'encoding' attribute, it is used to determine how to do the
- output to the stream.
+ A handler class which writes logging records, appropriately formatted,
+ to a stream. Note that this class does not close the stream, as
+ sys.stdout or sys.stderr may be used.
+
+ from logging.StreamHandler class,
+ modified for 'no return' mode line if '...' at end of record message
"""
- # log("StreamHandlerSimple.emit('%s')" % record, True) # for debug ...
- try:
- msg = self.format(record)
- stream = self.stream
- fs = '%s\n'
- ufs = u'%s\n'
- if not _unicode: # if no unicode support...
- stream.write(fs % msg)
- else:
- try:
- if (isinstance(msg, unicode) and
- getattr(stream, 'encoding', None)):
- # ufs = u'%s\n'
- try:
- stream.write(ufs % msg)
- except UnicodeEncodeError:
- # Printing to terminals sometimes fails. For example,
- # with an encoding of 'cp1251', the above write will
- # work if written to a stream opened or wrapped by
- # the codecs module, but fail when writing to a
- # terminal even when the codepage is set to cp1251.
- # An extra encoding step seems to be needed.
- stream.write((ufs % msg).encode(stream.encoding))
- else:
- stream.write(fs % msg)
- except UnicodeError:
- stream.write(fs % msg.encode("UTF-8"))
- self.flush()
- except (KeyboardInterrupt, SystemExit):
- raise
- except:
- self.handleError(record)
+ def emit(self, record):
+ """
+ Emit a record.
+
+ If a formatter is specified, it is used to format the record.
+ The record is then written to the stream with a trailing newline. If
+ exception information is present, it is formatted using
+ traceback.print_exception and appended to the stream. If the stream
+ has an 'encoding' attribute, it is used to determine how to do the
+ output to the stream.
+ """
+ # log("StreamHandlerSimple.emit('%s')" % record, True) # for debug ...
+ try:
+ msg = self.format(record)
+ stream = self.stream
+ fs = "%s\n"
+ ufs = u"%s\n"
+ if not _unicode: # if no unicode support...
+ stream.write(fs % msg)
+ else:
+ try:
+ if isinstance(msg, unicode) and getattr(stream, "encoding", None):
+ # ufs = u'%s\n'
+ try:
+ stream.write(ufs % msg)
+ except UnicodeEncodeError:
+ # Printing to terminals sometimes fails. For example,
+ # with an encoding of 'cp1251', the above write will
+ # work if written to a stream opened or wrapped by
+ # the codecs module, but fail when writing to a
+ # terminal even when the codepage is set to cp1251.
+ # An extra encoding step seems to be needed.
+ stream.write((ufs % msg).encode(stream.encoding))
+ else:
+ stream.write(fs % msg)
+ except UnicodeError:
+ stream.write(fs % msg.encode("UTF-8"))
+ self.flush()
+ except (KeyboardInterrupt, SystemExit):
+ raise
+ except:
+ self.handleError(record)
#################################################################
# no more need
#################################################################
def initLoggerAsDefault(logger, fmt=None, level=None):
- """
- init logger as prefixed message and indented message if multi line
- exept info() outed 'as it' without any format.
- level could be modified during execution
- """
- log("initLoggerAsDefault name=%s\nfmt='%s' level='%s'" % (logger.name, fmt, level))
- #handler = StreamHandlerSimple(sys.stdout) # Logging vers console
- handler = LOGI.StreamHandler(sys.stdout) # Logging vers console
- # set_name absent in logging 0.5.0.5 python 2.6
- handler._name = logger.name + "_console"
- if fmt is not None:
- # formatter = UnittestFormatter(fmt, "%y-%m-%d %H:%M:%S")
- formatter = DefaultFormatter(fmt, "%y-%m-%d %H:%M:%S")
- handler.setFormatter(formatter)
- handler.idCommandHandlers = 0
- logger.addHandler(handler)
- # as RootLogger is level WARNING
- # my logger is not notset but low, handlers needs setlevel greater
- logger.setLevel(LOGI.DEBUG)
- # import src/debug as DBG
- # tmp = (logger.getEffectiveLevel(), LOGI.NOTSET, logger.level, logger.parent.level)
- # DBG.write("logger levels tmp, True)
- if level is not None: # level could be modified during execution
- handler.setLevel(level) # on screen log as user wants
- else:
- handler.setLevel(LOGI.INFO) # on screen no log step, which are in xml files
- return
+ """
+ init logger as prefixed message and indented message if multi line
+ exept info() outed 'as it' without any format.
+ level could be modified during execution
+ """
+ log("initLoggerAsDefault name=%s\nfmt='%s' level='%s'" % (logger.name, fmt, level))
+ # handler = StreamHandlerSimple(sys.stdout) # Logging vers console
+ handler = LOGI.StreamHandler(sys.stdout) # Logging vers console
+ # set_name absent in logging 0.5.0.5 python 2.6
+ handler._name = logger.name + "_console"
+ if fmt is not None:
+ # formatter = UnittestFormatter(fmt, "%y-%m-%d %H:%M:%S")
+ formatter = DefaultFormatter(fmt, "%y-%m-%d %H:%M:%S")
+ handler.setFormatter(formatter)
+ handler.idCommandHandlers = 0
+ logger.addHandler(handler)
+ # as RootLogger is level WARNING
+ # my logger is not notset but low, handlers needs setlevel greater
+ logger.setLevel(LOGI.DEBUG)
+ # import src/debug as DBG
+ # tmp = (logger.getEffectiveLevel(), LOGI.NOTSET, logger.level, logger.parent.level)
+ # DBG.write("logger levels tmp, True)
+ if level is not None: # level could be modified during execution
+ handler.setLevel(level) # on screen log as user wants
+ else:
+ handler.setLevel(LOGI.INFO) # on screen no log step, which are in xml files
+ return
def initLoggerAsUnittest(logger, fmt=None, level=None):
- """
- init logger as silent on stdout/stderr
- used for retrieve messages in memory for post execution unittest
- https://docs.python.org/2/library/logging.handlers.html
- """
- log("initLoggerAsUnittest name=%s\nfmt='%s' level='%s'" % (logger.name, fmt, level))
- stream = UnittestStream()
- handler = LOGI.StreamHandler(stream) # Logging vers stream
- # set_name absent in logging 0.5.0.5 python 2.6
- handler._name = logger.name + "_unittest"
- if fmt is not None:
- # formatter = LOGI.Formatter(fmt, "%Y-%m-%d %H:%M:%S")
- formatter = UnittestFormatter(fmt, "%Y-%m-%d %H:%M:%S")
- handler.setFormatter(formatter)
- handler.idCommandHandlers = 0
- logger.addHandler(handler)
- logger.stream = stream
- logger.getLogs = stream.getLogs
- logger.getLogsAndClear = stream.getLogsAndClear
- if level is not None:
- logger.setLevel(level)
- else:
- logger.setLevel(LOGI.DEBUG)
+ """
+ init logger as silent on stdout/stderr
+ used for retrieve messages in memory for post execution unittest
+ https://docs.python.org/2/library/logging.handlers.html
+ """
+ log("initLoggerAsUnittest name=%s\nfmt='%s' level='%s'" % (logger.name, fmt, level))
+ stream = UnittestStream()
+ handler = LOGI.StreamHandler(stream) # Logging vers stream
+ # set_name absent in logging 0.5.0.5 python 2.6
+ handler._name = logger.name + "_unittest"
+ if fmt is not None:
+ # formatter = LOGI.Formatter(fmt, "%Y-%m-%d %H:%M:%S")
+ formatter = UnittestFormatter(fmt, "%Y-%m-%d %H:%M:%S")
+ handler.setFormatter(formatter)
+ handler.idCommandHandlers = 0
+ logger.addHandler(handler)
+ logger.stream = stream
+ logger.getLogs = stream.getLogs
+ logger.getLogsAndClear = stream.getLogsAndClear
+ if level is not None:
+ logger.setLevel(level)
+ else:
+ logger.setLevel(LOGI.DEBUG)
def getDefaultLogger():
- log("getDefaultLogger %s" % _loggerDefaultName)
- # case multithread may be problem as not LOGI._acquireLock()
- previousClass = LOGI._loggerClass
- LOGI.setLoggerClass(LoggerSimple) # to get LoggerSimple instance with trace etc.
- res = LOGI.getLogger(_loggerDefaultName)
- LOGI.setLoggerClass(previousClass)
- return res
+ log("getDefaultLogger %s" % _loggerDefaultName)
+ # case multithread may be problem as not LOGI._acquireLock()
+ previousClass = LOGI._loggerClass
+ LOGI.setLoggerClass(LoggerSimple) # to get LoggerSimple instance with trace etc.
+ res = LOGI.getLogger(_loggerDefaultName)
+ LOGI.setLoggerClass(previousClass)
+ return res
def getUnittestLogger():
- log("getUnittestLogger %s" % _loggerUnittestName)
- # case multithread may be problem as not LOGI._acquireLock()
- previousClass = LOGI._loggerClass
- LOGI.setLoggerClass(LoggerSimple) # to get LoggerSimple instance with trace etc.
- res = LOGI.getLogger(_loggerUnittestName)
- LOGI.setLoggerClass(previousClass)
- return res
+ log("getUnittestLogger %s" % _loggerUnittestName)
+ # case multithread may be problem as not LOGI._acquireLock()
+ previousClass = LOGI._loggerClass
+ LOGI.setLoggerClass(LoggerSimple) # to get LoggerSimple instance with trace etc.
+ res = LOGI.getLogger(_loggerUnittestName)
+ LOGI.setLoggerClass(previousClass)
+ return res
#################################################################
# small tests as demonstration, see unittest also
#################################################################
def testLogger_2(logger):
- """small test"""
- # print getStrDirLogger(logger)
- logger.debug('test logger debug')
- logger.trace('test logger trace')
- logger.info('test logger info')
- logger.warning('test logger warning')
- logger.error('test logger error')
- logger.critical('test logger critical')
- logger.info('\ntest logger info:\n- second line\n- third line\n')
- logger.warning('test logger warning:\n- second line\n- third line')
+ """small test"""
+ # print getStrDirLogger(logger)
+ logger.debug("test logger debug")
+ logger.trace("test logger trace")
+ logger.info("test logger info")
+ logger.warning("test logger warning")
+ logger.error("test logger error")
+ logger.critical("test logger critical")
+ logger.info("\ntest logger info:\n- second line\n- third line\n")
+ logger.warning("test logger warning:\n- second line\n- third line")
-def testMain_2():
- print("\n**** DEFAULT logger")
- logdef = getDefaultLogger()
- # use of setColorLevelname <color>...<reset>, so do not use %(levelname)-8s
- initLoggerAsDefault(logdef, '%(levelname)-8s :: %(message)s', level=LOGI.DEBUG)
- testLogger_2(logdef)
- print("\n**** UNITTEST logger")
- loguni = getUnittestLogger()
- initLoggerAsUnittest(loguni, '%(asctime)s :: %(levelname)-8s :: %(message)s', level=LOGI.DEBUG)
- testLogger_2(loguni) # is silent
- # log("loguni.getLogs():\n%s" % loguni.getLogs())
- print("loguni.streamUnittest:\n%s" % loguni.getLogs())
+def testMain_2():
+ print("\n**** DEFAULT logger")
+ logdef = getDefaultLogger()
+ # use of setColorLevelname <color>...<reset>, so do not use %(levelname)-8s
+ initLoggerAsDefault(logdef, "%(levelname)-8s :: %(message)s", level=LOGI.DEBUG)
+ testLogger_2(logdef)
+
+ print("\n**** UNITTEST logger")
+ loguni = getUnittestLogger()
+ initLoggerAsUnittest(
+ loguni, "%(asctime)s :: %(levelname)-8s :: %(message)s", level=LOGI.DEBUG
+ )
+ testLogger_2(loguni) # is silent
+ # log("loguni.getLogs():\n%s" % loguni.getLogs())
+ print("loguni.streamUnittest:\n%s" % loguni.getLogs())
#################################################################
# in production, or not (if __main__)
#################################################################
if __name__ == "__main__":
- # for example, not in production
- # get path to salomeTools sources
- curdir = os.path.dirname(os.path.dirname(__file__))
- # Make the src & commands package accessible from all code
- sys.path.insert(0, curdir)
- testMain_2()
- # here we have sys.exit()
+ # for example, not in production
+ # get path to salomeTools sources
+ curdir = os.path.dirname(os.path.dirname(__file__))
+ # Make the src & commands package accessible from all code
+ sys.path.insert(0, curdir)
+ testMain_2()
+ # here we have sys.exit()
else:
- # in production
- # get two LoggerSat instance used in salomeTools, no more needed.
- _loggerDefault = getDefaultLogger()
- _loggerUnittest = getUnittestLogger()
- initLoggerAsDefault(_loggerDefault, '%(levelname)-8s :: %(message)s')
- initLoggerAsUnittest(_loggerUnittest, '%(asctime)s :: %(levelname)s :: %(message)s')
+ # in production
+ # get two LoggerSat instance used in salomeTools, no more needed.
+ _loggerDefault = getDefaultLogger()
+ _loggerUnittest = getUnittestLogger()
+ initLoggerAsDefault(_loggerDefault, "%(levelname)-8s :: %(message)s")
+ initLoggerAsUnittest(_loggerUnittest, "%(asctime)s :: %(levelname)s :: %(message)s")
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2013 CEA/DEN
#
# This library is free software; you can redistribute it and/or
from . import printcolors
import src
-import src.debug as DBG # Easy print stderr (for DEBUG only)
+import src.debug as DBG # Easy print stderr (for DEBUG only)
+
class OptResult(object):
"""
An instance of this class will be the object manipulated
in code of all salomeTools commands
The aim of this class is to have an elegant syntax to manipulate the options.
-
- | Example:
+
+ | Example:
| >> options, remainderArgs = command.parseArguments(args)
| >> print(options.output_verbose_level)
| >> 'INFO'
"""
+
def __init__(self):
- """Initialization
- """
+ """Initialization"""
self.__dict__ = dict()
def __getattr__(self, name):
"""
- Overwrite of the __getattr__ function
+ Overwrite of the __getattr__ function
to customize it for option usage
-
+
:param name: (str) The attribute to get the value.
:return: (str int list boolean level)
the value corresponding to the attribute.
def __setattr__(self, name, value):
"""
- Overwrite of the __setattr__ function
+ Overwrite of the __setattr__ function
to customize it for option usage
-
+
:param name: (str) The attribute to set.
:param value: (str) The value corresponding to the attribute.
:return: None
res = "%s(\n %s\n)" % (self.__class__.__name__, aStr[1:-1])
return res
+
class Options(object):
"""
Class to manage all salomeTools options
"""
+
def __init__(self):
- """Initialization
- """
- # The options field stocks all options of a command
+ """Initialization"""
+ # The options field stocks all options of a command
# in a list that contains dicts
self.PROPERTY_EXPRESSION = "^.+:.+$"
self.options = []
self.default = None
self.results = {}
- def add_option(self, shortName, longName, optionType, destName, helpString="", default=None):
+ def add_option(
+ self, shortName, longName, optionType, destName, helpString="", default=None
+ ):
"""
Add an option to a command. It gets all attributes
of an option and append it in the options field
-
- :param shortName: (str)
+
+ :param shortName: (str)
The short name of the option (as '-l' for level option).
- :param longName: (str)
+ :param longName: (str)
The long name of the option (as '--level' for level option).
:param optionType: (str) The type of the option (ex "int").
:param destName: (str) The name that will be used in the code.
- :param helpString: (str)
- The text to display when user ask for help on a command.
+ :param helpString: (str)
+ The text to display when user ask for help on a command.
:return: None
"""
- tmp = [o['shortName'] for o in self.options if o['shortName'] != '']
- if shortName in tmp:
- raise Exception("option '-%s' existing yet" % shortName)
- tmp = [o['longName'] for o in self.options if o['longName'] != '']
- if longName in tmp:
- raise Exception("option '--%s' existing yet" % longName)
+ tmp = [o["shortName"] for o in self.options if o["shortName"] != ""]
+ if shortName in tmp:
+ raise Exception("option '-%s' existing yet" % shortName)
+ tmp = [o["longName"] for o in self.options if o["longName"] != ""]
+ if longName in tmp:
+ raise Exception("option '--%s' existing yet" % longName)
option = dict()
- option['shortName'] = shortName
- option['longName'] = longName
+ option["shortName"] = shortName
+ option["longName"] = longName
if optionType not in self.availableOptions:
- raise Exception("error optionType '%s' not available." % optionType)
+ raise Exception("error optionType '%s' not available." % optionType)
+
+ option["optionType"] = optionType
+ option["destName"] = destName
+ option["helpString"] = helpString
+ option["result"] = default
- option['optionType'] = optionType
- option['destName'] = destName
- option['helpString'] = helpString
- option['result'] = default
-
self.options.append(option)
# add option properties unconditionaly if 'products' option added
if [shortName, longName] == ["p", "products"]:
- self.add_option('', 'properties', 'properties', 'properties',
- _('Optional: Filter the products by their properties.\n\tSyntax: '
- '--properties <property>:<value>'))
-
+ self.add_option(
+ "",
+ "properties",
+ "properties",
+ "properties",
+ _(
+ "Optional: Filter the products by their properties.\n\tSyntax: "
+ "--properties <property>:<value>"
+ ),
+ )
-
def getDetailOption(self, option):
"""
- for convenience
-
+ for convenience
+
:return: (tuple) 4-elements (shortName, longName, optionType, helpString)
"""
- oos = option['shortName']
- ool = option['longName']
- oot = option['optionType']
- ooh = option['helpString']
+ oos = option["shortName"]
+ ool = option["longName"]
+ oot = option["optionType"]
+ ooh = option["helpString"]
return (oos, ool, oot, ooh)
def get_help(self):
"""
- Returns all options stored in self.options
+ Returns all options stored in self.options
as help message colored string
-
+
:return: (str) colored string
"""
msg = ""
# Do nothing if there are no options
- #there is -h option, always
- #if len(self.options) == 0:
+ # there is -h option, always
+ # if len(self.options) == 0:
# return _("No available options.")
- # for all options, gets its values.
- # "shortname" is an mandatory field of the options, could be ''
+ # for all options, gets its values.
+ # "shortname" is an mandatory field of the options, could be ''
msg += printcolors.printcHeader(_("Available options are:"))
for option in self.options:
oos, ool, oot, ooh = self.getDetailOption(option)
msg += "\n -%1s, --%s (%s)\n" % (oos, ool, oot)
else:
msg += "\n --%s (%s)\n" % (ool, oot)
-
+
msg += "%s\n" % self.indent(ooh, 10)
return msg
def indent(self, text, amount, car=" "):
"""indent multi lines message"""
padding = amount * car
- return ''.join(padding + line for line in text.splitlines(True))
-
+ return "".join(padding + line for line in text.splitlines(True))
+
def parse_args(self, argList=None):
"""
- Instantiates the class OptResult
+ Instantiates the class OptResult
that gives access to all options in the code
-
+
:param argList: (list) the raw list of arguments that were passed
- :return: (OptResult, list) as (optResult, args)
- optResult is the option instance to manipulate in the code.
- args is the full raw list of passed options
+ :return: (OptResult, list) as (optResult, args)
+ optResult is the option instance to manipulate in the code.
+ args is the full raw list of passed options
"""
# see https://pymotw.com/2/getopt/
if argList is None:
argList = sys.argv[1:]
-
+
DBG.write("parse_args", argList)
# DBG.write("options", self.options)
- # format shortNameOption and longNameOption
+ # format shortNameOption and longNameOption
# to make right arguments to getopt.getopt function
shortNameOption = ""
longNameOption = []
for option in self.options:
- shortNameOption = shortNameOption + option['shortName']
- if option['shortName'] != "" and option['optionType'] not in self.noArgOptions:
+ shortNameOption = shortNameOption + option["shortName"]
+ if (
+ option["shortName"] != ""
+ and option["optionType"] not in self.noArgOptions
+ ):
shortNameOption = shortNameOption + ":"
- if option['longName'] != "":
- if option['optionType'] not in self.noArgOptions:
- longNameOption.append(option['longName'] + "=")
+ if option["longName"] != "":
+ if option["optionType"] not in self.noArgOptions:
+ longNameOption.append(option["longName"] + "=")
else:
- longNameOption.append(option['longName'])
+ longNameOption.append(option["longName"])
- # call to getopt.getopt function to get the option
+ # call to getopt.getopt function to get the option
# passed in the command regarding the available options
try:
- optlist, args = getopt.getopt(argList, shortNameOption, longNameOption)
+ optlist, args = getopt.getopt(argList, shortNameOption, longNameOption)
except Exception as e:
- msg = str(e) + " on '%s'\n\n" % " ".join(argList) + self.get_help()
- raise Exception(msg)
+ msg = str(e) + " on '%s'\n\n" % " ".join(argList) + self.get_help()
+ raise Exception(msg)
# instantiate and completing the optResult that will be returned
optResult = OptResult()
for option in self.options:
- shortOption = "-" + option['shortName']
- longOption = "--" + option['longName']
- optionType = option['optionType']
+ shortOption = "-" + option["shortName"]
+ longOption = "--" + option["longName"]
+ optionType = option["optionType"]
for opt in optlist:
if opt[0] in [shortOption, longOption]:
if optionType == "string":
- option['result'] = opt[1]
+ option["result"] = opt[1]
elif optionType == "boolean":
- option['result'] = True
+ option["result"] = True
elif optionType == "noboolean":
- option['result'] = False
+ option["result"] = False
elif optionType == "int":
- option['result'] = int(opt[1])
+ option["result"] = int(opt[1])
elif optionType == "float":
- option['result'] = float(opt[1])
+ option["result"] = float(opt[1])
elif optionType == "long":
- option['result'] = long(opt[1])
+ option["result"] = long(opt[1])
elif optionType == "list":
- if option['result'] is None:
- option['result'] = list()
- option['result'].append(opt[1])
- elif optionType == "level": #logger logging levels
- option['result'] = self.filterLevel(opt[1])
+ if option["result"] is None:
+ option["result"] = list()
+ option["result"].append(opt[1])
+ elif optionType == "level": # logger logging levels
+ option["result"] = self.filterLevel(opt[1])
elif optionType == "list2":
- if option['result'] is None:
- option['result'] = list()
- option['result'] = self.filterList2(opt[1])
+ if option["result"] is None:
+ option["result"] = list()
+ option["result"] = self.filterList2(opt[1])
elif optionType == "properties":
- option['result'] = self.filterProperties(opt[1])
+ option["result"] = self.filterProperties(opt[1])
- optResult.__setattr__(option['destName'], option['result'])
- # free the option in order to be able to make
+ optResult.__setattr__(option["destName"], option["result"])
+ # free the option in order to be able to make
# a new free call of options (API case)
- option['result'] = None
+ option["result"] = None
- self.results = {"optlist": optlist, "optResult": optResult, "args": args, "argList": argList}
+ self.results = {
+ "optlist": optlist,
+ "optResult": optResult,
+ "args": args,
+ "argList": argList,
+ }
DBG.write("results", self.results)
return optResult, args
-
+
def filterLevel(self, aLevel):
- """filter level logging values"""
- import src.loggingSimple as LOG
- aLev = aLevel.upper()
- knownLevels = LOG._knownLevels
- maxLen = max([len(i) for i in knownLevels])
- for i in range(maxLen):
- for lev in knownLevels:
- if aLev == lev[:i]:
- DBG.write("filterLevel", "%s -> %s" % (aLevel, lev))
- return lev
- msg = "Unknown level '%s', accepted are:\n%s" % (aLev, ", ".join(knownLevels))
- raise Exception(msg)
-
+ """filter level logging values"""
+ import src.loggingSimple as LOG
+
+ aLev = aLevel.upper()
+ knownLevels = LOG._knownLevels
+ maxLen = max([len(i) for i in knownLevels])
+ for i in range(maxLen):
+ for lev in knownLevels:
+ if aLev == lev[:i]:
+ DBG.write("filterLevel", "%s -> %s" % (aLevel, lev))
+ return lev
+ msg = "Unknown level '%s', accepted are:\n%s" % (aLev, ", ".join(knownLevels))
+ raise Exception(msg)
+
def filterList2(self, aStr):
- """filter a list as 'KERNEL,YACS,etc.'"""
- aList = aStr.strip().split(",")
- # fix list leading ',' as ',KERNEL,...'
- aList = [i for i in aList if i != ""] # split old list leadin "," as ",KERNEL,ETC..."
- return aList
-
+ """filter a list as 'KERNEL,YACS,etc.'"""
+ aList = aStr.strip().split(",")
+ # fix list leading ',' as ',KERNEL,...'
+ aList = [
+ i for i in aList if i != ""
+ ] # split old list leadin "," as ",KERNEL,ETC..."
+ return aList
+
def filterProperties(self, aStr):
- """
- filter properties values
-
- example:
- >> sat -v 9 prepare $TRG -p KERNEL --properties is_SALOME_module:yes
- """
- msg = _('The "--properties" option must have the following syntax:\n--properties <property>:<value>')
- oExpr = re.compile(self.PROPERTY_EXPRESSION)
- if not oExpr.search(aStr):
- raise Exception(msg)
- res = aStr.split(":")
- if len(res) != 2:
- raise Exception(msg)
- return res
-
- def __repr__(self):
- """
- repr for only self.options and self.results (if present)
- """
- aDict = {'options': self.options, 'results': self.results}
- aStr = PP.pformat(aDict)
- res = "%s(\n %s\n)" % (self.__class__.__name__, aStr[1:-1])
- return res
-
- def __str__(self):
- """
- str for only resume expected self.options
- """
- #aDict = [(k["longName"], k["shortName", k["helpString"]) for k in self.options}
- #aList = [(k, self.options[k]) for k in sorted(self.options.keys())]
- aDict = {}
- for o in self.options:
- aDict[o["longName"]] = (o["shortName"], o["helpString"])
- aStr = PP.pformat(aDict)
- res = "%s(\n %s)" % (self.__class__.__name__, aStr[1:-1])
- return res
-
- def debug_write(self):
- DBG.write("options and results", self, True)
+ """
+ filter properties values
+
+ example:
+ >> sat -v 9 prepare $TRG -p KERNEL --properties is_SALOME_module:yes
+ """
+ msg = _(
+ 'The "--properties" option must have the following syntax:\n--properties <property>:<value>'
+ )
+ oExpr = re.compile(self.PROPERTY_EXPRESSION)
+ if not oExpr.search(aStr):
+ raise Exception(msg)
+ res = aStr.split(":")
+ if len(res) != 2:
+ raise Exception(msg)
+ return res
+ def __repr__(self):
+ """
+ repr for only self.options and self.results (if present)
+ """
+ aDict = {"options": self.options, "results": self.results}
+ aStr = PP.pformat(aDict)
+ res = "%s(\n %s\n)" % (self.__class__.__name__, aStr[1:-1])
+ return res
+ def __str__(self):
+ """
+ str for only resume expected self.options
+ """
+ # aDict = [(k["longName"], k["shortName", k["helpString"]) for k in self.options}
+ # aList = [(k, self.options[k]) for k in sorted(self.options.keys())]
+ aDict = {}
+ for o in self.options:
+ aDict[o["longName"]] = (o["shortName"], o["helpString"])
+ aStr = PP.pformat(aDict)
+ res = "%s(\n %s)" % (self.__class__.__name__, aStr[1:-1])
+ return res
+
+ def debug_write(self):
+ DBG.write("options and results", self, True)
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2013 CEA/DEN
#
# This library is free software; you can redistribute it and/or
# 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
-'''In this file is stored the mechanism that manage color prints in the terminal
-'''
+"""In this file is stored the mechanism that manage color prints in the terminal
+"""
# define constant to use in scripts
-COLOR_ERROR = 'ERROR'
-COLOR_WARNING = 'WARNING'
-COLOR_SUCCESS = 'SUCCESS'
-COLOR_LABEL = 'LABEL'
-COLOR_HEADER = 'HEADER'
-COLOR_INFO = 'INFO'
-COLOR_HIGLIGHT = 'HIGHLIGHT'
+COLOR_ERROR = "ERROR"
+COLOR_WARNING = "WARNING"
+COLOR_SUCCESS = "SUCCESS"
+COLOR_LABEL = "LABEL"
+COLOR_HEADER = "HEADER"
+COLOR_INFO = "INFO"
+COLOR_HIGLIGHT = "HIGHLIGHT"
# the color map to use to print the colors
__colormap__ = {
- COLOR_ERROR: '\033[1m\033[31m',
- COLOR_SUCCESS: '\033[1m\033[32m',
- COLOR_WARNING: '\033[33m',
- COLOR_HEADER: '\033[34m',
- COLOR_INFO: '\033[35m',
- COLOR_LABEL: '\033[36m',
- COLOR_HIGLIGHT: '\033[97m\033[43m'
+ COLOR_ERROR: "\033[1m\033[31m",
+ COLOR_SUCCESS: "\033[1m\033[32m",
+ COLOR_WARNING: "\033[33m",
+ COLOR_HEADER: "\033[34m",
+ COLOR_INFO: "\033[35m",
+ COLOR_LABEL: "\033[36m",
+ COLOR_HIGLIGHT: "\033[97m\033[43m",
}
# list of available codes
-__code_range__ = ([1, 4] + list(range(30, 38)) + list(range(40, 48))
- + list(range(90, 98)) + list(range(100, 108)))
+__code_range__ = (
+ [1, 4]
+ + list(range(30, 38))
+ + list(range(40, 48))
+ + list(range(90, 98))
+ + list(range(100, 108))
+)
+
+
+def printc(txt, code=""):
+ """print a text with colors
-def printc(txt, code=''):
- '''print a text with colors
-
:param txt str: The text to be printed.
:param code str: The color to use.
:return: The colored text.
:rtype: str
- '''
+ """
# no code means 'auto mode' (works only for OK, KO, NO and ERR*)
- if code == '':
+ if code == "":
striptxt = txt.strip().upper()
if striptxt == "OK":
code = COLOR_SUCCESS
return txt
# no code => output the originial text
- if code not in __colormap__.keys() or __colormap__[code] == '':
+ if code not in __colormap__.keys() or __colormap__[code] == "":
return txt
- return __colormap__[code] + txt + '\033[0m'
+ return __colormap__[code] + txt + "\033[0m"
+
def printcInfo(txt):
- '''print a text info color
-
+ """print a text info color
+
:param txt str: The text to be printed.
:return: The colored text.
:rtype: str
- '''
+ """
return printc(txt, COLOR_INFO)
+
def printcError(txt):
- '''print a text error color
-
+ """print a text error color
+
:param txt str: The text to be printed.
:return: The colored text.
:rtype: str
- '''
+ """
return printc(txt, COLOR_ERROR)
+
def printcWarning(txt):
- '''print a text warning color
-
+ """print a text warning color
+
:param txt str: The text to be printed.
:return: The colored text.
:rtype: str
- '''
+ """
return printc(txt, COLOR_WARNING)
+
def printcHeader(txt):
- '''print a text header color
-
+ """print a text header color
+
:param txt str: The text to be printed.
:return: The colored text.
:rtype: str
- '''
+ """
return printc(txt, COLOR_HEADER)
+
def printcLabel(txt):
- '''print a text label color
-
+ """print a text label color
+
:param txt str: The text to be printed.
:return: The colored text.
:rtype: str
- '''
+ """
return printc(txt, COLOR_LABEL)
+
def printcSuccess(txt):
- '''print a text success color
-
+ """print a text success color
+
:param txt str: The text to be printed.
:return: The colored text.
:rtype: str
- '''
+ """
return printc(txt, COLOR_SUCCESS)
+
def printcHighlight(txt):
- '''print a text highlight color
-
+ """print a text highlight color
+
:param txt str: The text to be printed.
:return: The colored text.
:rtype: str
- '''
+ """
return printc(txt, COLOR_HIGLIGHT)
+
def cleancolor(message):
- '''remove color from a colored text.
-
+ """remove color from a colored text.
+
:param message str: The text to be cleaned.
:return: The cleaned text.
:rtype: str
- '''
+ """
if message == None:
return message
-
- message = message.replace('\033[0m', '')
+
+ message = message.replace("\033[0m", "")
for i in __code_range__:
- message = message.replace('\033[%dm' % i, '')
+ message = message.replace("\033[%dm" % i, "")
return message
+
def print_value(logger, label, value, level=1, suffix=""):
- '''shortcut method to print a label and a value with the info color
-
+ """shortcut method to print a label and a value with the info color
+
:param logger class logger: the logger instance.
:param label int: the label to print.
:param value str: the value to print.
:param level int: the level of verboseness.
:param suffix str: the suffix to add at the end.
- '''
+ """
if type(value) is list:
skip = "\n "
strValue = ""
i = 0
for v in value:
- strValue += "%15s, " % str(v)
- i += 1
- if i >= 5:
- strValue += skip
- i = 0
+ strValue += "%15s, " % str(v)
+ i += 1
+ if i >= 5:
+ strValue += skip
+ i = 0
if len(value) > 5:
strValue = skip + strValue
else:
else:
logger.write(" %s = %s %s\n" % (label, strValue, suffix), level)
+
def print_color_range(start, end):
- '''print possible range values for colors
-
+ """print possible range values for colors
+
:param start int: The smaller value.
:param end int: The bigger value.
- '''
- for k in range(start, end+1):
- print("\033[%dm%3d\033[0m" % (k, k),)
+ """
+ for k in range(start, end + 1):
+ print(
+ "\033[%dm%3d\033[0m" % (k, k),
+ )
print
+
# This method prints the color map
def print_color_map():
- '''This method prints the color map
- '''
+ """This method prints the color map"""
print("colormap:")
print("{")
for k in sorted(__colormap__.keys()):
- codes = __colormap__[k].split('\033[')
+ codes = __colormap__[k].split("\033[")
codes = filter(lambda l: len(l) > 0, codes)
codes = map(lambda l: l[:-1], codes)
- print(printc(" %s: '%s', " % (k, ';'.join(codes)), k))
+ print(printc(" %s: '%s', " % (k, ";".join(codes)), k))
print("}")
-
-
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2012 CEA/DEN
#
# This library is free software; you can redistribute it and/or
import src.debug as DBG
import src.versionMinorMajorPatch as VMMP
-AVAILABLE_VCS = ['git', 'svn', 'cvs']
+AVAILABLE_VCS = ["git", "svn", "cvs"]
-CONFIG_FILENAME = "sat-config-" # trace product depends version(s)
-PRODUCT_FILENAME = "sat-product-" # trace product compile config
+CONFIG_FILENAME = "sat-config-" # trace product depends version(s)
+PRODUCT_FILENAME = "sat-product-" # trace product compile config
config_expression = "^config-\d+$"
+
def get_product_config(config, product_name, with_install_dir=True):
"""Get the specific configuration of a product from the global configuration
-
+
:param config Config: The global configuration
:param product_name str: The name of the product
- :param with_install_dir boolean: If false, do not provide an install
- directory (at false only for internal use
+ :param with_install_dir boolean: If false, do not provide an install
+ directory (at false only for internal use
of the function check_config_exists)
:return: the specific configuration of the product
:rtype: Config
# Get the version of the product from the application definition
version = config.APPLICATION.products[product_name]
-
+
# Define debug and dev modes
# Get the tag if a dictionary is given in APPLICATION.products for the
- # current product
- debug = 'no'
- dev = 'no'
- hpc = 'no'
- verbose = 'no'
- base = 'maybe'
+ # current product
+ debug = "no"
+ dev = "no"
+ hpc = "no"
+ verbose = "no"
+ base = "maybe"
section = None
# if no version, then take the default one defined in the application
- if isinstance(version, bool) or isinstance(version, str):
+ if isinstance(version, bool) or isinstance(version, str):
# in this case tag is mandatory, not debug, verbose, dev
- if 'debug' in config.APPLICATION:
+ if "debug" in config.APPLICATION:
debug = config.APPLICATION.debug
- if 'verbose' in config.APPLICATION:
+ if "verbose" in config.APPLICATION:
verbose = config.APPLICATION.verbose
- if 'dev' in config.APPLICATION:
+ if "dev" in config.APPLICATION:
dev = config.APPLICATION.dev
- if 'hpc' in config.APPLICATION:
+ if "hpc" in config.APPLICATION:
hpc = config.APPLICATION.hpc
- if 'base' in config.APPLICATION:
+ if "base" in config.APPLICATION:
base = config.APPLICATION.base
- # special case for which only the product name is mentionned
+ # special case for which only the product name is mentionned
if isinstance(version, bool):
version = config.APPLICATION.tag
if isinstance(version, src.pyconf.Mapping):
dic_version = version
# Get the version/tag
- if not 'tag' in dic_version:
+ if not "tag" in dic_version:
version = config.APPLICATION.tag
else:
version = dic_version.tag
-
+
# Get the debug if any
- if 'debug' in dic_version:
+ if "debug" in dic_version:
debug = dic_version.debug
- elif 'debug' in config.APPLICATION:
+ elif "debug" in config.APPLICATION:
debug = config.APPLICATION.debug
-
+
# Get the verbose if any
- if 'verbose' in dic_version:
+ if "verbose" in dic_version:
verbose = dic_version.verbose
- elif 'verbose' in config.APPLICATION:
+ elif "verbose" in config.APPLICATION:
verbose = config.APPLICATION.verbose
-
+
# Get the dev if any
- if 'dev' in dic_version:
+ if "dev" in dic_version:
dev = dic_version.dev
- elif 'dev' in config.APPLICATION:
+ elif "dev" in config.APPLICATION:
dev = config.APPLICATION.dev
-
+
# Get the hpc if any
- if 'hpc' in dic_version:
+ if "hpc" in dic_version:
hpc = dic_version.hpc
- elif 'hpc' in config.APPLICATION:
+ elif "hpc" in config.APPLICATION:
hpc = config.APPLICATION.hpc
# Get the base if any
- if 'base' in dic_version:
+ if "base" in dic_version:
base = dic_version.base
- elif 'base' in config.APPLICATION:
+ elif "base" in config.APPLICATION:
base = config.APPLICATION.base
# Get the section if any
- if 'section' in dic_version:
+ if "section" in dic_version:
section = dic_version.section
-
+
# this case occur when version is overwritten, cf sat # 8897
- if isinstance(version, dict):
+ if isinstance(version, dict):
dic_version = version
# Get the version/tag
- if not 'tag' in dic_version:
+ if not "tag" in dic_version:
version = config.APPLICATION.tag
else:
version = dic_version["tag"]
-
+
# Get the debug if any
- if 'debug' in dic_version:
+ if "debug" in dic_version:
debug = dic_version["debug"]
- elif 'debug' in config.APPLICATION:
+ elif "debug" in config.APPLICATION:
debug = config.APPLICATION.debug
-
+
# Get the verbose if any
- if 'verbose' in dic_version:
+ if "verbose" in dic_version:
verbose = dic_version["verbose"]
- elif 'verbose' in config.APPLICATION:
+ elif "verbose" in config.APPLICATION:
verbose = config.APPLICATION.verbose
-
+
# Get the dev if any
- if 'dev' in dic_version:
+ if "dev" in dic_version:
dev = dic_version["dev"]
- elif 'dev' in config.APPLICATION:
+ elif "dev" in config.APPLICATION:
dev = config.APPLICATION.dev
-
+
# Get the hpc if any
- if 'hpc' in dic_version:
- hpc = dic_version['hpc']
- elif 'hpc' in config.APPLICATION:
+ if "hpc" in dic_version:
+ hpc = dic_version["hpc"]
+ elif "hpc" in config.APPLICATION:
hpc = config.APPLICATION.hpc
# Get the base if any
- if 'base' in dic_version:
+ if "base" in dic_version:
base = dic_version["base"]
# Get the section if any
- if 'section' in dic_version:
- section = dic_version['section']
+ if "section" in dic_version:
+ section = dic_version["section"]
vv = version
# substitute some character with _ in order to get the correct definition
# in config.PRODUCTS. This is done because the pyconf tool does not handle
- # the . and - characters
- for c in ".-/": vv = vv.replace(c, "_")
+ # the . and - characters
+ for c in ".-/":
+ vv = vv.replace(c, "_")
prod_info = None
if product_name in config.PRODUCTS:
# Search for the product description in the configuration
prod_info = get_product_section(config, product_name, vv, section)
-
+
# get salomeTool version
prod_info.sat_version = src.get_salometool_version(config)
# merge opt_depend in depend
- if prod_info is not None and 'opt_depend' in prod_info:
+ if prod_info is not None and "opt_depend" in prod_info:
for depend in prod_info.opt_depend:
- if (depend in config.APPLICATION.products) and (depend not in prod_info.depend) :
- prod_info.depend.append(depend,'')
-
+ if (depend in config.APPLICATION.products) and (
+ depend not in prod_info.depend
+ ):
+ prod_info.depend.append(depend, "")
- # In case of a product get with a vcs,
+ # In case of a product get with a vcs,
# put the tag (equal to the version)
if prod_info is not None and prod_info.get_source in AVAILABLE_VCS:
-
- if prod_info.get_source == 'git':
+
+ if prod_info.get_source == "git":
prod_info.git_info.tag = version
-
- if prod_info.get_source == 'svn':
+
+ if prod_info.get_source == "svn":
prod_info.svn_info.tag = version
-
- if prod_info.get_source == 'cvs':
+
+ if prod_info.get_source == "cvs":
prod_info.cvs_info.tag = version
-
- # In case of a fixed product,
+
+ # In case of a fixed product,
# define the install_dir (equal to the version)
- if prod_info is not None and \
- (os.path.isdir(version) or version.startswith("/")):
- # we consider a (fixed) path existing paths;
- # or paths starting with '/' (the objective is to print a correct
- # message to the user in case of non existing path.)
+ if prod_info is not None and (
+ os.path.isdir(version) or version.startswith("/")
+ ):
+ # we consider a (fixed) path existing paths;
+ # or paths starting with '/' (the objective is to print a correct
+ # message to the user in case of non existing path.)
prod_info.install_dir = version
prod_info.get_source = "fixed"
prod_info.install_mode = "fixed"
-
+
# Check if the product is defined as native in the application
if prod_info is not None:
if version == "native":
prod_info.get_source = "native"
elif prod_info.get_source == "native":
- msg = _("The product %(prod)s has version %(ver)s but is "
- "declared as native in its definition" %
- { 'prod': prod_info.name, 'ver': version})
+ msg = _(
+ "The product %(prod)s has version %(ver)s but is "
+ "declared as native in its definition"
+ % {"prod": prod_info.name, "ver": version}
+ )
raise src.SatException(msg)
# If there is no definition but the product is declared as native,
prod_info.get_source = "fixed"
prod_info.addMapping("environ", src.pyconf.Mapping(prod_info), "")
-
# If prod_info is still None, it means that there is no product definition
# in the config. The user has to provide it.
if prod_info is None:
- prod_pyconf_path = src.find_file_in_lpath(product_name + ".pyconf",
- config.PATHS.PRODUCTPATH)
+ prod_pyconf_path = src.find_file_in_lpath(
+ product_name + ".pyconf", config.PATHS.PRODUCTPATH
+ )
if not prod_pyconf_path:
- msg = _("""\
+ msg = (
+ _(
+ """\
No definition found for the product %(1)s.
Please create a %(1)s.pyconf file somewhere in:
- %(2)s""") % {
- "1": product_name,
- "2": PP.pformat(config.PATHS.PRODUCTPATH) }
+ %(2)s"""
+ )
+ % {"1": product_name, "2": PP.pformat(config.PATHS.PRODUCTPATH)}
+ )
else:
- msg = _("""\
+ msg = (
+ _(
+ """\
No definition corresponding to the version %(1)s was found in the file:
%(2)s.
-Please add a section in it.""") % {"1" : vv, "2" : prod_pyconf_path}
+Please add a section in it."""
+ )
+ % {"1": vv, "2": prod_pyconf_path}
+ )
raise src.SatException(msg)
-
+
# Set the debug, dev and version keys
prod_info.debug = debug
prod_info.verbose = verbose
prod_info.dev = dev
prod_info.hpc = hpc
prod_info.version = version
- if base != 'maybe':
+ if base != "maybe":
prod_info.base = base
# Set the archive_info if the product is get in archive mode
if prod_info.get_source == "archive":
if not "archive_info" in prod_info:
- prod_info.addMapping("archive_info",
- src.pyconf.Mapping(prod_info),
- "")
- if "archive_name" in prod_info.archive_info:
+ prod_info.addMapping("archive_info", src.pyconf.Mapping(prod_info), "")
+ if "archive_name" in prod_info.archive_info:
arch_name = prod_info.archive_info.archive_name
elif "archive_prefix" in prod_info.archive_info:
- arch_name = prod_info.archive_info.archive_prefix + "-" + version + ".tar.gz"
+ arch_name = (
+ prod_info.archive_info.archive_prefix + "-" + version + ".tar.gz"
+ )
else:
# standard name
arch_name = product_name + "-" + version + ".tar.gz"
- arch_path = src.find_file_in_lpath(arch_name,
- config.PATHS.ARCHIVEPATH)
+ arch_path = src.find_file_in_lpath(arch_name, config.PATHS.ARCHIVEPATH)
if not arch_path:
# arch_path is not found. It may generate an error in sat source,
# unless the archive is found in ftp serveur
- prod_info.archive_info.archive_name = arch_name #without path
+ prod_info.archive_info.archive_name = arch_name # without path
else:
prod_info.archive_info.archive_name = arch_path
-
# If the product compiles with a script, check the script existence
# and if it is executable
if product_has_script(prod_info):
# Check the compil_script key existence
if "compil_script" not in prod_info:
- msg = _("""\
+ msg = (
+ _(
+ """\
No compilation script found for the product %s.
-Please provide a 'compil_script' key in its definition.""") % product_name
+Please provide a 'compil_script' key in its definition."""
+ )
+ % product_name
+ )
raise src.SatException(msg)
-
+
# Get the path of the script file
# if windows supposed '.bat', if linux supposed '.sh'
# but user set extension script file in his pyconf as he wants, no obligation.
script_name = os.path.basename(script)
if script == script_name:
# Only a name is given. Search in the default directory
- script_path = src.find_file_in_lpath(script_name, config.PATHS.PRODUCTPATH, "compil_scripts")
+ script_path = src.find_file_in_lpath(
+ script_name, config.PATHS.PRODUCTPATH, "compil_scripts"
+ )
if not script_path:
msg = _("Compilation script %s not found in") % script_name
- DBG.tofix(msg, config.PATHS.PRODUCTPATH, True) # say where searched
+ DBG.tofix(msg, config.PATHS.PRODUCTPATH, True) # say where searched
script_path = "%s_(Not_Found_by_Sat!!)" % script_name
prod_info.compil_script = script_path
-
# Check that the script is executable
- if os.path.exists(prod_info.compil_script) and not os.access(prod_info.compil_script, os.X_OK):
- DBG.tofix("Compilation script file is not in 'execute mode'", prod_info.compil_script, True)
-
+ if os.path.exists(prod_info.compil_script) and not os.access(
+ prod_info.compil_script, os.X_OK
+ ):
+ DBG.tofix(
+ "Compilation script file is not in 'execute mode'",
+ prod_info.compil_script,
+ True,
+ )
+
# If the product has a post install script, check the script existence
# and if it is executable
if product_has_post_script(prod_info):
# Check the compil_script key existence
-
+
# Get the path of the script file
# if windows supposed '.bat', if linux supposed '.sh'
# but user set extension script file in his pyconf as he wants, no obligation.
script_name = os.path.basename(script)
if script == script_name:
# Only a name is given. Search in the default directory
- script_path = src.find_file_in_lpath(script_name, config.PATHS.PRODUCTPATH, "post_scripts")
+ script_path = src.find_file_in_lpath(
+ script_name, config.PATHS.PRODUCTPATH, "post_scripts"
+ )
if not script_path:
msg = _("Post install script %s not found in") % script_name
- DBG.tofix(msg, config.PATHS.PRODUCTPATH, True) # say where searched
+ DBG.tofix(msg, config.PATHS.PRODUCTPATH, True) # say where searched
script_path = "%s_(Not_Found_by_Sat!!)" % script_name
prod_info.post_script = script_path
-
# Check that the script is executable
- if os.path.exists(prod_info.post_script) and not os.access(prod_info.post_script, os.X_OK):
- DBG.tofix("Post install script file is not in 'execute mode'", prod_info.post_script, True)
+ if os.path.exists(prod_info.post_script) and not os.access(
+ prod_info.post_script, os.X_OK
+ ):
+ DBG.tofix(
+ "Post install script file is not in 'execute mode'",
+ prod_info.post_script,
+ True,
+ )
# Get the full paths of all the patches
if product_has_patches(prod_info):
patches = []
try:
- for patch in prod_info.patches:
- patch_path = patch
- # If only a filename, then search for the patch in the PRODUCTPATH
- if os.path.basename(patch_path) == patch_path:
- # Search in the PRODUCTPATH/patches
- patch_path = src.find_file_in_lpath(patch,
- config.PATHS.PRODUCTPATH,
- "patches")
- if not patch_path:
- msg = _("Patch %(patch_name)s for %(prod_name)s not found:"
- "\n" % {"patch_name" : patch,
- "prod_name" : prod_info.name})
- raise src.SatException(msg)
- patches.append(patch_path)
+ for patch in prod_info.patches:
+ patch_path = patch
+ # If only a filename, then search for the patch in the PRODUCTPATH
+ if os.path.basename(patch_path) == patch_path:
+ # Search in the PRODUCTPATH/patches
+ patch_path = src.find_file_in_lpath(
+ patch, config.PATHS.PRODUCTPATH, "patches"
+ )
+ if not patch_path:
+ msg = _(
+ "Patch %(patch_name)s for %(prod_name)s not found:"
+ "\n" % {"patch_name": patch, "prod_name": prod_info.name}
+ )
+ raise src.SatException(msg)
+ patches.append(patch_path)
except:
- DBG.tofix("problem in prod_info.patches", prod_info)
+ DBG.tofix("problem in prod_info.patches", prod_info)
prod_info.patches = patches
# Get the full paths of the environment scripts
if product_has_env_script(prod_info):
env_script_path = prod_info.environ.env_script
- # If only a filename, then search for the environment script
+ # If only a filename, then search for the environment script
# in the PRODUCTPATH/env_scripts
if os.path.basename(env_script_path) == env_script_path:
# Search in the PRODUCTPATH/env_scripts
env_script_path = src.find_file_in_lpath(
- prod_info.environ.env_script,
- config.PATHS.PRODUCTPATH,
- "env_scripts")
+ prod_info.environ.env_script, config.PATHS.PRODUCTPATH, "env_scripts"
+ )
if not env_script_path:
- msg = _("Environment script %(env_name)s for %(prod_name)s not "
- "found.\n" % {"env_name" : env_script_path,
- "prod_name" : prod_info.name})
+ msg = _(
+ "Environment script %(env_name)s for %(prod_name)s not "
+ "found.\n"
+ % {"env_name": env_script_path, "prod_name": prod_info.name}
+ )
raise src.SatException(msg)
prod_info.environ.env_script = env_script_path
-
- if with_install_dir:
- # The variable with_install_dir is at false only for internal use
+
+ if with_install_dir:
+ # The variable with_install_dir is at false only for internal use
# of the function get_install_dir
-
+
# Save the install_dir key if there is any
if "install_dir" in prod_info and not "install_dir_save" in prod_info:
prod_info.install_dir_save = prod_info.install_dir
-
+
# if it is not the first time the install_dir is computed, it means
# that install_dir_save exists and it has to be taken into account.
if "install_dir_save" in prod_info:
prod_info.install_dir = prod_info.install_dir_save
-
+
# Set the install_dir key
- prod_info.install_dir,prod_info.install_mode = get_install_dir(config, version, prod_info)
-
+ prod_info.install_dir, prod_info.install_mode = get_install_dir(
+ config, version, prod_info
+ )
+
return prod_info
+
def get_product_section(config, product_name, version, section=None):
"""Build the product description from the configuration
-
+
:param config Config: The global configuration
:param product_name str: The product name
:param version str: The version of the product as 'V8_4_0', or else.
- :param section str: The searched section (if not None, the section is
+ :param section str: The searched section (if not None, the section is
explicitly given
:return: The product description
:rtype: Config
"""
-
- #get product definition and determine if the incremental definition mode is activated
+ # get product definition and determine if the incremental definition mode is activated
aProd = config.PRODUCTS[product_name]
- if "default" in aProd and\
- "properties" in aProd.default and\
- "incremental" in aProd.default.properties and\
- aProd.default.properties.incremental == "yes":
+ if (
+ "default" in aProd
+ and "properties" in aProd.default
+ and "incremental" in aProd.default.properties
+ and aProd.default.properties.incremental == "yes"
+ ):
# in this (new) mode the definition of the product is given by the default section
# and is incremented by others.
- is_incr=True
+ is_incr = True
else:
# in this (historic) mode the definition of the product is given by a full unique section
- is_incr=False
+ is_incr = False
# decode version number
try:
- versionMMP = VMMP.MinorMajorPatch(version)
- except: # example setuptools raise "minor in major_minor_patch is not integer: '0_6c11'"
- versionMMP = None
+ versionMMP = VMMP.MinorMajorPatch(version)
+ except: # example setuptools raise "minor in major_minor_patch is not integer: '0_6c11'"
+ versionMMP = None
# if a section is explicitely specified we select it
if section:
if section not in aProd:
- pi=None
+ pi = None
# returns specific information for the given version
pi = aProd[section]
pi.section = section
l_section_ranges = []
tagged = []
for name in l_section_names:
- aRange = VMMP.getRange_majorMinorPatch(name)
- if aRange is not None:
- l_section_ranges.append((name, aRange))
+ aRange = VMMP.getRange_majorMinorPatch(name)
+ if aRange is not None:
+ l_section_ranges.append((name, aRange))
if versionMMP is not None and len(l_section_ranges) > 0:
- for name, (vmin, vmax) in l_section_ranges:
- if versionMMP >= vmin and versionMMP <= vmax:
- tagged.append((name, [vmin, vmax]))
+ for name, (vmin, vmax) in l_section_ranges:
+ if versionMMP >= vmin and versionMMP <= vmax:
+ tagged.append((name, [vmin, vmax]))
if len(tagged) > 1:
- DBG.write("multiple version ranges tagged for '%s', fix it" % version,
- PP.pformat(tagged))
- pi=None
- elif len(tagged) == 1: # ok
- name, (vmin, vmax) = tagged[0]
- pi = aProd[name]
- pi.section = name
- pi.from_file = aProd.from_file
+ DBG.write(
+ "multiple version ranges tagged for '%s', fix it" % version,
+ PP.pformat(tagged),
+ )
+ pi = None
+ elif len(tagged) == 1: # ok
+ name, (vmin, vmax) = tagged[0]
+ pi = aProd[name]
+ pi.section = name
+ pi.from_file = aProd.from_file
# Else, get the standard informations
elif "default" in aProd:
pi.section = "default"
pi.from_file = aProd.from_file
else:
- pi=None
+ pi = None
if is_incr:
# If the definition is incremental, we take the default section
- # and then complete it with other sections :
+ # and then complete it with other sections :
# - default_win
# - the selected section (pi)
# - the selected _win section
- prod_info=aProd["default"]
+ prod_info = aProd["default"]
prod_info.from_file = aProd.from_file
prod_info.section = "default"
if src.architecture.is_windows() and "default_win" in aProd:
for key in aProd["default_win"]:
- prod_info[key]=aProd["default_win"][key]
- if pi!=None and pi.section!="default":
+ prod_info[key] = aProd["default_win"][key]
+ if pi != None and pi.section != "default":
# update prod_info with incremental definition contained in pi
for key in pi:
- prod_info[key]=pi[key]
- win_section=pi.section+"_win"
+ prod_info[key] = pi[key]
+ win_section = pi.section + "_win"
if src.architecture.is_windows() and win_section in aProd:
for key in aProd[win_section]:
- prod_info[key]=aProd[win_section][key]
+ prod_info[key] = aProd[win_section][key]
else:
- prod_info=pi
+ prod_info = pi
- #DBG.write("product info returned for product %s with version %s and section %s" %\
+ # DBG.write("product info returned for product %s with version %s and section %s" %\
# (product_name, version, section), prod_info)
return prod_info
-
+
+
def get_install_dir(config, version, prod_info):
- """Compute the installation directory of a given product
-
+ """Compute the installation directory of a given product
+
:param config Config: The global configuration
- :param base str: This corresponds to the value given by user in its
+ :param base str: This corresponds to the value given by user in its
application.pyconf for the specific product. If "yes", the
user wants the product to be in base. If "no", he wants the
product to be in the application workdir
:param version str: The version of the product
- :param product_info Config: The configuration specific to
+ :param product_info Config: The configuration specific to
the product
-
+
:return: The path of the product installation and the mode of the install directory (base/implicit/fixed/value)
:rtype: str,str
"""
install_dir = ""
in_base = False
-
+
# prod_info.base : corresponds to what is specified in application pyconf (either from the global key base, or from a product dict)
# prod_info.install_dir : corresponds to what is specified in product pyconf (usually "base" for prerequisites)
- if ( ("install_dir" in prod_info and prod_info.install_dir == "base") # product is declared as base in its own config
- or ("base" in prod_info and prod_info.base != "no") ): # product is declared as base in the application
+ if (
+ "install_dir" in prod_info and prod_info.install_dir == "base"
+ ) or ( # product is declared as base in its own config
+ "base" in prod_info and prod_info.base != "no"
+ ): # product is declared as base in the application
# a product goes in base if install_dir is set to base, or if product was declared based in application pyconf
in_base = True
# check desactivation of base at application level
- if ( "base" in prod_info and prod_info.base == "no"):
+ if "base" in prod_info and prod_info.base == "no":
in_base = False
if in_base:
install_dir = get_base_install_dir(config, prod_info, version)
install_mode = "base"
else:
- if ("install_mode" in prod_info and prod_info.install_mode in ["implicit", "base"]) or\
- ("install_dir" not in prod_info or prod_info.install_dir == "base"):
- # the check to "base" comes from the package case were base mode is changed dynamically
+ if (
+ "install_mode" in prod_info
+ and prod_info.install_mode in ["implicit", "base"]
+ ) or ("install_dir" not in prod_info or prod_info.install_dir == "base"):
+ # the check to "base" comes from the package case were base mode is changed dynamically
# to create a package launcher.
# Set it to the default value (in application directory)
install_mode = "implicit"
- if ( src.appli_test_property(config,"single_install_dir", "yes") and
- src.product.product_test_property(prod_info,"single_install_dir", "yes")):
+ if src.appli_test_property(
+ config, "single_install_dir", "yes"
+ ) and src.product.product_test_property(
+ prod_info, "single_install_dir", "yes"
+ ):
# when single_install_dir mode is activated in tha application
- # we use config.INTERNAL.config.single_install_dir for products
+ # we use config.INTERNAL.config.single_install_dir for products
# having single_install_dir property
- install_dir = os.path.join(config.APPLICATION.workdir,
- config.INTERNAL.config.install_dir,
- config.INTERNAL.config.single_install_dir)
- elif ( src.appli_test_property(config,"pip", "yes") and
- src.product.product_test_property(prod_info,"pip", "yes") and
- src.appli_test_property(config,"pip_install_dir", "python") ):
+ install_dir = os.path.join(
+ config.APPLICATION.workdir,
+ config.INTERNAL.config.install_dir,
+ config.INTERNAL.config.single_install_dir,
+ )
+ elif (
+ src.appli_test_property(config, "pip", "yes")
+ and src.product.product_test_property(prod_info, "pip", "yes")
+ and src.appli_test_property(config, "pip_install_dir", "python")
+ ):
# when pip mode is activated in the application
- # and product is pip, and pip_install_dir is set to python
+ # and product is pip, and pip_install_dir is set to python
# we assume python in installed in install_dir/Python
- install_dir = os.path.join(config.APPLICATION.workdir,
- config.INTERNAL.config.install_dir,
- "Python")
+ install_dir = os.path.join(
+ config.APPLICATION.workdir,
+ config.INTERNAL.config.install_dir,
+ "Python",
+ )
else:
- install_dir = os.path.join(config.APPLICATION.workdir,
- config.INTERNAL.config.install_dir,
- prod_info.name)
+ install_dir = os.path.join(
+ config.APPLICATION.workdir,
+ config.INTERNAL.config.install_dir,
+ prod_info.name,
+ )
else:
install_dir = prod_info.install_dir
install_mode = "value"
- return install_dir,install_mode
+ return install_dir, install_mode
+
def get_base_install_dir(config, prod_info, version):
- """Compute the installation directory of a product in base
-
+ """Compute the installation directory of a product in base
+
:param config Config: The global configuration
- :param product_info Config: The configuration specific to
+ :param product_info Config: The configuration specific to
the product
- :param version str: The version of the product
- :param base str: This corresponds to the value given by user in its
+ :param version str: The version of the product
+ :param base str: This corresponds to the value given by user in its
application.pyconf for the specific product. If "yes", the
user wants the product to be in base. If "no", he wants the
product to be in the application workdir.
- if it contains something else, is is interpreted as the name
+ if it contains something else, is is interpreted as the name
of a base we build for module load.
:return: The path of the product installation
:rtype: str
- """
-
+ """
+
# get rid of / to avoid create subdirectories cf sat #18546
- version_wslash=version.replace("/", "_")
-
- if ( src.appli_test_property(config,"pip", "yes") and
- src.product.product_test_property(prod_info,"pip", "yes") and
- src.appli_test_property(config,"pip_install_dir", "python") ):
- # when pip mode is activated in the application
- # and product is pip, and pip_install_dir is set to python
- python_info=get_product_config(config, "Python")
+ version_wslash = version.replace("/", "_")
+
+ if (
+ src.appli_test_property(config, "pip", "yes")
+ and src.product.product_test_property(prod_info, "pip", "yes")
+ and src.appli_test_property(config, "pip_install_dir", "python")
+ ):
+ # when pip mode is activated in the application
+ # and product is pip, and pip_install_dir is set to python
+ python_info = get_product_config(config, "Python")
return python_info.install_dir
- base_path = src.get_base_path(config)
+ base_path = src.get_base_path(config)
if "base" in prod_info and prod_info.base != "no" and prod_info.base != "yes":
# we are in the case of a named base
- prod_dir = os.path.join(base_path, "apps", prod_info.base, prod_info.name, version_wslash)
+ prod_dir = os.path.join(
+ base_path, "apps", prod_info.base, prod_info.name, version_wslash
+ )
return prod_dir
-
+
prod_dir = os.path.join(base_path, prod_info.name + "-" + version_wslash)
if not os.path.exists(prod_dir):
return os.path.join(prod_dir, "config-1")
-
+
exists, install_dir = check_config_exists(config, prod_dir, prod_info)
if exists:
return install_dir
-
+
# Find the first config-<i> directory that is available in the product
# directory
- found = False
+ found = False
label = 1
while not found:
install_dir = os.path.join(prod_dir, "config-%i" % label)
if os.path.exists(install_dir):
- label+=1
+ label += 1
else:
found = True
-
+
return install_dir
+
def add_compile_config_file(p_info, config):
- '''Execute the proper configuration command(s)
+ """Execute the proper configuration command(s)
in the product build directory.
:param p_info Config: The specific config of the product
:param config Config: The global configuration
- '''
+ """
# Create the compile config
# DBG.write("add_compile_config_file", p_info, True)
res = src.pyconf.Config()
res.addMapping(p_info.name, src.pyconf.Mapping(res), "")
- res[p_info.name]= p_info.version
+ res[p_info.name] = p_info.version
- depprod=[]
+ depprod = []
for d in p_info.depend:
depprod.append(d)
if "build_depend" in p_info:
for d in p_info.build_depend:
depprod.append(d)
for prod_name in depprod:
- if prod_name not in res:
- res.addMapping(prod_name, src.pyconf.Mapping(res), "")
- prod_dep_info = src.product.get_product_config(config, prod_name, False)
- res[prod_name] = prod_dep_info.version
+ if prod_name not in res:
+ res.addMapping(prod_name, src.pyconf.Mapping(res), "")
+ prod_dep_info = src.product.get_product_config(config, prod_name, False)
+ res[prod_name] = prod_dep_info.version
# Write it in the install directory of the product
# This file is for automatic reading/checking
# see check_config_exists method
afilename = CONFIG_FILENAME + p_info.name + ".pyconf"
aFile = os.path.join(p_info.install_dir, afilename)
- with open(aFile, 'w') as f:
- res.__save__(f)
+ with open(aFile, "w") as f:
+ res.__save__(f)
# this file is not mandatory, is for human eye reading
afilename = PRODUCT_FILENAME + p_info.name + ".pyconf"
aFile = os.path.join(p_info.install_dir, afilename)
try:
- with open(aFile, 'w') as f:
- p_info.__save__(f, evaluated=True) # evaluated expressions mode
+ with open(aFile, "w") as f:
+ p_info.__save__(f, evaluated=True) # evaluated expressions mode
except:
- # sometime some information cannot be evaluated.
- # for example, in the context of non VCS archives, information on git server is not available.
- DBG.write("Warning : sat was not able to evaluate and write down some information in file %s" % aFile)
-
+ # sometime some information cannot be evaluated.
+ # for example, in the context of non VCS archives, information on git server is not available.
+ DBG.write(
+ "Warning : sat was not able to evaluate and write down some information in file %s"
+ % aFile
+ )
+
def check_config_exists(config, prod_dir, prod_info, verbose=False):
"""\
# check if the directories or files of the directory corresponds to the
# directory installation of the product
if os.path.isdir(prod_dir):
- l_dir_and_files = os.listdir(prod_dir)
+ l_dir_and_files = os.listdir(prod_dir)
else:
- raise Exception("Inexisting directory '%s'" % prod_dir)
+ raise Exception("Inexisting directory '%s'" % prod_dir)
- DBG.write("check_config_exists 000", (prod_dir, l_dir_and_files), verbose)
- DBG.write("check_config_exists 111", prod_info, verbose)
+ DBG.write("check_config_exists 000", (prod_dir, l_dir_and_files), verbose)
+ DBG.write("check_config_exists 111", prod_info, verbose)
- depend_all=[]
+ depend_all = []
if "depend" in prod_info:
for d in prod_info.depend:
depend_all.append(d)
depend_all.append(d)
for dir_or_file in l_dir_and_files:
oExpr = re.compile(config_expression)
- if not(oExpr.search(dir_or_file)):
+ if not (oExpr.search(dir_or_file)):
# in mode BASE, not config-<i>, not interesting
# DBG.write("not interesting", dir_or_file, True)
continue
# check if there is the file sat-config.pyconf file in the installation
- # directory
+ # directory
afilename = CONFIG_FILENAME + prod_info.name + ".pyconf"
config_file = os.path.join(prod_dir, dir_or_file, afilename)
DBG.write("check_config_exists 222", config_file, verbose)
if not os.path.exists(config_file):
continue
-
- # check if there is the config described in the file corresponds the
+
+ # check if there is the config described in the file corresponds the
# dependencies of the product
- config_corresponds = True
+ config_corresponds = True
compile_cfg = src.pyconf.Config(config_file)
for prod_dep in depend_all:
- # if the dependency is not in the config,
+ # if the dependency is not in the config,
# the config does not correspond
if prod_dep not in compile_cfg:
config_corresponds = False
break
else:
prod_dep_info = get_product_config(config, prod_dep, False)
- # If the version of the dependency does not correspond,
+ # If the version of the dependency does not correspond,
# the config does not correspond
if prod_dep_info.version != compile_cfg[prod_dep]:
config_corresponds = False
break
if config_corresponds:
- for prod_name in compile_cfg:
- # assume new compatibility with prod_name in sat-config.pyconf files
- if prod_name == prod_info.name:
- if prod_info.version == compile_cfg[prod_name]:
- DBG.write("check_config_exists OK 333", compile_cfg, verbose)
- pass
- else: # no correspondence with newer with prod_name sat-config.pyconf files
- config_corresponds = False
- break
- else:
- # as old compatibility without prod_name sat-config.pyconf files
- if prod_name not in depend_all:
- # here there is an unexpected depend in an old compilation
- config_corresponds = False
- break
-
- if config_corresponds: # returns (and stops) at first correspondence found
+ for prod_name in compile_cfg:
+ # assume new compatibility with prod_name in sat-config.pyconf files
+ if prod_name == prod_info.name:
+ if prod_info.version == compile_cfg[prod_name]:
+ DBG.write("check_config_exists OK 333", compile_cfg, verbose)
+ pass
+ else: # no correspondence with newer with prod_name sat-config.pyconf files
+ config_corresponds = False
+ break
+ else:
+ # as old compatibility without prod_name sat-config.pyconf files
+ if prod_name not in depend_all:
+ # here there is an unexpected depend in an old compilation
+ config_corresponds = False
+ break
+
+ if config_corresponds: # returns (and stops) at first correspondence found
DBG.write("check_config_exists OK 444", dir_or_file, verbose)
return True, os.path.join(prod_dir, dir_or_file)
# no correspondence found
return False, None
-
-
-
+
+
def get_products_infos(lproducts, config):
"""Get the specific configuration of a list of products
-
+
:param lproducts List: The list of product names
:param config Config: The global configuration
- :return: the list of tuples
+ :return: the list of tuples
(product name, specific configuration of the product)
:rtype: [(str, Config)]
"""
products_infos = []
# Loop on product names
- for prod in lproducts:
+ for prod in lproducts:
# Get the specific configuration of the product
prod_info = get_product_config(config, prod)
if prod_info is not None:
resAll = src.product.get_products_infos(products, cfg)
# if the property option was passed, filter the list
- if options.properties: # existing properties
- ok = []
- ko = []
- res =[]
- prop, value = options.properties # for example 'is_SALOME_module', 'yes'
- if value[0] == '!':
- for p_name, p_info in resAll:
- try:
- if p_info.properties[prop] == value[1:]:
- ko.append(p_name)
- else:
- res.append((p_name, p_info))
- ok.append(p_name)
- except:
- res.append((p_name, p_info))
- ok.append(p_name)
- else:
- for p_name, p_info in resAll:
- try:
- if p_info.properties[prop] == value:
- res.append((p_name, p_info))
- ok.append(p_name)
- else:
- ko.append(p_name)
- except:
- ko.append(p_name)
-
- if len(ok) != len(resAll):
- logger.trace("on properties %s\n products accepted:\n %s\n products rejected:\n %s\n" %
- (options.properties, PP.pformat(sorted(ok)), PP.pformat(sorted(ko))))
- else:
- logger.warning("properties %s\n seems useless with no products rejected" %
- (options.properties))
+ if options.properties: # existing properties
+ ok = []
+ ko = []
+ res = []
+ prop, value = options.properties # for example 'is_SALOME_module', 'yes'
+ if value[0] == "!":
+ for p_name, p_info in resAll:
+ try:
+ if p_info.properties[prop] == value[1:]:
+ ko.append(p_name)
+ else:
+ res.append((p_name, p_info))
+ ok.append(p_name)
+ except:
+ res.append((p_name, p_info))
+ ok.append(p_name)
+ else:
+ for p_name, p_info in resAll:
+ try:
+ if p_info.properties[prop] == value:
+ res.append((p_name, p_info))
+ ok.append(p_name)
+ else:
+ ko.append(p_name)
+ except:
+ ko.append(p_name)
+
+ if len(ok) != len(resAll):
+ logger.trace(
+ "on properties %s\n products accepted:\n %s\n products rejected:\n %s\n"
+ % (options.properties, PP.pformat(sorted(ok)), PP.pformat(sorted(ko)))
+ )
+ else:
+ logger.warning(
+ "properties %s\n seems useless with no products rejected"
+ % (options.properties)
+ )
else:
- res = resAll # not existing properties as all accepted
+ res = resAll # not existing properties as all accepted
return res
:rtype: list
"""
from compile import get_dependencies_graph, depth_search_graph
- all_products_infos = get_products_infos(
- config.APPLICATION.products,
- config)
- all_products_graph=get_dependencies_graph(all_products_infos)
- res=[]
- res=depth_search_graph(all_products_graph, product_name, res)
+
+ all_products_infos = get_products_infos(config.APPLICATION.products, config)
+ all_products_graph = get_dependencies_graph(all_products_infos)
+ res = []
+ res = depth_search_graph(all_products_graph, product_name, res)
return res[1:] # remove the product himself (in first position)
+
def check_installation(config, product_info):
"""\
Verify if a product is well installed. Checks install directory presence
if product_is_native(product_info):
# check a system product
- check_cmd=src.system.get_pkg_check_cmd(config.VARS.dist_name)
- run_pkg,build_pkg=src.product.check_system_dep(config.VARS.dist, check_cmd, product_info)
- build_dep_ko=[]
+ check_cmd = src.system.get_pkg_check_cmd(config.VARS.dist_name)
+ run_pkg, build_pkg = src.product.check_system_dep(
+ config.VARS.dist, check_cmd, product_info
+ )
+ build_dep_ko = []
for pkg in build_pkg:
if "KO" in build_pkg[pkg]:
build_dep_ko.append(pkg)
if build_dep_ko:
# the product is not installed : display message and return error status
- msg="Please install them with %s before compiling salome" % check_cmd[0]
+ msg = "Please install them with %s before compiling salome" % check_cmd[0]
print(build_pkg)
print("\nmissing compile time dependencies : ")
for md in build_dep_ko:
return False
else:
filename = CONFIG_FILENAME + product_info.name + ".pyconf"
- if not os.path.exists(os.path.join(install_dir, filename)):
+ if not os.path.exists(os.path.join(install_dir, filename)):
return False
# check extra files if specified in present_files.install section
- if ("present_files" in product_info and
- "install" in product_info.present_files):
+ if "present_files" in product_info and "install" in product_info.present_files:
for file_relative_path in product_info.present_files.install:
file_path = os.path.join(install_dir, file_relative_path)
if not os.path.exists(file_path):
return False
return True
+
def check_source(product_info):
"""Verify if a sources of product is preset. Checks source directory presence
-
- :param product_info Config: The configuration specific to
+
+ :param product_info Config: The configuration specific to
the product
:return: True if it is well installed
:rtype: boolean
source_dir = product_info.source_dir
if not os.path.exists(source_dir):
return False
- if ("present_files" in product_info and
- "source" in product_info.present_files):
+ if "present_files" in product_info and "source" in product_info.present_files:
for file_relative_path in product_info.present_files.source:
file_path = os.path.join(source_dir, file_relative_path)
if not os.path.exists(file_path):
return False
return True
+
def product_is_salome(product_info):
"""Know if a product is a SALOME module
-
- :param product_info Config: The configuration specific to
+
+ :param product_info Config: The configuration specific to
the product
:return: True if the product is a SALOME module, else False
:rtype: boolean
"""
- return ("properties" in product_info and
- "is_SALOME_module" in product_info.properties and
- product_info.properties.is_SALOME_module == "yes")
+ return (
+ "properties" in product_info
+ and "is_SALOME_module" in product_info.properties
+ and product_info.properties.is_SALOME_module == "yes"
+ )
+
def product_is_configuration(product_info):
"""Know if a product is a configuration module
-
- :param product_info Config: The configuration specific to
+
+ :param product_info Config: The configuration specific to
the product
:return: True if the product is a configuration module, else False
:rtype: boolean
"""
- return ("properties" in product_info and
- "configure_dependency" in product_info.properties and
- product_info.properties.configure_dependency == "yes")
+ return (
+ "properties" in product_info
+ and "configure_dependency" in product_info.properties
+ and product_info.properties.configure_dependency == "yes"
+ )
+
def product_is_fixed(product_info):
"""Know if a product is fixed
-
- :param product_info Config: The configuration specific to
+
+ :param product_info Config: The configuration specific to
the product
:return: True if the product is fixed, else False
:rtype: boolean
"""
get_src = product_info.get_source
- return get_src.lower() == 'fixed'
+ return get_src.lower() == "fixed"
+
def product_is_native(product_info):
"""Know if a product is native
-
- :param product_info Config: The configuration specific to
+
+ :param product_info Config: The configuration specific to
the product
:return: True if the product is native, else False
:rtype: boolean
"""
get_src = product_info.get_source
- return get_src.lower() == 'native'
+ return get_src.lower() == "native"
+
def product_is_dev(product_info):
"""Know if a product is in dev mode
-
- :param product_info Config: The configuration specific to
+
+ :param product_info Config: The configuration specific to
the product
:return: True if the product is in dev mode, else False
:rtype: boolean
"""
dev = product_info.dev
- res = (dev.lower() == 'yes')
- DBG.write('product_is_dev %s' % product_info.name, res)
+ res = dev.lower() == "yes"
+ DBG.write("product_is_dev %s" % product_info.name, res)
# if product_info.name == "XDATA": return True #test #10569
return res
+
def product_is_hpc(product_info):
"""Know if a product is in hpc mode
-
- :param product_info Config: The configuration specific to
+
+ :param product_info Config: The configuration specific to
the product
:return: True if the product is in hpc mode, else False
:rtype: boolean
"""
hpc = product_info.hpc
- res = (hpc.lower() == 'yes')
+ res = hpc.lower() == "yes"
return res
+
def product_is_debug(product_info):
"""Know if a product is in debug mode
-
- :param product_info Config: The configuration specific to
+
+ :param product_info Config: The configuration specific to
the product
:return: True if the product is in debug mode, else False
:rtype: boolean
"""
debug = product_info.debug
- return debug.lower() == 'yes'
+ return debug.lower() == "yes"
+
def product_is_verbose(product_info):
"""Know if a product is in verbose mode
-
- :param product_info Config: The configuration specific to
+
+ :param product_info Config: The configuration specific to
the product
:return: True if the product is in verbose mode, else False
:rtype: boolean
"""
verbose = product_info.verbose
- return verbose.lower() == 'yes'
+ return verbose.lower() == "yes"
+
def product_is_autotools(product_info):
"""Know if a product is compiled using the autotools
-
- :param product_info Config: The configuration specific to
+
+ :param product_info Config: The configuration specific to
the product
:return: True if the product is autotools, else False
:rtype: boolean
"""
build_src = product_info.build_source
- return build_src.lower() == 'autotools'
+ return build_src.lower() == "autotools"
+
def product_is_cmake(product_info):
"""Know if a product is compiled using the cmake
-
- :param product_info Config: The configuration specific to
+
+ :param product_info Config: The configuration specific to
the product
:return: True if the product is cmake, else False
:rtype: boolean
"""
build_src = product_info.build_source
- return build_src.lower() == 'cmake'
+ return build_src.lower() == "cmake"
+
def product_is_vcs(product_info):
"""Know if a product is download using git, svn or cvs (not archive)
-
- :param product_info Config: The configuration specific to
+
+ :param product_info Config: The configuration specific to
the product
:return: True if the product is vcs, else False
:rtype: boolean
"""
return product_info.get_source in AVAILABLE_VCS
+
def product_is_smesh_plugin(product_info):
"""Know if a product is a SMESH plugin
-
- :param product_info Config: The configuration specific to
+
+ :param product_info Config: The configuration specific to
the product
:return: True if the product is a SMESH plugin, else False
:rtype: boolean
"""
- return ("properties" in product_info and
- "smesh_plugin" in product_info.properties and
- product_info.properties.smesh_plugin == "yes")
+ return (
+ "properties" in product_info
+ and "smesh_plugin" in product_info.properties
+ and product_info.properties.smesh_plugin == "yes"
+ )
+
def product_is_cpp(product_info):
"""Know if a product is cpp
-
- :param product_info Config: The configuration specific to
+
+ :param product_info Config: The configuration specific to
the product
:return: True if the product is a cpp, else False
:rtype: boolean
"""
- return ("properties" in product_info and
- "cpp" in product_info.properties and
- product_info.properties.cpp == "yes")
+ return (
+ "properties" in product_info
+ and "cpp" in product_info.properties
+ and product_info.properties.cpp == "yes"
+ )
+
def product_compiles(product_info):
"""\
:return: True if the product compiles, else False
:rtype: boolean
"""
- return not("properties" in product_info and
- "compilation" in product_info.properties and
- product_info.properties.compilation == "no")
+ return not (
+ "properties" in product_info
+ and "compilation" in product_info.properties
+ and product_info.properties.compilation == "no"
+ )
+
def product_has_script(product_info):
"""Know if a product has a compilation script
-
- :param product_info Config: The configuration specific to
+
+ :param product_info Config: The configuration specific to
the product
:return: True if the product it has a compilation script, else False
:rtype: boolean
# Native case
return False
build_src = product_info.build_source
- return build_src.lower() == 'script'
+ return build_src.lower() == "script"
+
def product_has_env_script(product_info):
"""Know if a product has an environment script
-
- :param product_info Config: The configuration specific to
+
+ :param product_info Config: The configuration specific to
the product
:return: True if the product it has an environment script, else False
:rtype: boolean
"""
return "environ" in product_info and "env_script" in product_info.environ
+
def product_has_patches(product_info):
"""Know if a product has one or more patches
-
- :param product_info Config: The configuration specific to
+
+ :param product_info Config: The configuration specific to
the product
:return: True if the product has one or more patches
:rtype: boolean
- """
- res = ( "patches" in product_info and len(product_info.patches) > 0 )
+ """
+ res = "patches" in product_info and len(product_info.patches) > 0
return res
+
def product_has_post_script(product_info):
"""Know if a product has a post install script
-
- :param product_info Config: The configuration specific to
+
+ :param product_info Config: The configuration specific to
the product
:return: True if the product has one or more patches
:rtype: boolean
- """
- res = ( "post_script" in product_info and len(product_info.post_script) > 0 and not src.architecture.is_windows())
+ """
+ res = (
+ "post_script" in product_info
+ and len(product_info.post_script) > 0
+ and not src.architecture.is_windows()
+ )
return res
+
def product_has_logo(product_info):
"""Know if a product has a logo (YACSGEN generate)
-
- :param product_info Config: The configuration specific to
+
+ :param product_info Config: The configuration specific to
the product
:return: The path of the logo if the product has a logo, else False
:rtype: Str
"""
- if ("properties" in product_info and
- "logo" in product_info.properties):
+ if "properties" in product_info and "logo" in product_info.properties:
return product_info.properties.logo
else:
return False
+
def product_has_licence(product_info, path):
"""Find out if a product has a licence
-
+
:param product_info Config: The configuration specific to the product
:param path Str: The path where to search for the licence
:return: The name of the licence file (the complete path if it is found in the path, else the name, else False
:rtype: Str
"""
- if ("properties" in product_info and
- "licence" in product_info.properties):
+ if "properties" in product_info and "licence" in product_info.properties:
licence_name = product_info.properties.licence
if len(path) > 0:
# search for licence_name in path
# a- consolidate the path into one signe string licence_path
- licence_path=path[0]
+ licence_path = path[0]
for lpath in path[1:]:
- licence_path=licence_path+":"+lpath
- licence_path_list=licence_path.split(":")
+ licence_path = licence_path + ":" + lpath
+ licence_path_list = licence_path.split(":")
licence_fullname = src.find_file_in_lpath(licence_name, licence_path_list)
if licence_fullname:
return licence_fullname
- # if the search of licence in path failed, we return its name (not the full path)
+ # if the search of licence in path failed, we return its name (not the full path)
return licence_name
else:
return False # product has no licence
+
def product_has_salome_gui(product_info):
"""Know if a product has a SALOME gui
-
- :param product_info Config: The configuration specific to
+
+ :param product_info Config: The configuration specific to
the product
:return: True if the product has a SALOME gui, else False
:rtype: Boolean
"""
- return ("properties" in product_info and
- "has_salome_gui" in product_info.properties and
- product_info.properties.has_salome_gui == "yes")
+ return (
+ "properties" in product_info
+ and "has_salome_gui" in product_info.properties
+ and product_info.properties.has_salome_gui == "yes"
+ )
+
def product_is_mpi(product_info):
"""Know if a product has openmpi in its dependencies
-
- :param product_info Config: The configuration specific to
+
+ :param product_info Config: The configuration specific to
the product
:return: True if the product has openmpi inits dependencies
:rtype: boolean
"""
return "openmpi" in product_info.depend
+
def product_is_generated(product_info):
"""Know if a product is generated (YACSGEN)
-
- :param product_info Config: The configuration specific to
+
+ :param product_info Config: The configuration specific to
the product
:return: True if the product is generated
:rtype: boolean
"""
- return ("properties" in product_info and
- "generate" in product_info.properties and
- product_info.properties.generate == "yes")
+ return (
+ "properties" in product_info
+ and "generate" in product_info.properties
+ and product_info.properties.generate == "yes"
+ )
+
def product_is_compile_time(product_info):
"""Know if a product is only used at compile time
-
- :param product_info Config: The configuration specific to
+
+ :param product_info Config: The configuration specific to
the product
:return: True if the product is only used at compile time
:rtype: boolean
"""
- return ("properties" in product_info and
- "compile_time" in product_info.properties and
- product_info.properties.compile_time == "yes")
+ return (
+ "properties" in product_info
+ and "compile_time" in product_info.properties
+ and product_info.properties.compile_time == "yes"
+ )
+
def product_is_compile_and_runtime(product_info):
"""Know if a product is only used at compile time
-
- :param product_info Config: The configuration specific to
+
+ :param product_info Config: The configuration specific to
the product
:return: True if the product is only used at compile time
:rtype: boolean
"""
- return ("properties" in product_info and
- "compile_and_runtime" in product_info.properties and
- product_info.properties.compile_and_runtime == "yes")
-
+ return (
+ "properties" in product_info
+ and "compile_and_runtime" in product_info.properties
+ and product_info.properties.compile_and_runtime == "yes"
+ )
def product_test_property(product_info, property_name, property_value):
"""Generic function to test if a product has a property set to a value
-
- :param product_info Config: The configuration specific to
+
+ :param product_info Config: The configuration specific to
the product
:param property_name : The name of the property to check
:param property_value : The value of the property to test
:rtype: boolean
"""
# first check if product has the property
- if not ("properties" in product_info and
- property_name in product_info.properties):
+ if not ("properties" in product_info and property_name in product_info.properties):
return False
-
+
# then check to the property is set to property_value
- eval_expression = 'product_info.properties.%s == "%s"' % (property_name,property_value)
+ eval_expression = 'product_info.properties.%s == "%s"' % (
+ property_name,
+ property_value,
+ )
result = eval(eval_expression)
return result
+
def check_system_dep(distrib, check_cmd, product_info):
"""Search for system dependencies, check if installed
:param dist : The linux ditribution (CO7,DB10...)
:param product_info Config: The configuration specific to the product
:rtype: two dictionnaries for runtime and compile time dependencies with text status
"""
- runtime_dep={}
- build_dep={}
+ runtime_dep = {}
+ build_dep = {}
if "system_info" in product_info:
- sysinfo=product_info.system_info
+ sysinfo = product_info.system_info
additional_sysinfo = None
- for key in sysinfo :
- if distrib in key :
+ for key in sysinfo:
+ if distrib in key:
additional_sysinfo = sysinfo[key]
- if check_cmd[0]=="rpm":
+ if check_cmd[0] == "rpm":
if "rpm" in sysinfo:
for pkg in sysinfo.rpm:
- runtime_dep[pkg]=src.system.check_system_pkg(check_cmd,pkg)
+ runtime_dep[pkg] = src.system.check_system_pkg(check_cmd, pkg)
if "rpm_dev" in sysinfo:
for pkg in sysinfo.rpm_dev:
- build_dep[pkg]=src.system.check_system_pkg(check_cmd,pkg)
- if additional_sysinfo :
+ build_dep[pkg] = src.system.check_system_pkg(check_cmd, pkg)
+ if additional_sysinfo:
if "rpm" in additional_sysinfo:
for pkg in additional_sysinfo.rpm:
- runtime_dep[pkg]=src.system.check_system_pkg(check_cmd,pkg)
+ runtime_dep[pkg] = src.system.check_system_pkg(check_cmd, pkg)
if "rpm_dev" in additional_sysinfo:
for pkg in additional_sysinfo.rpm_dev:
- build_dep[pkg]=src.system.check_system_pkg(check_cmd,pkg)
- #if check_cmd[0]=="apt" or check_cmd[0]=="dpkg-query":
+ build_dep[pkg] = src.system.check_system_pkg(check_cmd, pkg)
+ # if check_cmd[0]=="apt" or check_cmd[0]=="dpkg-query":
else:
if "apt" in sysinfo:
for pkg in sysinfo.apt:
- runtime_dep[pkg]=src.system.check_system_pkg(check_cmd,pkg)
+ runtime_dep[pkg] = src.system.check_system_pkg(check_cmd, pkg)
if "apt_dev" in sysinfo:
for pkg in sysinfo.apt_dev:
- build_dep[pkg]=src.system.check_system_pkg(check_cmd,pkg)
- if additional_sysinfo :
+ build_dep[pkg] = src.system.check_system_pkg(check_cmd, pkg)
+ if additional_sysinfo:
if "apt" in additional_sysinfo:
for pkg in additional_sysinfo.apt:
- runtime_dep[pkg]=src.system.check_system_pkg(check_cmd,pkg)
+ runtime_dep[pkg] = src.system.check_system_pkg(check_cmd, pkg)
if "apt_dev" in additional_sysinfo:
for pkg in additional_sysinfo.apt_dev:
- build_dep[pkg]=src.system.check_system_pkg(check_cmd,pkg)
+ build_dep[pkg] = src.system.check_system_pkg(check_cmd, pkg)
- return runtime_dep,build_dep
+ return runtime_dep, build_dep
def get_product_components(product_info):
"""Get the component list to generate with the product
-
- :param product_info Config: The configuration specific to
+
+ :param product_info Config: The configuration specific to
the product
:return: The list of names of the components
:rtype: List
-
+
"""
if not product_is_generated(product_info):
return []
-
+
compo_list = []
if "component_name" in product_info:
compo_list = product_info.component_name
-
+
if isinstance(compo_list, str):
- compo_list = [ compo_list ]
+ compo_list = [compo_list]
return compo_list
+
+
def product_is_wheel(product_info):
- """ tells whether a product is a wheel
-
- :param product_info Config: The configuration specific to
+ """tells whether a product is a wheel
+
+ :param product_info Config: The configuration specific to
the product
:return: True if the product has a wheel, else False
:rtype: Boolean
"""
- return ("properties" in product_info and
- "is_wheel" in product_info.properties and
- product_info.properties.is_wheel == "yes")
-
+ return (
+ "properties" in product_info
+ and "is_wheel" in product_info.properties
+ and product_info.properties.is_wheel == "yes"
+ )
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright 2004-2007 by Vinay Sajip. All Rights Reserved.
#
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-# CEA adds :
+# CEA adds :
# Possibility to overwrites value in a pyconf file
# Python 3 porting
of how it's used, see test_config.py (search for streamOpener).
"""
-__author__ = "Vinay Sajip <vinay_sajip@red-dove.com>"
-__status__ = "alpha"
-__version__ = "0.3.7.1" #modified for salomeTools
-__date__ = "05 October 2007"
+__author__ = "Vinay Sajip <vinay_sajip@red-dove.com>"
+__status__ = "alpha"
+__version__ = "0.3.7.1" # modified for salomeTools
+__date__ = "05 October 2007"
import codecs
import os
import sys
-WORD = 'a'
-NUMBER = '9'
+WORD = "a"
+NUMBER = "9"
STRING = '"'
-EOF = ''
-LCURLY = '{'
-RCURLY = '}'
-LBRACK = '['
-LBRACK2 = 'a['
-RBRACK = ']'
-LPAREN = '('
-LPAREN2 = '(('
-RPAREN = ')'
-DOT = '.'
-COMMA = ','
-COLON = ':'
-AT = '@'
-PLUS = '+'
-MINUS = '-'
-STAR = '*'
-SLASH = '/'
-MOD = '%'
-BACKTICK = '`'
-DOLLAR = '$'
-TRUE = 'True'
-FALSE = 'False'
-NONE = 'None'
+EOF = ""
+LCURLY = "{"
+RCURLY = "}"
+LBRACK = "["
+LBRACK2 = "a["
+RBRACK = "]"
+LPAREN = "("
+LPAREN2 = "(("
+RPAREN = ")"
+DOT = "."
+COMMA = ","
+COLON = ":"
+AT = "@"
+PLUS = "+"
+MINUS = "-"
+STAR = "*"
+SLASH = "/"
+MOD = "%"
+BACKTICK = "`"
+DOLLAR = "$"
+TRUE = "True"
+FALSE = "False"
+NONE = "None"
WORDCHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_"
-if sys.platform == 'win32':
- NEWLINE = '\r\n'
-elif os.name == 'mac':
- NEWLINE = '\r'
+if sys.platform == "win32":
+ NEWLINE = "\r\n"
+elif os.name == "mac":
+ NEWLINE = "\r"
else:
- NEWLINE = '\n'
+ NEWLINE = "\n"
try:
has_utf32 = True
except:
has_utf32 = False
+
class ConfigInputStream(object):
"""
An input stream which can read either ANSI files with default encoding
Handles UTF-8, UTF-16LE, UTF-16BE. Could handle UTF-32 if Python had
built-in support.
"""
+
def __init__(self, stream):
"""
Initialize an instance.
used = -1
if has_utf32:
if signature == codecs.BOM_UTF32_LE:
- encoding = 'utf-32le'
+ encoding = "utf-32le"
elif signature == codecs.BOM_UTF32_BE:
- encoding = 'utf-32be'
+ encoding = "utf-32be"
if encoding is None:
if signature[:3] == codecs.BOM_UTF8:
used = 3
- encoding = 'utf-8'
+ encoding = "utf-8"
elif signature[:2] == codecs.BOM_UTF16_LE:
used = 2
- encoding = 'utf-16le'
+ encoding = "utf-16le"
elif signature[:2] == codecs.BOM_UTF16_BE:
used = 2
- encoding = 'utf-16be'
+ encoding = "utf-16be"
else:
used = 0
if used >= 0:
if (size == 0) or (self.encoding is None):
rv = self.stream.read(size)
else:
- rv = u''
+ rv = u""
while size > 0:
rv += self.stream.read(1)
size -= 1
def readline(self):
if self.encoding is None:
- line = ''
+ line = ""
else:
- line = u''
+ line = u""
while True:
c = self.stream.read(1)
if isinstance(c, bytes):
c = c.decode()
if c:
line += c
- if c == '\n':
+ if c == "\n":
break
return line
+
class ConfigOutputStream(object):
"""
An output stream which can write either ANSI files with default encoding
def close(self):
self.stream.close()
+
def defaultStreamOpener(name):
"""\
This function returns a read-only stream, given its name. The name passed
@return: A stream with the specified name.
@rtype: A read-only stream (file-like object)
"""
- return ConfigInputStream(open(name, 'rb'))
+ return ConfigInputStream(open(name, "rb"))
+
streamOpener = None
__resolveOverwrite__ = True
+
class ConfigError(Exception):
"""
This is the base class of exceptions raised by this module.
"""
+
pass
+
class ConfigFormatError(ConfigError):
"""
This is the base class of exceptions raised due to syntax errors in
configurations.
"""
+
pass
+
class ConfigResolutionError(ConfigError):
"""
This is the base class of exceptions raised due to semantic errors in
configurations.
"""
+
pass
+
def isWord(s):
"""
See if a passed-in value is an identifier. If the value passed in is not a
@return: True if a word, else False
@rtype: bool
"""
- if type(s) != type(''):
+ if type(s) != type(""):
return False
- s = s.replace('_', '')
+ s = s.replace("_", "")
return s.isalnum()
+
def makePath(prefix, suffix):
"""\
Make a path from a prefix and suffix.
"""
if not prefix:
rv = suffix
- elif suffix[0] == '[':
+ elif suffix[0] == "[":
rv = prefix + suffix
else:
- rv = prefix + '.' + suffix
+ rv = prefix + "." + suffix
return rv
a.list.of[1].or['more'].elements
"""
+
def __init__(self, parent):
"""
Initialize an instance.
@param parent: The parent of this instance in the hierarchy.
@type parent: A L{Container} instance.
"""
- object.__setattr__(self, 'parent', parent)
+ object.__setattr__(self, "parent", parent)
def setPath(self, path):
"""
to this instance from the root of the hierarchy.
@type path: str
"""
- object.__setattr__(self, 'path', path)
+ object.__setattr__(self, "path", path)
def evaluate(self, item):
"""
def writeValue(self, value, stream, indent, evaluated=False):
if isinstance(self, Mapping):
- indstr = ' '
+ indstr = " "
else:
- indstr = indent * ' '
+ indstr = indent * " "
if isinstance(value, Reference) or isinstance(value, Expression):
if not evaluated:
- stream.write('%s%r%s' % (indstr, value, NEWLINE))
+ stream.write("%s%r%s" % (indstr, value, NEWLINE))
else:
- stream.write('%s%r%s' % (indstr, self.evaluate(value), NEWLINE))
+ stream.write("%s%r%s" % (indstr, self.evaluate(value), NEWLINE))
else:
- if isinstance(value, str): # and not isWord(value):
+ if isinstance(value, str): # and not isWord(value):
value = repr(value)
- stream.write('%s%s%s' % (indstr, value, NEWLINE))
+ stream.write("%s%s%s" % (indstr, value, NEWLINE))
+
class Mapping(Container):
"""
@type parent: A L{Container} instance.
"""
Container.__init__(self, parent)
- object.__setattr__(self, 'path', '')
- object.__setattr__(self, 'data', {})
- object.__setattr__(self, 'order', []) # to preserve ordering
- object.__setattr__(self, 'comments', {})
+ object.__setattr__(self, "path", "")
+ object.__setattr__(self, "data", {})
+ object.__setattr__(self, "order", []) # to preserve ordering
+ object.__setattr__(self, "comments", {})
def __delitem__(self, key):
"""
Remove an item
"""
- data = object.__getattribute__(self, 'data')
+ data = object.__getattribute__(self, "data")
if key not in data:
raise AttributeError(key)
- order = object.__getattribute__(self, 'order')
- comments = object.__getattribute__(self, 'comments')
+ order = object.__getattribute__(self, "order")
+ comments = object.__getattribute__(self, "comments")
del data[key]
order.remove(key)
del comments[key]
def __getitem__(self, key):
- data = object.__getattribute__(self, 'data')
+ data = object.__getattribute__(self, "data")
if key not in data:
raise AttributeError("Unknown pyconf key: '%s'" % key)
rv = data[key]
return self.evaluate(rv)
__getattr__ = __getitem__
-
- '''
+
+ """
def __getattribute__(self, name):
if name == "__dict__":
return {}
if rv is None:
raise AttributeError(name)
return rv
- '''
+ """
def iteritems(self):
for key in self.keys():
- yield(key, self[key])
+ yield (key, self[key])
raise StopIteration
def __contains__(self, item):
- order = object.__getattribute__(self, 'order')
+ order = object.__getattribute__(self, "order")
return item in order
def addMapping(self, key, value, comment, setting=False):
@raise ConfigFormatError: If an existing key is seen
again and setting is False.
"""
- data = object.__getattribute__(self, 'data')
- order = object.__getattribute__(self, 'order')
- comments = object.__getattribute__(self, 'comments')
+ data = object.__getattribute__(self, "data")
+ order = object.__getattribute__(self, "order")
+ comments = object.__getattribute__(self, "comments")
data[key] = value
if key not in order:
"""
Return the keys in a similar way to a dictionary.
"""
- return object.__getattribute__(self, 'order')
+ return object.__getattribute__(self, "order")
def get(self, key, default=None):
"""
return default
def __str__(self):
- return str(object.__getattribute__(self, 'data'))
+ return str(object.__getattribute__(self, "data"))
def __repr__(self):
- return repr(object.__getattribute__(self, 'data'))
+ return repr(object.__getattribute__(self, "data"))
def __len__(self):
- return len(object.__getattribute__(self, 'order'))
+ return len(object.__getattribute__(self, "order"))
def __iter__(self):
return self.iterkeys()
def iterkeys(self):
- order = object.__getattribute__(self, 'order')
+ order = object.__getattribute__(self, "order")
return order.__iter__()
def writeToStream(self, stream, indent, container, evaluated=False):
@param container: The container of this instance
@type container: L{Container}
"""
- indstr = indent * ' '
+ indstr = indent * " "
if len(self) == 0:
- stream.write(' { }%s' % NEWLINE)
+ stream.write(" { }%s" % NEWLINE)
else:
if isinstance(container, Mapping):
stream.write(NEWLINE)
- stream.write('%s{%s' % (indstr, NEWLINE))
+ stream.write("%s{%s" % (indstr, NEWLINE))
self.__save__(stream, indent + 1, evaluated=evaluated)
- stream.write('%s}%s' % (indstr, NEWLINE))
+ stream.write("%s}%s" % (indstr, NEWLINE))
def __save__(self, stream, indent=0, evaluated=False):
"""
@param indent: The indentation level for the output.
@type indent: int
"""
- indstr = indent * ' '
- order = object.__getattribute__(self, 'order')
- data = object.__getattribute__(self, 'data')
- maxlen = 0 # max(map(lambda x: len(x), order))
+ indstr = indent * " "
+ order = object.__getattribute__(self, "order")
+ data = object.__getattribute__(self, "data")
+ maxlen = 0 # max(map(lambda x: len(x), order))
for key in order:
comment = self.comments[key]
if isWord(key):
else:
skey = repr(key)
if comment:
- stream.write('%s#%s' % (indstr, comment))
+ stream.write("%s#%s" % (indstr, comment))
if skey.startswith("u'"):
skey = skey[1:]
- stream.write('%s%-*s :' % (indstr, maxlen, skey))
+ stream.write("%s%-*s :" % (indstr, maxlen, skey))
value = data[key]
if isinstance(value, Container):
value.writeToStream(stream, indent, self, evaluated=evaluated)
else:
self.writeValue(value, stream, indent, evaluated=evaluated)
+
class Config(Mapping):
"""
This class represents a configuration, and is the only one which clients
An instance acts as a namespace.
"""
+
def __init__(self):
self.sys = sys
self.os = os
- def __init__(self, streamOrFile=None, parent=None, PWD = None):
+ def __init__(self, streamOrFile=None, parent=None, PWD=None):
"""
Initializes an instance.
in the configuration hierarchy.
@type parent: a L{Container} instance.
"""
- try: # Python 3 compatibility
+ try: # Python 3 compatibility
if isinstance(streamOrFile, unicode):
streamOrFile = streamOrFile.encode()
except NameError:
pass
Mapping.__init__(self, parent)
- object.__setattr__(self, 'reader', ConfigReader(self))
- object.__setattr__(self, 'namespaces', [Config.Namespace()])
+ object.__setattr__(self, "reader", ConfigReader(self))
+ object.__setattr__(self, "namespaces", [Config.Namespace()])
if streamOrFile is not None:
if isinstance(streamOrFile, str) or isinstance(streamOrFile, bytes):
global streamOpener
existing keys.
@raise ConfigFormatError: if there is a syntax error in the stream.
"""
- reader = object.__getattribute__(self, 'reader')
+ reader = object.__getattribute__(self, "reader")
reader.load(stream)
stream.close()
an additional level of indirection.
@type name: str
"""
- namespaces = object.__getattribute__(self, 'namespaces')
+ namespaces = object.__getattribute__(self, "namespaces")
if name is None:
namespaces.append(ns)
else:
called.
@type name: str
"""
- namespaces = object.__getattribute__(self, 'namespaces')
+ namespaces = object.__getattribute__(self, "namespaces")
if name is None:
namespaces.remove(ns)
else:
@rtype: any
@raise ConfigError: If the path is invalid
"""
- s = 'self.' + path
+ s = "self." + path
try:
return eval(s)
except Exception as e:
raise ConfigError(str(e))
+
class Sequence(Container):
"""
This internal class implements a value which is a sequence of other values.
"""
+
class SeqIter(object):
"""
This internal class implements an iterator for a L{Sequence} instance.
"""
+
def __init__(self, seq):
self.seq = seq
- self.limit = len(object.__getattribute__(seq, 'data'))
+ self.limit = len(object.__getattribute__(seq, "data"))
self.index = 0
def __iter__(self):
rv = self.seq[self.index]
self.index += 1
return rv
-
+
# This method is for python3 compatibility
- def __next__(self):
+ def __next__(self):
if self.index >= self.limit:
raise StopIteration
rv = self.seq[self.index]
@type parent: A L{Container} instance.
"""
Container.__init__(self, parent)
- object.__setattr__(self, 'data', [])
- object.__setattr__(self, 'comments', [])
+ object.__setattr__(self, "data", [])
+ object.__setattr__(self, "comments", [])
def append(self, item, comment):
"""
@param comment: A comment for the item.
@type comment: str
"""
- data = object.__getattribute__(self, 'data')
- comments = object.__getattribute__(self, 'comments')
+ data = object.__getattribute__(self, "data")
+ comments = object.__getattribute__(self, "comments")
data.append(item)
comments.append(comment)
def __getitem__(self, index):
- data = object.__getattribute__(self, 'data')
+ data = object.__getattribute__(self, "data")
try:
rv = data[index]
except (IndexError, KeyError, TypeError):
- raise ConfigResolutionError('Invalid pyconf index %r for %r' % (index, object.__getattribute__(self, 'path')))
+ raise ConfigResolutionError(
+ "Invalid pyconf index %r for %r"
+ % (index, object.__getattribute__(self, "path"))
+ )
if not isinstance(rv, list):
rv = self.evaluate(rv)
else:
return Sequence.SeqIter(self)
def __repr__(self):
- return repr(object.__getattribute__(self, 'data'))
+ return repr(object.__getattribute__(self, "data"))
def __str__(self):
- return str(self[:]) # using the slice evaluates the contents
+ return str(self[:]) # using the slice evaluates the contents
def __len__(self):
- return len(object.__getattribute__(self, 'data'))
+ return len(object.__getattribute__(self, "data"))
def writeToStream(self, stream, indent, container, evaluated=False):
"""
@param container: The container of this instance
@type container: L{Container}
"""
- indstr = indent * ' '
+ indstr = indent * " "
if len(self) == 0:
- stream.write(' [ ]%s' % NEWLINE)
+ stream.write(" [ ]%s" % NEWLINE)
else:
if isinstance(container, Mapping):
stream.write(NEWLINE)
- stream.write('%s[%s' % (indstr, NEWLINE))
+ stream.write("%s[%s" % (indstr, NEWLINE))
self.__save__(stream, indent + 1, evaluated=evaluated)
- stream.write('%s]%s' % (indstr, NEWLINE))
+ stream.write("%s]%s" % (indstr, NEWLINE))
def __save__(self, stream, indent, evaluated=False):
"""
"""
if indent == 0:
raise ConfigError("sequence cannot be saved as a top-level item")
- data = object.__getattribute__(self, 'data')
- comments = object.__getattribute__(self, 'comments')
- indstr = indent * ' '
+ data = object.__getattribute__(self, "data")
+ comments = object.__getattribute__(self, "comments")
+ indstr = indent * " "
for i in range(0, len(data)):
value = data[i]
comment = comments[i]
if comment:
- stream.write('%s#%s' % (indstr, comment))
+ stream.write("%s#%s" % (indstr, comment))
if isinstance(value, Container):
value.writeToStream(stream, indent, self, evaluated=evaluated)
else:
self.writeValue(value, stream, indent, evaluated=evaluated)
+
class Reference(object):
"""
This internal class implements a value which is a reference to another value.
"""
+
def __init__(self, config, type, ident):
"""
Initialize an instance.
@rtype: L{Config}
"""
while (container is not None) and not isinstance(container, Config):
- container = object.__getattribute__(container, 'parent')
+ container = object.__getattribute__(container, "parent")
return container
def resolve(self, container):
@raise ConfigResolutionError: If resolution fails.
"""
rv = None
- path = object.__getattribute__(container, 'path')
+ path = object.__getattribute__(container, "path")
current = container
while current is not None:
if self.type == BACKTICK:
- namespaces = object.__getattribute__(current, 'namespaces')
+ namespaces = object.__getattribute__(current, "namespaces")
found = False
for ns in namespaces:
try:
except:
rv = None
pass
- current = object.__getattribute__(current, 'parent')
+ current = object.__getattribute__(current, "parent")
if current is None:
- raise ConfigResolutionError("unable to evaluate %r in the configuration %s" % (self, path))
+ raise ConfigResolutionError(
+ "unable to evaluate %r in the configuration %s" % (self, path)
+ )
return rv
def __str__(self):
s = self.elements[0]
for tt, tv in self.elements[1:]:
if tt == DOT:
- s += '.%s' % tv
+ s += ".%s" % tv
else:
- s += '[%r]' % tv
+ s += "[%r]" % tv
if self.type == BACKTICK:
return BACKTICK + s + BACKTICK
else:
def __repr__(self):
return self.__str__()
+
class Expression(object):
"""
This internal class implements a value which is obtained by evaluating an expression.
"""
+
def __init__(self, op, lhs, rhs):
"""
Initialize an instance.
self.rhs = rhs
def __str__(self):
- return '%r %s %r' % (self.lhs, self.op, self.rhs)
+ return "%r %s %r" % (self.lhs, self.op, self.rhs)
def __repr__(self):
return self.__str__()
rv = lhs % rhs
return rv
+
class ConfigReader(object):
"""
This internal class implements a parser for configurations.
self.colno = 0
self.lastc = None
self.last_token = None
- self.commentchars = '#'
- self.whitespace = ' \t\r\n'
- self.quotes = '\'"'
- self.punct = ':-+*/%,.{}[]()@`$'
- self.digits = '0123456789'
- self.wordchars = '%s' % WORDCHARS # make a copy
+ self.commentchars = "#"
+ self.whitespace = " \t\r\n"
+ self.quotes = "'\""
+ self.punct = ":-+*/%,.{}[]()@`$"
+ self.digits = "0123456789"
+ self.wordchars = "%s" % WORDCHARS # make a copy
self.identchars = self.wordchars + self.digits
self.pbchars = []
self.pbtokens = []
"""
if self.pbchars:
c = self.pbchars.pop()
- if isinstance(c,bytes):
+ if isinstance(c, bytes):
c = c.decode()
else:
c = self.stream.read(1)
- if isinstance(c,bytes):
+ if isinstance(c, bytes):
c = c.decode()
self.colno += 1
- if c == '\n':
+ if c == "\n":
self.lineno += 1
self.colno = 1
return c
return self.pbtokens.pop()
stream = self.stream
self.comment = None
- token = ''
+ token = ""
tt = EOF
while True:
c = self.getChar()
if not c:
break
- elif c == '#':
- if self.comment :
- self.comment += '#' + stream.readline()
- else :
+ elif c == "#":
+ if self.comment:
+ self.comment += "#" + stream.readline()
+ else:
self.comment = stream.readline()
self.lineno += 1
continue
break
token += c
if (c == quote) and not escaped:
- if not multiline or (len(token) >= 6 and token.endswith(token[:3]) and token[-4] != '\\'):
+ if not multiline or (
+ len(token) >= 6
+ and token.endswith(token[:3])
+ and token[-4] != "\\"
+ ):
break
- if c == '\\':
+ if c == "\\":
escaped = not escaped
else:
escaped = False
if not c:
- raise ConfigFormatError('%s: Unterminated quoted string: %r, %r' % (self.location(), token, c))
+ raise ConfigFormatError(
+ "%s: Unterminated quoted string: %r, %r"
+ % (self.location(), token, c)
+ )
break
if c in self.whitespace:
self.lastc = c
elif c in self.punct:
token = c
tt = c
- if (self.lastc == ']') or (self.lastc in self.identchars):
- if c == '[':
+ if (self.lastc == "]") or (self.lastc in self.identchars):
+ if c == "[":
tt = LBRACK2
- elif c == '(':
+ elif c == "(":
tt = LPAREN2
break
elif c in self.digits:
break
if c in self.digits:
token += c
- elif (c == '.') and token.find('.') < 0:
+ elif (c == ".") and token.find(".") < 0:
token += c
else:
if c and (c not in self.whitespace):
while c and (c in self.identchars):
token += c
c = self.getChar()
- if c: # and c not in self.whitespace:
+ if c: # and c not in self.whitespace:
self.pbchars.append(c)
if token == "True":
tt = TRUE
tt = NONE
break
else:
- raise ConfigFormatError('%s: Unexpected character: %r' % (self.location(), c))
+ raise ConfigFormatError(
+ "%s: Unexpected character: %r" % (self.location(), c)
+ )
if token:
self.lastc = token[-1]
else:
self.lastc = None
self.last_token = tt
-
+
# Python 2.x specific unicode conversion
if sys.version_info[0] == 2 and tt == WORD and isinstance(token, unicode):
- token = token.encode('ascii')
+ token = token.encode("ascii")
return (tt, token)
def load(self, stream, parent=None, suffix=None):
"""
if parent is not None:
if suffix is None:
- raise ConfigError("internal error: load called with parent but no suffix")
- self.config.setPath(makePath(object.__getattribute__(parent, 'path'), suffix))
+ raise ConfigError(
+ "internal error: load called with parent but no suffix"
+ )
+ self.config.setPath(
+ makePath(object.__getattribute__(parent, "path"), suffix)
+ )
self.setStream(stream)
self.token = self.getToken()
self.parseMappingBody(self.config)
if self.token[0] != EOF:
- raise ConfigFormatError('%s: expecting EOF, found %r' % (self.location(), self.token[1]))
+ raise ConfigFormatError(
+ "%s: expecting EOF, found %r" % (self.location(), self.token[1])
+ )
def setStream(self, stream):
"""
@type stream: A stream (file-like object).
"""
self.stream = stream
- if hasattr(stream, 'name'):
+ if hasattr(stream, "name"):
filename = stream.name
else:
- filename = '?'
+ filename = "?"
self.filename = filename
self.lineno = 1
self.colno = 1
@raise ConfigFormatError: If the token does not match what's expected.
"""
if self.token[0] != t:
- raise ConfigFormatError("%s: expecting %s, found %r" % (self.location(), t, self.token[1]))
+ raise ConfigFormatError(
+ "%s: expecting %s, found %r" % (self.location(), t, self.token[1])
+ )
rv = self.token
self.token = self.getToken()
return rv
suffix = tv
elif tt == STRING:
key = eval(tv)
- suffix = '[%s]' % tv
+ suffix = "[%s]" % tv
else:
msg = "%s: expecting word or string, found %r"
raise ConfigFormatError(msg % (self.location(), tv))
try:
parent.addMapping(key, value, comment)
except Exception as e:
- raise ConfigFormatError("%s: %s, %r" % (self.location(), e,
- self.token[1]))
+ raise ConfigFormatError("%s: %s, %r" % (self.location(), e, self.token[1]))
tt = self.token[0]
if tt not in [EOF, WORD, STRING, RCURLY, COMMA]:
msg = "%s: expecting one of EOF, WORD, STRING, \
RCURLY, COMMA, found %r"
- raise ConfigFormatError(msg % (self.location(), self.token[1]))
+ raise ConfigFormatError(msg % (self.location(), self.token[1]))
if tt == COMMA:
self.token = self.getToken()
@raise ConfigFormatError: if a syntax error is found.
"""
tt = self.token[0]
- if tt in [STRING, WORD, NUMBER, LPAREN, DOLLAR,
- TRUE, FALSE, NONE, BACKTICK, MINUS]:
+ if tt in [
+ STRING,
+ WORD,
+ NUMBER,
+ LPAREN,
+ DOLLAR,
+ TRUE,
+ FALSE,
+ NONE,
+ BACKTICK,
+ MINUS,
+ ]:
rv = self.parseScalar()
elif tt == LBRACK:
rv = self.parseSequence(parent, suffix)
elif tt in [LCURLY, AT]:
rv = self.parseMapping(parent, suffix)
else:
- raise ConfigFormatError("%s: unexpected input: %r" %
- (self.location(), self.token[1]))
+ raise ConfigFormatError(
+ "%s: unexpected input: %r" % (self.location(), self.token[1])
+ )
return rv
def parseSequence(self, parent, suffix):
@raise ConfigFormatError: if a syntax error is found.
"""
rv = Sequence(parent)
- rv.setPath(makePath(object.__getattribute__(parent, 'path'), suffix))
+ rv.setPath(makePath(object.__getattribute__(parent, "path"), suffix))
self.match(LBRACK)
comment = self.comment
tt = self.token[0]
- while tt in [STRING, WORD, NUMBER, LCURLY, LBRACK, LPAREN, DOLLAR,
- TRUE, FALSE, NONE, BACKTICK]:
- suffix = '[%d]' % len(rv)
+ while tt in [
+ STRING,
+ WORD,
+ NUMBER,
+ LCURLY,
+ LBRACK,
+ LPAREN,
+ DOLLAR,
+ TRUE,
+ FALSE,
+ NONE,
+ BACKTICK,
+ ]:
+ suffix = "[%d]" % len(rv)
value = self.parseValue(parent, suffix)
rv.append(value, comment)
tt = self.token[0]
if self.token[0] == LCURLY:
self.match(LCURLY)
rv = Mapping(parent)
- rv.setPath(
- makePath(object.__getattribute__(parent, 'path'), suffix))
+ rv.setPath(makePath(object.__getattribute__(parent, "path"), suffix))
self.parseMappingBody(rv)
self.match(RCURLY)
else:
self.match(MINUS)
rv = -self.parseScalar()
else:
- raise ConfigFormatError("%s: unexpected input: %r" %
- (self.location(), self.token[1]))
+ raise ConfigFormatError(
+ "%s: unexpected input: %r" % (self.location(), self.token[1])
+ )
return rv
def parseReference(self, type):
self.match(LBRACK2)
tt, tv = self.token
if tt not in [NUMBER, STRING]:
- raise ConfigFormatError("%s: expected number or string, found %r" % (self.location(), tv))
+ raise ConfigFormatError(
+ "%s: expected number or string, found %r" % (self.location(), tv)
+ )
self.token = self.getToken()
tv = eval(tv)
self.match(RBRACK)
ref.addElement(LBRACK, tv)
+
def defaultMergeResolve(map1, map2, key):
"""\
A default resolver for merge conflicts.
rv = "mismatch"
return rv
+
def overwriteMergeResolve(map1, map2, key):
"""
An overwriting resolver for merge conflicts. Calls L{defaultMergeResolve},
rv = "overwrite"
return rv
+
def deepCopyMapping(inMapping):
res = Mapping()
for element in inMapping:
res[element] = inMapping[element]
return res
+
class ConfigMerger(object):
"""
This class is used for merging two configurations. If a key exists in the
@type map2: L{Mapping}.
"""
- overwrite_list = object.__getattribute__(seq2, 'data')
+ overwrite_list = object.__getattribute__(seq2, "data")
for overwrite_instruction in overwrite_list:
- object.__setattr__(overwrite_instruction, 'parent', map1)
+ object.__setattr__(overwrite_instruction, "parent", map1)
if "__condition__" in overwrite_instruction.keys():
overwrite_condition = overwrite_instruction["__condition__"]
if eval(overwrite_condition, globals(), map1):
if key == "__condition__":
continue
try:
- exec( 'map1.' + key + " = " + repr(overwrite_instruction[key]))
+ exec(
+ "map1." + key + " = " + repr(overwrite_instruction[key])
+ )
except:
- exec('map1.' + key + " = " + str(overwrite_instruction[key]))
+ exec(
+ "map1." + key + " = " + str(overwrite_instruction[key])
+ )
else:
for key in overwrite_instruction.keys():
try:
- exec('map1.' + key + " = " + repr(overwrite_instruction[key]))
+ exec("map1." + key + " = " + repr(overwrite_instruction[key]))
except:
- exec('map1.' + key + " = " + str(overwrite_instruction[key]))
+ exec("map1." + key + " = " + str(overwrite_instruction[key]))
def mergeMapping(self, map1, map2):
"""
global __resolveOverwrite__
for key in map2.keys():
if __resolveOverwrite__ and key == "__overwrite__":
- self.overwriteKeys(map1,map2[key])
+ self.overwriteKeys(map1, map2[key])
elif key not in keys:
map1[key] = map2[key]
- if isinstance(map1[key], Container) :
- object.__setattr__(map1[key], 'parent', map1)
+ if isinstance(map1[key], Container):
+ object.__setattr__(map1[key], "parent", map1)
else:
obj1 = map1[key]
obj2 = map2[key]
elif decision == "overwrite":
map1[key] = obj2
if isinstance(map1[key], Container):
- object.__setattr__(map1[key], 'parent', map1)
+ object.__setattr__(map1[key], "parent", map1)
elif decision == "mismatch":
self.handleMismatch(obj1, obj2)
else:
@param seq2: The sequence to merge.
@type seq2: L{Sequence}.
"""
- data1 = object.__getattribute__(seq1, 'data')
- data2 = object.__getattribute__(seq2, 'data')
+ data1 = object.__getattribute__(seq1, "data")
+ data2 = object.__getattribute__(seq2, "data")
for obj in data2:
data1.append(obj)
- comment1 = object.__getattribute__(seq1, 'comments')
- comment2 = object.__getattribute__(seq2, 'comments')
+ comment1 = object.__getattribute__(seq1, "comments")
+ comment2 = object.__getattribute__(seq2, "comments")
for obj in comment2:
comment1.append(obj)
"""
raise ConfigError("unable to merge %r with %r" % (obj1, obj2))
+
class ConfigList(list):
"""
This class implements an ordered list of configurations and allows you
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2018-20xx CEA/DEN
#
# global module variable
_OK_STATUS = "OK"
_KO_STATUS = "KO"
-_NA_STATUS = "NA" # not applicable
-_UNKNOWN_STATUS = "ND" # not defined
+_NA_STATUS = "NA" # not applicable
+_UNKNOWN_STATUS = "ND" # not defined
_KNOWNFAILURE_STATUS = "KF"
_TIMEOUT_STATUS = "TIMEOUT"
#####################################################
class ReturnCode(object):
- """
- assume simple return code for methods, with explanation as 'why'.
- Obviously why is 'why it is not OK',
- but also why is 'why it is OK' (if you want).
- Optionaly contains a return value as self.getValue()
-
- | Usage:
- | >> import returnCode as RCO
- |
- | >> aValue = doSomethingToReturn()
- | >> return RCO.ReturnCode("KO", "there is no problem here", aValue)
- | >> return RCO.ReturnCode("KO", "there is a problem here because etc", None)
- | >> return RCO.ReturnCode("TIMEOUT_STATUS", "too long here because etc")
- | >> return RCO.ReturnCode("NA", "not applicable here because etc")
- |
- | >> rc = doSomething()
- | >> print("short returnCode string", str(rc))
- | >> print("long returnCode string with value", repr(rc))
- |
- | >> rc1 = RCO.ReturnCode("OK", ...)
- | >> rc2 = RCO.ReturnCode("KO", ...)
- | >> rcFinal = rc1 + rc2
- | >> print("long returnCode string with value", repr(rcFinal)) # KO!
- |
- | >> rc = doSomething()
- | >> if rc.isOk(): doSomethingAsOK()
- | >> if not rc.isOk(): doSomethingAsKO()
- |
- | >> rc = doSomething().raiseIfKo() # raise Exception if KO
- | >> doSomethingWithValue(rc.getValue()) # here i am sure that is OK
- """
-
- # redunctant but useful class variables
- OK_STATUS = _OK_STATUS
- KO_STATUS = _KO_STATUS
- NA_STATUS = _NA_STATUS # not applicable
- UNKNOWN_STATUS = _UNKNOWN_STATUS # not defined
- KNOWNFAILURE_STATUS = _KNOWNFAILURE_STATUS
- TIMEOUT_STATUS = _TIMEOUT_STATUS
-
- # an integer for sys.exit(anInteger)
- # OKSYS and KOSYS seems equal on linux or windows
- OKSYS = 0 # OK
- KOSYS = 1 # KO
- NASYS = 2 # KO not applicable return code
- NDSYS = 3 # KO not defined return code
- KFSYS = 4 # KO known failure return code
- TOSYS = 5 # KO time out
-
- _TOSYS = {
- OK_STATUS: OKSYS,
- KO_STATUS: KOSYS,
- NA_STATUS: NASYS,
- UNKNOWN_STATUS: NDSYS,
- KNOWNFAILURE_STATUS: KFSYS,
- TIMEOUT_STATUS: TOSYS,
- }
- _DEFAULT_WHY = "No given explanation"
- _DEFAULT_VALUE = None
-
- def __init__(self, status=None, why=None, value=None):
- self._why = self._DEFAULT_WHY
- self._value = self._DEFAULT_VALUE
- if status is None:
- self._status = self.UNKNOWN_STATUS
- else:
- self.setStatus(status, why, value)
-
- def __repr__(self):
- """complete with value, 'ok, why, value' message"""
- res = '%s: %s --value: %s' % (self._status, self._why, PP.pformat(self._value))
- return res
-
- def __str__(self):
- """without value, only simple 'ok, why' message"""
- res = '%s: %s' % (self._status, self._why)
- return res
-
- def indent(self, text, amount=5, ch=' '):
- """indent multi lines message"""
- padding = amount * ch
- res = ''.join(padding + line for line in text.splitlines(True))
- return res[amount:]
-
- def __add__(self, rc2):
- """allows expression 'returnCode1 + returnCode2 + ...' """
- isOk = self.isOk() and rc2.isOk()
- newWhy = self._toList(self.getWhy()) + self._toList(rc2.getWhy())
- newValue = self._toList(self.getValue()) + self._toList(rc2.getValue())
- if isOk:
- return ReturnCode("OK", newWhy, newValue)
- else:
- return ReturnCode("KO", newWhy, newValue)
-
- def __radd__(self, other):
- # see http://www.marinamele.com/2014/04/modifying-add-method-of-python-class.html
- if other == 0:
- return self
- else:
- return self.__add__(other)
-
- def _toList(self, strOrList):
- """internal use"""
- if type(strOrList) is not list:
- return [strOrList]
- else:
- return strOrList
-
- def toSys(self):
- """return system return code as bash or bat"""
- try:
- return self._TOSYS[self._status]
- except:
- return self._TOSYS[self.NA_STATUS]
-
- def toXmlPassed(self):
- """return xml return code as '0' (passed) or '1' (not passed)"""
- if self.isOk():
- return "0"
- else:
- return "1"
-
- def getWhy(self):
- """return why as str or list if sum or some ReturnCode"""
- return self._why
-
- def setWhy(self, why):
- self._why = why
-
- def getValue(self):
- return self._value
-
- def setValue(self, value):
- """choice as not deep copying if mutables value"""
- # TODO deepcopy maybe for value, not yet
- self._value = value
-
- def setStatus(self, status, why=None, value=None):
- if why is None:
- aWhy = self._DEFAULT_WHY
- else:
- aWhy = why
-
- if status in self._TOSYS.keys():
- self._status = status
- self._why = aWhy
- else:
- self._status = self.NA_STATUS
- self._why = "Error status '%s' for '%s'" % (status, aWhy)
-
- if value is not None:
- # TODO deepcopy maybe for value, not yet
- self._value = value
- else:
- self._value = self._DEFAULT_VALUE
-
- def getStatus(self):
- return self._status
-
- def isOk(self):
"""
- return True if ok.
- inexisting method isKo(), use more explicit/readability 'if not res.isOk()'
- """
- return (self._status == self.OK_STATUS)
-
- def raiseIfKo(self):
- """
- raise an exception with message why if not ok, else return self.
- This trick is to write usage
-
+ assume simple return code for methods, with explanation as 'why'.
+ Obviously why is 'why it is not OK',
+ but also why is 'why it is OK' (if you want).
+ Optionaly contains a return value as self.getValue()
+
| Usage:
+ | >> import returnCode as RCO
+ |
+ | >> aValue = doSomethingToReturn()
+ | >> return RCO.ReturnCode("KO", "there is no problem here", aValue)
+ | >> return RCO.ReturnCode("KO", "there is a problem here because etc", None)
+ | >> return RCO.ReturnCode("TIMEOUT_STATUS", "too long here because etc")
+ | >> return RCO.ReturnCode("NA", "not applicable here because etc")
+ |
+ | >> rc = doSomething()
+ | >> print("short returnCode string", str(rc))
+ | >> print("long returnCode string with value", repr(rc))
+ |
+ | >> rc1 = RCO.ReturnCode("OK", ...)
+ | >> rc2 = RCO.ReturnCode("KO", ...)
+ | >> rcFinal = rc1 + rc2
+ | >> print("long returnCode string with value", repr(rcFinal)) # KO!
+ |
+ | >> rc = doSomething()
+ | >> if rc.isOk(): doSomethingAsOK()
+ | >> if not rc.isOk(): doSomethingAsKO()
+ |
| >> rc = doSomething().raiseIfKo() # raise Exception if KO
| >> doSomethingWithValue(rc.getValue()) # here i am sure that is OK
"""
- if self.isOk():
- return self
- else:
- raise Exception(self.getWhy())
+
+ # redunctant but useful class variables
+ OK_STATUS = _OK_STATUS
+ KO_STATUS = _KO_STATUS
+ NA_STATUS = _NA_STATUS # not applicable
+ UNKNOWN_STATUS = _UNKNOWN_STATUS # not defined
+ KNOWNFAILURE_STATUS = _KNOWNFAILURE_STATUS
+ TIMEOUT_STATUS = _TIMEOUT_STATUS
+
+ # an integer for sys.exit(anInteger)
+ # OKSYS and KOSYS seems equal on linux or windows
+ OKSYS = 0 # OK
+ KOSYS = 1 # KO
+ NASYS = 2 # KO not applicable return code
+ NDSYS = 3 # KO not defined return code
+ KFSYS = 4 # KO known failure return code
+ TOSYS = 5 # KO time out
+
+ _TOSYS = {
+ OK_STATUS: OKSYS,
+ KO_STATUS: KOSYS,
+ NA_STATUS: NASYS,
+ UNKNOWN_STATUS: NDSYS,
+ KNOWNFAILURE_STATUS: KFSYS,
+ TIMEOUT_STATUS: TOSYS,
+ }
+ _DEFAULT_WHY = "No given explanation"
+ _DEFAULT_VALUE = None
+
+ def __init__(self, status=None, why=None, value=None):
+ self._why = self._DEFAULT_WHY
+ self._value = self._DEFAULT_VALUE
+ if status is None:
+ self._status = self.UNKNOWN_STATUS
+ else:
+ self.setStatus(status, why, value)
+
+ def __repr__(self):
+ """complete with value, 'ok, why, value' message"""
+ res = "%s: %s --value: %s" % (self._status, self._why, PP.pformat(self._value))
+ return res
+
+ def __str__(self):
+ """without value, only simple 'ok, why' message"""
+ res = "%s: %s" % (self._status, self._why)
+ return res
+
+ def indent(self, text, amount=5, ch=" "):
+ """indent multi lines message"""
+ padding = amount * ch
+ res = "".join(padding + line for line in text.splitlines(True))
+ return res[amount:]
+
+ def __add__(self, rc2):
+ """allows expression 'returnCode1 + returnCode2 + ...'"""
+ isOk = self.isOk() and rc2.isOk()
+ newWhy = self._toList(self.getWhy()) + self._toList(rc2.getWhy())
+ newValue = self._toList(self.getValue()) + self._toList(rc2.getValue())
+ if isOk:
+ return ReturnCode("OK", newWhy, newValue)
+ else:
+ return ReturnCode("KO", newWhy, newValue)
+
+ def __radd__(self, other):
+ # see http://www.marinamele.com/2014/04/modifying-add-method-of-python-class.html
+ if other == 0:
+ return self
+ else:
+ return self.__add__(other)
+
+ def _toList(self, strOrList):
+ """internal use"""
+ if type(strOrList) is not list:
+ return [strOrList]
+ else:
+ return strOrList
+
+ def toSys(self):
+ """return system return code as bash or bat"""
+ try:
+ return self._TOSYS[self._status]
+ except:
+ return self._TOSYS[self.NA_STATUS]
+
+ def toXmlPassed(self):
+ """return xml return code as '0' (passed) or '1' (not passed)"""
+ if self.isOk():
+ return "0"
+ else:
+ return "1"
+
+ def getWhy(self):
+ """return why as str or list if sum or some ReturnCode"""
+ return self._why
+
+ def setWhy(self, why):
+ self._why = why
+
+ def getValue(self):
+ return self._value
+
+ def setValue(self, value):
+ """choice as not deep copying if mutables value"""
+ # TODO deepcopy maybe for value, not yet
+ self._value = value
+
+ def setStatus(self, status, why=None, value=None):
+ if why is None:
+ aWhy = self._DEFAULT_WHY
+ else:
+ aWhy = why
+
+ if status in self._TOSYS.keys():
+ self._status = status
+ self._why = aWhy
+ else:
+ self._status = self.NA_STATUS
+ self._why = "Error status '%s' for '%s'" % (status, aWhy)
+
+ if value is not None:
+ # TODO deepcopy maybe for value, not yet
+ self._value = value
+ else:
+ self._value = self._DEFAULT_VALUE
+
+ def getStatus(self):
+ return self._status
+
+ def isOk(self):
+ """
+ return True if ok.
+ inexisting method isKo(), use more explicit/readability 'if not res.isOk()'
+ """
+ return self._status == self.OK_STATUS
+
+ def raiseIfKo(self):
+ """
+ raise an exception with message why if not ok, else return self.
+ This trick is to write usage
+
+ | Usage:
+ | >> rc = doSomething().raiseIfKo() # raise Exception if KO
+ | >> doSomethingWithValue(rc.getValue()) # here i am sure that is OK
+ """
+ if self.isOk():
+ return self
+ else:
+ raise Exception(self.getWhy())
+
def ReturnCodeFromList(aListOfReturnCodes):
- """
- Create ReturnCode from list of ReturnCode
-
- convenience over "+" operand
- """
- res = "OK"
- whyes = []
- for rc in aListOfReturnCodes:
- if not rc.isOk():
- res = "KO"
- whyes.append(str(rc))
- reswhy = "\n ".join(whyes)
- return ReturnCode(res, "\n " + reswhy)
-
-
\ No newline at end of file
+ """
+ Create ReturnCode from list of ReturnCode
+
+ convenience over "+" operand
+ """
+ res = "OK"
+ whyes = []
+ for rc in aListOfReturnCodes:
+ if not rc.isOk():
+ res = "KO"
+ whyes.append(str(rc))
+ reswhy = "\n ".join(whyes)
+ return ReturnCode(res, "\n " + reswhy)
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2012 CEA/DEN
#
# This library is free software; you can redistribute it and/or
import traceback
import src
-import src.debug as DBG # Easy print stderr (for DEBUG only)
-import src.returnCode as RCO # Easy (ok/ko, why) return methods code
+import src.debug as DBG # Easy print stderr (for DEBUG only)
+import src.returnCode as RCO # Easy (ok/ko, why) return methods code
import src.utilsSat as UTS
# get path to salomeTools sources
-satdir = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
-srcdir = os.path.join(satdir, 'src')
-cmdsdir = os.path.join(satdir, 'commands')
+satdir = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+srcdir = os.path.join(satdir, "src")
+cmdsdir = os.path.join(satdir, "commands")
import commands.config as CONFIG
gettext.install("salomeTools", os.path.join(srcdir, "i18n"))
try:
- _LANG = os.environ["LANG"] # original locale
+ _LANG = os.environ["LANG"] # original locale
except:
- _LANG = "en_US.utf8" #default
+ _LANG = "en_US.utf8" # default
-# The possible hooks :
+# The possible hooks :
# pre is for hooks to be executed before commands
# post is for hooks to be executed after commands
C_PRE_HOOK = "pre"
# Define all possible option for salomeTools command : sat <option> <args>
parser = src.options.Options()
-parser.add_option('h', 'help', 'boolean', 'help',
- _("shows global help or help on a specific command."))
-parser.add_option('o', 'overwrite', 'list', "overwrite",
- _("overwrites a configuration parameters."))
-parser.add_option('g', 'debug', 'boolean', 'debug_mode',
- _("run salomeTools in debug mode."))
-parser.add_option('v', 'verbose', 'int', "output_verbose_level",
- _("change output verbose level (default is 3)."))
-parser.add_option('b', 'batch', 'boolean', "batch",
- _("batch mode (no question)."))
-parser.add_option('t', 'all_in_terminal', 'boolean', "all_in_terminal",
- _("all traces in the terminal (for example compilation logs)."))
-parser.add_option('l', 'logs_paths_in_file', 'string', "logs_paths_in_file",
- _("put the command results and paths to log files."))
+parser.add_option(
+ "h",
+ "help",
+ "boolean",
+ "help",
+ _("shows global help or help on a specific command."),
+)
+parser.add_option(
+ "o", "overwrite", "list", "overwrite", _("overwrites a configuration parameters.")
+)
+parser.add_option(
+ "g", "debug", "boolean", "debug_mode", _("run salomeTools in debug mode.")
+)
+parser.add_option(
+ "v",
+ "verbose",
+ "int",
+ "output_verbose_level",
+ _("change output verbose level (default is 3)."),
+)
+parser.add_option("b", "batch", "boolean", "batch", _("batch mode (no question)."))
+parser.add_option(
+ "t",
+ "all_in_terminal",
+ "boolean",
+ "all_in_terminal",
+ _("all traces in the terminal (for example compilation logs)."),
+)
+parser.add_option(
+ "l",
+ "logs_paths_in_file",
+ "string",
+ "logs_paths_in_file",
+ _("put the command results and paths to log files."),
+)
########################################################################
# utility methods
########################################################################
def find_command_list(dirPath):
- ''' Parse files in dirPath that end with .py : it gives commands list
-
+ """Parse files in dirPath that end with .py : it gives commands list
+
:param dirPath str: The directory path where to search the commands
- :return: cmd_list : the list containing the commands name
+ :return: cmd_list : the list containing the commands name
:rtype: list
- '''
+ """
cmd_list = []
for item in os.listdir(dirPath):
- if "__init__" in item: continue # skip __init__.py
- if item.endswith('.py'):
- cmd_list.append(item[:-len('.py')])
+ if "__init__" in item:
+ continue # skip __init__.py
+ if item.endswith(".py"):
+ cmd_list.append(item[: -len(".py")])
return cmd_list
# The list of valid salomeTools commands from cmdsdir
# ['config', 'compile', 'prepare', ...]
_COMMANDS_NAMES = find_command_list(cmdsdir)
-lCommand = find_command_list(cmdsdir) # obsolete
+lCommand = find_command_list(cmdsdir) # obsolete
+
def getCommandsList():
- """Gives commands list (as basename of files .py in directory commands"""
+ """Gives commands list (as basename of files .py in directory commands"""
return _COMMANDS_NAMES
+
def launchSat(command, logger=None):
"""
launch sat as subprocess.Popen
command as string ('sat --help' for example)
used for unittest, or else...
-
+
:return: RCO.ReturnCode with getValue as subprocess.Popen output
"""
if "sat" not in command.split()[0]:
- raise Exception(_("Not a valid command for launchSat: '%s'") % command)
- env = dict(os.environ) # copy
+ raise Exception(_("Not a valid command for launchSat: '%s'") % command)
+ env = dict(os.environ) # copy
# theorically useless, in user environ $PATH,
# on ne sait jamais
# https://docs.python.org/2/library/os.html
- # On some platforms, including FreeBSD and Mac OS X,
+ # On some platforms, including FreeBSD and Mac OS X,
# setting environ may cause memory leaks.
# see test/initializeTest.py
if satdir not in env["PATH"].split(":"):
- env["PATH"] = satdir + ":" + env["PATH"]
+ env["PATH"] = satdir + ":" + env["PATH"]
# TODO setLocale not 'fr' on subprocesses, why not?
# env["LANG"] == ''
- res = UTS.Popen(command, env=env, logger=logger) # logger or not.
+ res = UTS.Popen(command, env=env, logger=logger) # logger or not.
return res
+
def setNotLocale():
"""force english at any moment"""
- os.environ["LANG"] = ''
+ os.environ["LANG"] = ""
gettext.install("salomeTools", os.path.join(srcdir, "i18n"))
DBG.write("setNotLocale", os.environ["LANG"])
-
+
+
def setLocale():
"""
- reset initial locale at any moment
+ reset initial locale at any moment
'fr' or else (TODO) from initial environment var '$LANG'
'i18n' as 'internationalization'
"""
os.environ["LANG"] = _LANG
gettext.install("salomeTools", os.path.join(srcdir, "i18n"))
DBG.write("setLocale", os.environ["LANG"])
-
+
+
def getVersion():
"""get version number as string"""
return src.__version__
-
+
+
def assumeAsList(strOrList):
"""return a list as sys.argv if string"""
if type(strOrList) is list:
- return list(strOrList) # copy
+ return list(strOrList) # copy
else:
- res = strOrList.split(" ")
- return [r for r in res if r != ""] # supposed string to split for convenience
+ res = strOrList.split(" ")
+ return [r for r in res if r != ""] # supposed string to split for convenience
########################################################################
"""
The main class that stores all the commands of salomeTools
"""
+
def __init__(self, logger=None):
"""
Initialization
self.options = None # the options passed to salomeTools
self.datadir = None # default value will be <salomeTools root>/data
- def obsolete__init__(self, opt='', datadir=None):
- '''Initialization
+ def obsolete__init__(self, opt="", datadir=None):
+ """Initialization
:param opt str: The sat options
:param: datadir str : the directory that contain all the external
data (like software pyconf and software scripts)
- '''
+ """
# Read the salomeTools options (the list of possible options is
# at the beginning of this file)
argList = self.assumeAsList(opt)
if options.debug_mode:
DBG.push_debug(True)
self.arguments = opt
- self.options = options # the generic options passed to salomeTools
+ self.options = options # the generic options passed to salomeTools
self.remaindersArgs = remaindersArgs # the command and their options
- self.datadir = datadir # default value will be <salomeTools root>/data
+ self.datadir = datadir # default value will be <salomeTools root>/data
self._setCommands(cmdsdir)
DBG.write("Sat.options", self.options, self.options.debug_mode)
argList = self.assumeAsList(args)
# no arguments : print general help
if len(argList) == 0:
- self.mainLogger.info(get_help())
- return RCO.ReturnCode("OK", "no args as sat --help")
+ self.mainLogger.info(get_help())
+ return RCO.ReturnCode("OK", "no args as sat --help")
self.setInternals(opt=argList, datadir=None)
# print general help on -h
if self.options.help and len(self.remaindersArgs) == 0:
- self.mainLogger.info(get_help())
- return RCO.ReturnCode("OK", "help done")
+ self.mainLogger.info(get_help())
+ return RCO.ReturnCode("OK", "help done")
DBG.write("options", self.options)
DBG.write("remaindersArgs", self.remaindersArgs)
if len(self.remaindersArgs) == 0:
- return RCO.ReturnCode("KO", "Nothing to do")
+ return RCO.ReturnCode("KO", "Nothing to do")
# print command help on -h --help after name command
if "-h" in self.remaindersArgs or "--help" in self.remaindersArgs:
- self.mainLogger.info(self.get_help(self.remaindersArgs))
- return RCO.ReturnCode("OK", "sat --help command")
+ self.mainLogger.info(self.get_help(self.remaindersArgs))
+ return RCO.ReturnCode("OK", "sat --help command")
# print command help on -h and continue if something do do more
if self.options.help and len(self.remaindersArgs) >= 1:
- self.mainLogger.info(self.get_help(self.remaindersArgs))
+ self.mainLogger.info(self.get_help(self.remaindersArgs))
command = self.remaindersArgs[0]
# get dynamically the command function to call
# Run the command using the arguments
code = fun_command(self.remaindersArgs[1:])
- if code is None: code = 0 # what?! do not know why so respect history
+ if code is None:
+ code = 0 # what?! do not know why so respect history
# return salomeTools command with the right message
# code (0 if no errors, else 1)
if code == _KOSYS:
- return RCO.ReturnCode("KO", "problem on execute_cli 'sat %s'" % " ".join(argList))
+ return RCO.ReturnCode(
+ "KO", "problem on execute_cli 'sat %s'" % " ".join(argList)
+ )
else:
- return RCO.ReturnCode("OK", "execute_cli 'sat %s' done" % " ".join(argList))
+ return RCO.ReturnCode("OK", "execute_cli 'sat %s' done" % " ".join(argList))
- '''
+ """
# OBSOLETE... see file ../sat
# ###############################
# MAIN : terminal command usage #
if code is None: code = 0
sys.exit(code)
- '''
+ """
def __getattr__(self, name):
- '''
+ """
overwrite of __getattr__ function in order to display
a customized message in case of a wrong call
-
- :param name str: The name of the attribute
- '''
+
+ :param name str: The name of the attribute
+ """
if name in self.__dict__:
return self.__dict__[name]
else:
def assumeAsList(self, strOrList):
# DBG.write("Sat assumeAsList", strOrList, True)
return assumeAsList(strOrList)
-
+
def _setCommands(self, dirPath):
- '''set class attributes corresponding to all commands that are
+ """set class attributes corresponding to all commands that are
in the dirPath directory
-
- :param dirPath str: The directory path containing the commands
- '''
+
+ :param dirPath str: The directory path containing the commands
+ """
# loop on the commands name
for nameCmd in lCommand:
# Exception for the jobs command that requires the paramiko module
ff = tempfile.TemporaryFile()
sys.stderr = ff
import paramiko
+
sys.stderr = saveout
except:
sys.stderr = saveout
# load the module that has name nameCmd in dirPath
(file_, pathname, description) = imp.find_module(nameCmd, [dirPath])
module = imp.load_module(nameCmd, file_, pathname, description)
-
- def run_command(args='',
- options=None,
- batch = False,
- verbose = -1,
- logger_add_link = None):
- '''
+
+ def run_command(
+ args="", options=None, batch=False, verbose=-1, logger_add_link=None
+ ):
+ """
The function that will load the configuration (all pyconf)
and return the function run of the command corresponding to module
-
- :param args str: The arguments of the command
- '''
+
+ :param args str: The arguments of the command
+ """
# Make sure the internationalization is available
- gettext.install('salomeTools', os.path.join(satdir, 'src', 'i18n'))
-
+ gettext.install("salomeTools", os.path.join(satdir, "src", "i18n"))
+
# Get the arguments in a list and remove the empty elements
- if type(args) == type(''):
+ if type(args) == type(""):
# split by spaces without considering spaces in quotes
argv_0 = re.findall(r'(?:"[^"]*"|[^\s"])+', args)
else:
argv_0 = args
-
- if argv_0 != ['']:
- while "" in argv_0: argv_0.remove("")
-
- # Format the argv list in order to prevent strings
+
+ if argv_0 != [""]:
+ while "" in argv_0:
+ argv_0.remove("")
+
+ # Format the argv list in order to prevent strings
# that contain a blank to be separated
argv = []
elem_old = ""
else:
argv[-1] += " " + elem
elem_old = elem
-
+
# if it is provided by the command line, get the application
appliToLoad = None
- if argv not in [[''], []] and argv[0][0] != "-":
- appliToLoad = argv[0].rstrip('*')
+ if argv not in [[""], []] and argv[0][0] != "-":
+ appliToLoad = argv[0].rstrip("*")
argv = argv[1:]
-
+
# Check if the global options of salomeTools have to be changed
if options:
options_save = self.options
- self.options = options
+ self.options = options
- # read the configuration from all the pyconf files
+ # read the configuration from all the pyconf files
cfgManager = CONFIG.ConfigManager()
- self.cfg = cfgManager.get_config(datadir=self.datadir,
- application=appliToLoad,
- options=self.options,
- command=__nameCmd__)
-
+ self.cfg = cfgManager.get_config(
+ datadir=self.datadir,
+ application=appliToLoad,
+ options=self.options,
+ command=__nameCmd__,
+ )
+
# Set the verbose mode if called
if verbose > -1:
verbose_save = self.options.output_verbose_level
- self.options.__setattr__("output_verbose_level", verbose)
+ self.options.__setattr__("output_verbose_level", verbose)
# Set batch mode if called
if batch:
# set output level
if self.options.output_verbose_level is not None:
- self.cfg.USER.output_verbose_level = self.options.output_verbose_level
+ self.cfg.USER.output_verbose_level = (
+ self.options.output_verbose_level
+ )
if self.cfg.USER.output_verbose_level < 1:
self.cfg.USER.output_verbose_level = 0
- silent = (self.cfg.USER.output_verbose_level == 0)
+ silent = self.cfg.USER.output_verbose_level == 0
# create log file
micro_command = False
if logger_add_link:
micro_command = True
- logger_command = src.logger.Logger(self.cfg,
- silent_sysstd=silent,
- all_in_terminal=self.options.all_in_terminal,
- micro_command=micro_command)
-
+ logger_command = src.logger.Logger(
+ self.cfg,
+ silent_sysstd=silent,
+ all_in_terminal=self.options.all_in_terminal,
+ micro_command=micro_command,
+ )
+
# Check that the path given by the logs_paths_in_file option
# is a file path that can be written
if self.options.logs_paths_in_file and not micro_command:
try:
self.options.logs_paths_in_file = os.path.abspath(
- self.options.logs_paths_in_file)
+ self.options.logs_paths_in_file
+ )
dir_file = os.path.dirname(self.options.logs_paths_in_file)
if not os.path.exists(dir_file):
os.makedirs(dir_file)
file_test = open(self.options.logs_paths_in_file, "w")
file_test.close()
except Exception as e:
- msg = _("WARNING: the logs_paths_in_file option will "
- "not be taken into account.\nHere is the error:")
- logger_command.write("%s\n%s\n\n" % (
- src.printcolors.printcWarning(msg),
- str(e)))
+ msg = _(
+ "WARNING: the logs_paths_in_file option will "
+ "not be taken into account.\nHere is the error:"
+ )
+ logger_command.write(
+ "%s\n%s\n\n" % (src.printcolors.printcWarning(msg), str(e))
+ )
self.options.logs_paths_in_file = None
-
# do nothing more if help is True
if self.options.help:
- return 0
+ return 0
options_launched = ""
res = None
try:
- # Execute the hooks (if there is any)
+ # Execute the hooks (if there is any)
# and run method of the command
self.run_hook(__nameCmd__, C_PRE_HOOK, logger_command)
res = __module__.run(argv, self, logger_command)
self.run_hook(__nameCmd__, C_POST_HOOK, logger_command)
if res is None:
res = 0
-
+
except src.SatException as e:
# for sat exception do not display the stack, unless debug mode is set
logger_command.write("\n***** ", 1)
- logger_command.write(src.printcolors.printcError(
- "salomeTools ERROR: sat %s" % __nameCmd__), 1)
+ logger_command.write(
+ src.printcolors.printcError(
+ "salomeTools ERROR: sat %s" % __nameCmd__
+ ),
+ 1,
+ )
logger_command.write(" *****\n", 1)
print(e.message)
if self.options.debug_mode:
except Exception as e:
# here we print the stack in addition
logger_command.write("\n***** ", 1)
- logger_command.write(src.printcolors.printcError(
- "salomeTools ERROR: sat %s" % __nameCmd__), 1)
+ logger_command.write(
+ src.printcolors.printcError(
+ "salomeTools ERROR: sat %s" % __nameCmd__
+ ),
+ 1,
+ )
logger_command.write("\n" + DBG.format_exception("") + "\n", 1)
-
finally:
# set res if it is not set in the command
if res is None:
res = 1
-
+
# come back to the original global options
if options:
options_launched = get_text_from_options(self.options)
self.options = options_save
-
- # come back in the original batch mode if
+
+ # come back in the original batch mode if
# batch argument was called
if batch:
self.options.__setattr__("batch", batch_save)
- # come back in the original verbose mode if
- # verbose argument was called
+ # come back in the original verbose mode if
+ # verbose argument was called
if verbose > -1:
- self.options.__setattr__("output_verbose_level",
- verbose_save)
- # put final attributes in xml log file
+ self.options.__setattr__("output_verbose_level", verbose_save)
+ # put final attributes in xml log file
# (end time, total time, ...) and write it
- launchedCommand = ' '.join([self.cfg.VARS.salometoolsway +
- os.path.sep +
- 'sat',
- options_launched,
- __nameCmd__,
- ' '.join(argv_0)])
+ launchedCommand = " ".join(
+ [
+ self.cfg.VARS.salometoolsway + os.path.sep + "sat",
+ options_launched,
+ __nameCmd__,
+ " ".join(argv_0),
+ ]
+ )
# TODO may be no need as call escapeSequence xml
launchedCommand = launchedCommand.replace('"', "'")
-
- # Add a link to the parent command
+
+ # Add a link to the parent command
if logger_add_link is not None:
- logger_add_link.add_link(logger_command.logFileName,
- __nameCmd__,
- res,
- launchedCommand)
+ logger_add_link.add_link(
+ logger_command.logFileName,
+ __nameCmd__,
+ res,
+ launchedCommand,
+ )
logger_add_link.l_logFiles += logger_command.l_logFiles
-
+
# Put the final attributes corresponding to end time and
# Write the file to the hard drive
- logger_command.end_write(
- {"launchedCommand" : launchedCommand})
-
+ logger_command.end_write({"launchedCommand": launchedCommand})
+
if res != 0:
res = 1
-
- # print the log file path if
- # the maximum verbose mode is invoked
+
+ # print the log file path if
+ # the maximum verbose mode is invoked
if not micro_command:
- logger_command.write("\nPath to the xml log file :\n",
- 5)
- logger_command.write("%s\n\n" % src.printcolors.printcInfo(
- logger_command.logFilePath), 5)
+ logger_command.write("\nPath to the xml log file :\n", 5)
+ logger_command.write(
+ "%s\n\n"
+ % src.printcolors.printcInfo(logger_command.logFilePath),
+ 5,
+ )
# If the logs_paths_in_file was called, write the result
# and log files in the given file path
if i < len(logger_command.l_logFiles):
file_res.write("\n")
file_res.flush()
-
+
return res
- # Make sure that run_command will be redefined
+ # Make sure that run_command will be redefined
# at each iteration of the loop
globals_up = {}
globals_up.update(run_command.__globals__)
- globals_up.update({'__nameCmd__': nameCmd, '__module__' : module})
- func = types.FunctionType(run_command.__code__,
- globals_up,
- run_command.__name__,
- run_command.__defaults__,
- run_command.__closure__)
+ globals_up.update({"__nameCmd__": nameCmd, "__module__": module})
+ func = types.FunctionType(
+ run_command.__code__,
+ globals_up,
+ run_command.__name__,
+ run_command.__defaults__,
+ run_command.__closure__,
+ )
# set the attribute corresponding to the command
self.__setattr__(nameCmd, func)
def run_hook(self, cmd_name, hook_type, logger):
- '''Execute a hook file for a given command regarding the fact
+ """Execute a hook file for a given command regarding the fact
it is pre or post
-
+
:param cmd_name str: The the command on which execute the hook
:param hook_type str: pre or post
:param logger Logger: the logging instance to use for the prints
- '''
+ """
# The hooks must be defined in the application pyconf
# So, if there is no application, do not do anything
if not src.config_has_application(self.cfg):
# The hooks must be defined in the application pyconf in the
# APPLICATION section, hook : { command : 'script_path.py'}
- if "hook" not in self.cfg.APPLICATION \
- or cmd_name not in self.cfg.APPLICATION.hook:
+ if (
+ "hook" not in self.cfg.APPLICATION
+ or cmd_name not in self.cfg.APPLICATION.hook
+ ):
return
# Get the hook_script path and verify that it exists
hook_script_path = self.cfg.APPLICATION.hook[cmd_name]
if not os.path.exists(hook_script_path):
- raise src.SatException(_("Hook script not found: %s") %
- hook_script_path)
-
+ raise src.SatException(_("Hook script not found: %s") % hook_script_path)
+
# Try to execute the script, catch the exception if it fails
try:
# import the module (in the sense of python)
pymodule = imp.load_source(cmd_name, hook_script_path)
-
+
# format a message to be printed at hook execution
msg = src.printcolors.printcWarning(_("Run hook script"))
- msg = "%s: %s\n" % (msg,
- src.printcolors.printcInfo(hook_script_path))
-
- # run the function run_pre_hook if this function is called
+ msg = "%s: %s\n" % (msg, src.printcolors.printcInfo(hook_script_path))
+
+ # run the function run_pre_hook if this function is called
# before the command, run_post_hook if it is called after
if hook_type == C_PRE_HOOK and "run_pre_hook" in dir(pymodule):
logger.write(msg, 1)
raise src.SatException(msg)
def get_help(self, opt):
- '''Prints help for a command. Function called when "sat -h <command>"
-
+ """Prints help for a command. Function called when "sat -h <command>"
+
:param argv str: the options passed (to get the command name)
- '''
+ """
# if no command as argument (sat -h)
- if len(opt)==0:
+ if len(opt) == 0:
return get_help()
# get command name
command = opt[0]
# Check if this command exists
if not hasattr(self, command):
raise src.SatException(_("Command '%s' does not exist") % command)
-
+
# Print salomeTools version
msg = "\n" + get_version() + "\n\n"
-
+
# load the module
module = self.get_module(command)
# print the description of the command that is done in the command file
- if hasattr( module, "description" ) :
- msg += src.printcolors.printcHeader( _("Description:") )
- msg += '\n' + module.description() + '\n\n'
+ if hasattr(module, "description"):
+ msg += src.printcolors.printcHeader(_("Description:"))
+ msg += "\n" + module.description() + "\n\n"
# print the description of the command options
- if hasattr( module, "parser" ):
+ if hasattr(module, "parser"):
msg += module.parser.get_help()
msg += "\n -h, --help (boolean)\n shows help on command.\n"
return msg
def get_module(self, module):
- '''Loads a command. Function called only by print_help
-
+ """Loads a command. Function called only by print_help
+
:param module str: the command to load
- '''
+ """
# Check if this command exists
if not hasattr(self, module):
raise src.SatException(_("Command '%s' does not exist") % module)
module = imp.load_module(module, file_, pathname, description)
return module
+
##################################################################
def get_text_from_options(options):
text_options = ""
continue
if options.__getattr__(attr) != None:
option_contain = options.__getattr__(attr)
- if type(option_contain)==type([]):
+ if type(option_contain) == type([]):
option_contain = ",".join(option_contain)
- if type(option_contain)==type(True):
+ if type(option_contain) == type(True):
option_contain = ""
- text_options+= "--%s %s " % (attr, option_contain)
+ text_options += "--%s %s " % (attr, option_contain)
return text_options
-
+
def get_version():
- '''
+ """
get colorized salomeTools version (in src/internal_config/salomeTools.pyconf).
returns string
- '''
- # read the config
+ """
+ # read the config
cfgManager = CONFIG.ConfigManager()
cfg = cfgManager.get_config()
# print the key corresponding to salomeTools version
- msg = (src.printcolors.printcHeader( _("Version: ") ) + src.get_salometool_version(cfg))
+ msg = src.printcolors.printcHeader(_("Version: ")) + src.get_salometool_version(cfg)
return msg
def get_help():
- '''
+ """
get salomeTools general help.
returns string
- '''
+ """
msg = "\n" + get_version() + "\n\n"
- msg += src.printcolors.printcHeader( _("Usage: ") ) + \
- "sat [sat_options] <command> [application] [command_options]\n\n"
+ msg += (
+ src.printcolors.printcHeader(_("Usage: "))
+ + "sat [sat_options] <command> [application] [command_options]\n\n"
+ )
msg += parser.get_help() + "\n"
msg += "\n"
# Explain how to get the help for a specific command
- msg += src.printcolors.printcHeader(
- _("Get help for a specific command:")) + \
- "\n>> sat --help <command>\n"
+ msg += (
+ src.printcolors.printcHeader(_("Get help for a specific command:"))
+ + "\n>> sat --help <command>\n"
+ )
return msg
+
def write_exception(exc):
- '''write exception in case of error in a command
-
+ """write exception in case of error in a command
+
:param exc exception: the exception to print
- '''
+ """
sys.stderr.write("\n***** ")
sys.stderr.write(src.printcolors.printcError("salomeTools ERROR:"))
sys.stderr.write("\n" + str(exc) + "\n")
-
-
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2013 CEA/DEN
#
# This library is free software; you can redistribute it and/or
import string
+
class MyTemplate(string.Template):
- delimiter = '¤'
+ delimiter = "¤"
+
def substitute(template_file, subst_dic):
- template = open(template_file, 'r')
+ template = open(template_file, "r")
template = MyTemplate(template.read())
return template.safe_substitute(subst_dic)
-
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# ToolBox for test framework
"""
Exception class for test errors.
"""
+
def __init__(self, value):
self.value = value
def __str__(self):
return repr(self.value)
+
class SatNotApplicableError(Exception):
"""
Exception class for test errors.
"""
+
def __init__(self, value):
self.value = value
def __str__(self):
return repr(self.value)
+
def ERROR(message):
print("ERROR", message)
raise SatTestError(message)
-
+
+
def NOT_APPLICABLE(message):
print("NOT_APPLICABLE", message)
raise SatNotApplicableError(message)
+
def compFloat(f1, f2, tol=10e-10):
"""Compares 2 numbers with tolerance tol."""
diff = abs(f1 - f2)
comp = "KO"
return comp
+
def compFiles(f1, f2, tol=0):
"""Compares 2 files."""
assert os.path.exists(f1), "compFiles: file not found: %s" % f1
comp = "KO"
return comp
+
def mdump_med(med_file, dump_file, options):
"""Uses mdump to dump a med file."""
assert isinstance(options, list), "Bad options for mdump: %s" % options
assert len(options) == 3, "Bad options for mdump: %s" % options
cmd = "mdump %s %s" % (med_file, " ".join(options))
- #print(cmd)
+ # print(cmd)
with open(dump_file, "w") as df:
pdump = subprocess.Popen(cmd, shell=True, stdout=df)
st = pdump.wait()
return st
+
def compMED(file1, file2, tol=0, diff_flags=""):
"""Compares 2 med files by using mdump."""
# local utility method
def do_dump(med):
- dump = os.path.join(os.environ['TT_TMP_RESULT'], os.path.basename(med) + ".mdump")
+ dump = os.path.join(
+ os.environ["TT_TMP_RESULT"], os.path.basename(med) + ".mdump"
+ )
st = mdump_med(med, dump, ["1", "NODALE", "FULL_INTERLACE"])
if st != 0 or not os.path.exists(dump):
raise Exception("Error mpdump %s" % med)
with open(dump, "w") as dumpfile:
for line in lines:
try:
- line.index('Universal name of mesh')
+ line.index("Universal name of mesh")
continue
except:
- dumpfile.write(line.replace(med, 'filename'))
+ dumpfile.write(line.replace(med, "filename"))
return dump
-
# begin method
- print(""">>>> compMED
+ print(
+ """>>>> compMED
file1: %s
file2: %s
-""" % (file1, file2))
+"""
+ % (file1, file2)
+ )
if not os.path.exists(file1):
print("compMED: file not found: '%s'" % file1)
return os.path.join(self.tmp_dir, name)
def writeInFiles(self, pylog):
- pylog.write('inFiles=%s\n' % str(self.inFiles))
-
+ pylog.write("inFiles=%s\n" % str(self.inFiles))
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2013 CEA/DEN
#
# This library is free software; you can redistribute it and/or
try:
execfile
except:
+
def execfile(somefile, global_vars, local_vars):
with open(somefile) as f:
- code = compile(f.read(), somefile, 'exec')
+ code = compile(f.read(), somefile, "exec")
exec(code, global_vars, local_vars)
+
import os
import sys
import datetime
from . import fork
import src
-from src.versionMinorMajorPatch import MinorMajorPatch as MMP
+from src.versionMinorMajorPatch import MinorMajorPatch as MMP
# directories not considered as test grids
-C_IGNORE_GRIDS = ['.git', '.svn', 'RESSOURCES']
+C_IGNORE_GRIDS = [".git", ".svn", "RESSOURCES"]
DEFAULT_TIMEOUT = 150
directory = os.getenv("TEMP")
else:
# for Linux: use /tmp/logs/{user} folder
- directory = os.path.join( '/tmp', 'logs', os.getenv("USER", "unknown"))
+ directory = os.path.join("/tmp", "logs", os.getenv("USER", "unknown"))
return directory
+
class Test:
- def __init__(self,
- config,
- logger,
- tmp_working_dir,
- testbase="",
- grids=None,
- sessions=None,
- launcher="",
- show_desktop=True):
+ def __init__(
+ self,
+ config,
+ logger,
+ tmp_working_dir,
+ testbase="",
+ grids=None,
+ sessions=None,
+ launcher="",
+ show_desktop=True,
+ ):
self.grids = grids
self.config = config
self.logger = logger
def _copy_dir(self, source, target):
if self.config.VARS.python >= "2.6":
- shutil.copytree(source, target,
- symlinks=True,
- ignore=shutil.ignore_patterns('.git*','.svn*'))
+ shutil.copytree(
+ source,
+ target,
+ symlinks=True,
+ ignore=shutil.ignore_patterns(".git*", ".svn*"),
+ )
else:
- shutil.copytree(source, target,
- symlinks=True)
+ shutil.copytree(source, target, symlinks=True)
def prepare_testbase_from_dir(self, testbase_name, testbase_dir):
- self.logger.write(_("get test base from dir: %s\n") % \
- src.printcolors.printcLabel(testbase_dir), 3)
+ self.logger.write(
+ _("get test base from dir: %s\n")
+ % src.printcolors.printcLabel(testbase_dir),
+ 3,
+ )
if not os.access(testbase_dir, os.X_OK):
- raise src.SatException(_("testbase %(name)s (%(dir)s) does not "
- "exist ...\n") % { 'name': testbase_name,
- 'dir': testbase_dir })
+ raise src.SatException(
+ _("testbase %(name)s (%(dir)s) does not " "exist ...\n")
+ % {"name": testbase_name, "dir": testbase_dir}
+ )
- self._copy_dir(testbase_dir,
- os.path.join(self.tmp_working_dir, 'BASES', testbase_name))
+ self._copy_dir(
+ testbase_dir, os.path.join(self.tmp_working_dir, "BASES", testbase_name)
+ )
- def prepare_testbase_from_git(self,
- testbase_name,
- testbase_base,
- testbase_tag):
+ def prepare_testbase_from_git(self, testbase_name, testbase_base, testbase_tag):
self.logger.write(
- _("get test base '%(testbase)s' with '%(tag)s' tag from git\n") % {
- "testbase" : src.printcolors.printcLabel(testbase_name),
- "tag" : src.printcolors.printcLabel(testbase_tag)},
- 3)
+ _("get test base '%(testbase)s' with '%(tag)s' tag from git\n")
+ % {
+ "testbase": src.printcolors.printcLabel(testbase_name),
+ "tag": src.printcolors.printcLabel(testbase_tag),
+ },
+ 3,
+ )
try:
- def set_signal(): # pragma: no cover
+
+ def set_signal(): # pragma: no cover
"""see http://bugs.python.org/issue1652"""
import signal
+
signal.signal(signal.SIGPIPE, signal.SIG_DFL)
cmd = "git clone --depth 1 %(base)s %(dir)s"
cmd += " && cd %(dir)s"
- if testbase_tag=='master':
+ if testbase_tag == "master":
cmd += " && git fetch origin %(branch)s"
else:
cmd += " && git fetch origin %(branch)s:%(branch)s"
cmd += " && git checkout %(branch)s"
- cmd = cmd % { 'branch': testbase_tag,
- 'base': testbase_base,
- 'dir': testbase_name }
+ cmd = cmd % {
+ "branch": testbase_tag,
+ "base": testbase_base,
+ "dir": testbase_name,
+ }
self.logger.write("> %s\n" % cmd, 5)
if src.architecture.is_windows():
# preexec_fn not supported on windows platform
- res = subprocess.call(cmd,
- cwd=os.path.join(self.tmp_working_dir, 'BASES'),
- shell=True,
- stdout=self.logger.logTxtFile,
- stderr=subprocess.PIPE)
+ res = subprocess.call(
+ cmd,
+ cwd=os.path.join(self.tmp_working_dir, "BASES"),
+ shell=True,
+ stdout=self.logger.logTxtFile,
+ stderr=subprocess.PIPE,
+ )
else:
- res = subprocess.call(cmd,
- cwd=os.path.join(self.tmp_working_dir, 'BASES'),
- shell=True,
- preexec_fn=set_signal,
- stdout=self.logger.logTxtFile,
- stderr=subprocess.PIPE)
+ res = subprocess.call(
+ cmd,
+ cwd=os.path.join(self.tmp_working_dir, "BASES"),
+ shell=True,
+ preexec_fn=set_signal,
+ stdout=self.logger.logTxtFile,
+ stderr=subprocess.PIPE,
+ )
if res != 0:
- raise src.SatException(_("Error: unable to get test base "
- "'%(name)s' from git '%(repo)s'.") % \
- { 'name': testbase_name,
- 'repo': testbase_base })
+ raise src.SatException(
+ _(
+ "Error: unable to get test base "
+ "'%(name)s' from git '%(repo)s'."
+ )
+ % {"name": testbase_name, "repo": testbase_base}
+ )
except OSError:
self.logger.error(_("git is not installed. exiting...\n"))
sys.exit(0)
def prepare_testbase_from_svn(self, user, testbase_name, testbase_base):
- self.logger.write(_("get test base '%s' from svn\n") % \
- src.printcolors.printcLabel(testbase_name), 3)
+ self.logger.write(
+ _("get test base '%s' from svn\n")
+ % src.printcolors.printcLabel(testbase_name),
+ 3,
+ )
try:
- def set_signal(): # pragma: no cover
+
+ def set_signal(): # pragma: no cover
"""see http://bugs.python.org/issue1652"""
import signal
+
signal.signal(signal.SIGPIPE, signal.SIG_DFL)
cmd = "svn checkout --username %(user)s %(base)s %(dir)s"
- cmd = cmd % { 'user': user,
- 'base': testbase_base,
- 'dir': testbase_name }
+ cmd = cmd % {"user": user, "base": testbase_base, "dir": testbase_name}
# Get the application environment
self.logger.write(_("Set the application environment\n"), 5)
- env_appli = src.environment.SalomeEnviron(self.config,
- src.environment.Environ(dict(os.environ)))
+ env_appli = src.environment.SalomeEnviron(
+ self.config, src.environment.Environ(dict(os.environ))
+ )
env_appli.set_application_env(self.logger)
self.logger.write("> %s\n" % cmd, 5)
if src.architecture.is_windows():
# preexec_fn not supported on windows platform
- res = subprocess.call(cmd,
- cwd=os.path.join(self.tmp_working_dir, 'BASES'),
- shell=True,
- stdout=self.logger.logTxtFile,
- stderr=subprocess.PIPE)
+ res = subprocess.call(
+ cmd,
+ cwd=os.path.join(self.tmp_working_dir, "BASES"),
+ shell=True,
+ stdout=self.logger.logTxtFile,
+ stderr=subprocess.PIPE,
+ )
else:
- res = subprocess.call(cmd,
- cwd=os.path.join(self.tmp_working_dir, 'BASES'),
- shell=True,
- preexec_fn=set_signal,
- stdout=self.logger.logTxtFile,
- stderr=subprocess.PIPE,
- env=env_appli.environ.environ,)
+ res = subprocess.call(
+ cmd,
+ cwd=os.path.join(self.tmp_working_dir, "BASES"),
+ shell=True,
+ preexec_fn=set_signal,
+ stdout=self.logger.logTxtFile,
+ stderr=subprocess.PIPE,
+ env=env_appli.environ.environ,
+ )
if res != 0:
- raise src.SatException(_("Error: unable to get test base '%(nam"
- "e)s' from svn '%(repo)s'.") % \
- { 'name': testbase_name,
- 'repo': testbase_base })
+ raise src.SatException(
+ _(
+ "Error: unable to get test base '%(nam"
+ "e)s' from svn '%(repo)s'."
+ )
+ % {"name": testbase_name, "repo": testbase_base}
+ )
except OSError:
self.logger.error(_("svn is not installed. exiting...\n"))
##
# Configure tests base.
def prepare_testbase(self, test_base_name):
- src.printcolors.print_value(self.logger,
- _("Test base"),
- test_base_name,
- 3)
+ src.printcolors.print_value(self.logger, _("Test base"), test_base_name, 3)
self.logger.write("\n", 3, False)
# search for the test base
return 0
if not test_base_info:
- message = (_("########## ERROR: test base '%s' not found\n") %
- test_base_name)
+ message = _("########## ERROR: test base '%s' not found\n") % test_base_name
self.logger.write("%s\n" % src.printcolors.printcError(message))
return 1
if test_base_info.get_sources == "dir":
- self.prepare_testbase_from_dir(test_base_name,
- test_base_info.info.dir)
+ self.prepare_testbase_from_dir(test_base_name, test_base_info.info.dir)
elif test_base_info.get_sources == "git":
- self.prepare_testbase_from_git(test_base_name,
- test_base_info.info.base,
- self.config.APPLICATION.test_base.tag)
+ self.prepare_testbase_from_git(
+ test_base_name,
+ test_base_info.info.base,
+ self.config.APPLICATION.test_base.tag,
+ )
elif test_base_info.get_sources == "svn":
- svn_user = src.get_cfg_param(test_base_info.info,
- "svn_user",
- self.config.USER.svn_user)
- self.prepare_testbase_from_svn(svn_user,
- test_base_name,
- test_base_info.info.base)
+ svn_user = src.get_cfg_param(
+ test_base_info.info, "svn_user", self.config.USER.svn_user
+ )
+ self.prepare_testbase_from_svn(
+ svn_user, test_base_name, test_base_info.info.base
+ )
else:
- raise src.SatException(_("unknown source type '%(type)s' for test b"
- "ase '%(base)s' ...\n") % {
- 'type': test_base_info.get_sources,
- 'base': test_base_name })
+ raise src.SatException(
+ _("unknown source type '%(type)s' for test b" "ase '%(base)s' ...\n")
+ % {"type": test_base_info.get_sources, "base": test_base_name}
+ )
self.currentTestBase = test_base_name
if not error.fixed:
# the error is fixed
self.known_errors.fix_error(error)
- #import testerror
- #testerror.write_test_failures(
+ # import testerror
+ # testerror.write_test_failures(
# self.config.TOOLS.testerror.file_path,
# self.known_errors.errors)
- return status, [ error.date,
- error.expected,
- error.comment,
- error.fixed ]
+ return status, [error.date, error.expected, error.comment, error.fixed]
if error.fixed:
self.known_errors.unfix_error(error)
- #import testerror
- #testerror.write_test_failures(self.config.TOOLS.testerror.file_path,
+ # import testerror
+ # testerror.write_test_failures(self.config.TOOLS.testerror.file_path,
# self.known_errors.errors)
delta = self.known_errors.get_expecting_days(error)
- kfres = [ error.date, error.expected, error.comment, error.fixed ]
+ kfres = [error.date, error.expected, error.comment, error.fixed]
if delta < 0:
return src.KO_STATUS, kfres
return src.KNOWNFAILURE_STATUS, kfres
def read_results(self, listTest, has_timed_out):
results = {}
for test in listTest:
- resfile = os.path.join(self.currentDir,
- self.currentgrid,
- self.currentsession,
- test[:-3] + ".result.py")
+ resfile = os.path.join(
+ self.currentDir,
+ self.currentgrid,
+ self.currentsession,
+ test[:-3] + ".result.py",
+ )
# check if <test>.result.py file exists
if not os.path.exists(resfile):
else:
gdic, ldic = {}, {}
if verbose:
- print("test script: '%s':\n'%s'\n" % (resfile, open(resfile, 'r').read()))
+ print(
+ "test script: '%s':\n'%s'\n"
+ % (resfile, open(resfile, "r").read())
+ )
try:
- execfile(resfile, gdic, ldic)
-
- status = src.TIMEOUT_STATUS
- if not has_timed_out:
- status = src.KO_STATUS
-
- if 'status' in ldic:
- status = ldic['status']
-
- expected = []
- if status == src.KO_STATUS or status == src.OK_STATUS:
- status, expected = self.search_known_errors(status,
- self.currentgrid,
- self.currentsession,
- test)
-
- callback = ""
- if 'callback' in ldic:
- callback = ldic['callback']
- elif status == src.KO_STATUS:
- callback = "CRASH"
- if verbose:
- print("--- CRASH ldic\n%s" % PP.pformat(ldic)) # cvw TODO
- print("--- CRASH gdic\n%s" % PP.pformat(gdic))
- pass
-
- exec_time = -1
- if 'time' in ldic:
- try:
- exec_time = float(ldic['time'])
- except:
- pass
-
- results[test] = [status, exec_time, callback, expected]
+ execfile(resfile, gdic, ldic)
+
+ status = src.TIMEOUT_STATUS
+ if not has_timed_out:
+ status = src.KO_STATUS
+
+ if "status" in ldic:
+ status = ldic["status"]
+
+ expected = []
+ if status == src.KO_STATUS or status == src.OK_STATUS:
+ status, expected = self.search_known_errors(
+ status, self.currentgrid, self.currentsession, test
+ )
+
+ callback = ""
+ if "callback" in ldic:
+ callback = ldic["callback"]
+ elif status == src.KO_STATUS:
+ callback = "CRASH"
+ if verbose:
+ print("--- CRASH ldic\n%s" % PP.pformat(ldic)) # cvw TODO
+ print("--- CRASH gdic\n%s" % PP.pformat(gdic))
+ pass
+
+ exec_time = -1
+ if "time" in ldic:
+ try:
+ exec_time = float(ldic["time"])
+ except:
+ pass
+
+ results[test] = [status, exec_time, callback, expected]
except:
- results[test] = ["?", -1, "", []]
- # results[test] = [src.O_STATUS, -1, open(resfile, 'r').read(), []]
+ results[test] = ["?", -1, "", []]
+ # results[test] = [src.O_STATUS, -1, open(resfile, 'r').read(), []]
# check if <test>.py file exists
- testfile = os.path.join(self.currentDir,
- self.currentgrid,
- self.currentsession,
- test)
+ testfile = os.path.join(
+ self.currentDir, self.currentgrid, self.currentsession, test
+ )
if not os.path.exists(testfile):
- results[test].append('')
+ results[test].append("")
else:
text = open(testfile, "r").read()
results[test].append(text)
# check if <test>.out.py file exists
- outfile = os.path.join(self.currentDir,
- self.currentgrid,
- self.currentsession,
- test[:-3] + ".out.py")
+ outfile = os.path.join(
+ self.currentDir,
+ self.currentgrid,
+ self.currentsession,
+ test[:-3] + ".out.py",
+ )
if not os.path.exists(outfile):
- results[test].append('')
+ results[test].append("")
else:
text = open(outfile, "r").read()
results[test].append(text)
def generate_script(self, listTest, script_path, ignoreList):
# open template file
tFile = os.path.join(self.config.VARS.srcDir, "test", "scriptTemplate.py")
- with open(tFile, 'r') as f:
- template = string.Template(f.read())
+ with open(tFile, "r") as f:
+ template = string.Template(f.read())
# create substitution dictionary
d = dict()
- d['resourcesWay'] = os.path.join(self.currentDir, 'RESSOURCES')
- d['tmpDir'] = os.path.join(self.tmp_working_dir, 'WORK')
- d['toolsWay'] = os.path.join(self.config.VARS.srcDir, "test")
- d['sessionDir'] = os.path.join(self.currentDir, self.currentgrid, self.currentsession)
- d['resultFile'] = os.path.join(self.tmp_working_dir, 'WORK', 'exec_result')
- d['listTest'] = listTest
- d['sessionName'] = self.currentsession
- d['ignore'] = ignoreList
+ d["resourcesWay"] = os.path.join(self.currentDir, "RESSOURCES")
+ d["tmpDir"] = os.path.join(self.tmp_working_dir, "WORK")
+ d["toolsWay"] = os.path.join(self.config.VARS.srcDir, "test")
+ d["sessionDir"] = os.path.join(
+ self.currentDir, self.currentgrid, self.currentsession
+ )
+ d["resultFile"] = os.path.join(self.tmp_working_dir, "WORK", "exec_result")
+ d["listTest"] = listTest
+ d["sessionName"] = self.currentsession
+ d["ignore"] = ignoreList
# create script with template
contents = template.safe_substitute(d)
- if verbose: print("generate_script '%s':\n%s" % (script_path, contents)) # cvw TODO
- with open(script_path, 'w') as f:
- f.write(contents)
-
+ if verbose:
+ print("generate_script '%s':\n%s" % (script_path, contents)) # cvw TODO
+ with open(script_path, "w") as f:
+ f.write(contents)
# Find the getTmpDir function that gives access to *_pidict file directory.
# (the *_pidict file exists when SALOME is launched)
def get_tmp_dir(self):
# Rare case where there is no KERNEL in grid list
# (for example MED_STANDALONE)
- if ('APPLICATION' in self.config
- and 'KERNEL' not in self.config.APPLICATION.products
- and 'KERNEL_ROOT_DIR' not in os.environ):
+ if (
+ "APPLICATION" in self.config
+ and "KERNEL" not in self.config.APPLICATION.products
+ and "KERNEL_ROOT_DIR" not in os.environ
+ ):
return getTmpDirDEFAULT
# Case where "sat test" is launched in an existing SALOME environment
- if 'KERNEL_ROOT_DIR' in os.environ:
- root_dir = os.environ['KERNEL_ROOT_DIR']
+ if "KERNEL_ROOT_DIR" in os.environ:
+ root_dir = os.environ["KERNEL_ROOT_DIR"]
- if ('APPLICATION' in self.config and
- 'KERNEL' in self.config.APPLICATION.products):
+ if (
+ "APPLICATION" in self.config
+ and "KERNEL" in self.config.APPLICATION.products
+ ):
root_dir = src.product.get_product_config(self.config, "KERNEL").install_dir
# Case where there the appli option is called (with path to launcher)
# and the new one
launcherName = os.path.basename(self.launcher)
launcherDir = os.path.dirname(self.launcher)
- if launcherName == 'runAppli':
+ if launcherName == "runAppli":
# Old application
- cmd = """
+ cmd = (
+ """
for i in %s/env.d/*.sh;
do source ${i};
done
echo $KERNEL_ROOT_DIR
-""" % launcherDir
+"""
+ % launcherDir
+ )
else:
# New application
- cmd = """
+ cmd = (
+ """
echo -e 'import os\nprint(os.environ[\"KERNEL_ROOT_DIR\"])' > tmpscript.py
%s shell tmpscript.py
-""" % self.launcher
+"""
+ % self.launcher
+ )
if src.architecture.is_windows():
- subproc_res = subprocess.Popen(cmd,
- stdout=subprocess.PIPE,
- shell=True).communicate()
+ subproc_res = subprocess.Popen(
+ cmd, stdout=subprocess.PIPE, shell=True
+ ).communicate()
pass
else:
- subproc_res = subprocess.Popen(cmd,
- stdout=subprocess.PIPE,
- shell=True,
- executable='/bin/bash').communicate()
+ subproc_res = subprocess.Popen(
+ cmd, stdout=subprocess.PIPE, shell=True, executable="/bin/bash"
+ ).communicate()
pass
root_dir = subproc_res[0].split()[-1]
# import grid salome_utils from KERNEL that gives
# the right getTmpDir function
- root_dir = root_dir.decode('utf-8')
- aPath = [os.path.join(root_dir, 'bin', 'salome')]
+ root_dir = root_dir.decode("utf-8")
+ aPath = [os.path.join(root_dir, "bin", "salome")]
sal_uts = "salome_utils"
try:
- (file_, pathname, description) = imp.find_module(sal_uts, aPath )
+ (file_, pathname, description) = imp.find_module(sal_uts, aPath)
except Exception:
msg = "inexisting %s.py in %s" % (sal_uts, aPath)
raise Exception(msg)
if file_:
file_.close()
-
def get_test_timeout(self, test_name, default_value):
- if ("timeout" in self.settings and
- test_name in self.settings["timeout"]):
+ if "timeout" in self.settings and test_name in self.settings["timeout"]:
return self.settings["timeout"][test_name]
return default_value
# and the new one
launcherName = os.path.basename(self.launcher)
launcherDir = os.path.dirname(self.launcher)
- if os.path.basename(launcherDir) == 'APPLI':
+ if os.path.basename(launcherDir) == "APPLI":
# Old application
binSalome = self.launcher
- binPython = ("for i in " +
- launcherDir +
- "/env.d/*.sh; do source ${i}; done ; python")
- killSalome = ("for i in " +
- launcherDir +
- "/env.d/*.sh; do source ${i}; done ; killSalome.py'")
+ binPython = (
+ "for i in "
+ + launcherDir
+ + "/env.d/*.sh; do source ${i}; done ; python"
+ )
+ killSalome = (
+ "for i in "
+ + launcherDir
+ + "/env.d/*.sh; do source ${i}; done ; killSalome.py'"
+ )
return binSalome, binPython, killSalome
else:
# New application
binSalome = self.launcher
- binPython = self.launcher + ' shell'
- killSalome = self.launcher + ' killall'
+ binPython = self.launcher + " shell"
+ killSalome = self.launcher + " killall"
return binSalome, binPython, killSalome
# SALOME version detection and APPLI repository detection
VersionSalome = src.get_salome_version(self.config)
- appdir = 'APPLI'
+ appdir = "APPLI"
if "APPLI" in self.config and "application_name" in self.config.APPLI:
appdir = self.config.APPLI.application_name
# Case where SALOME has NOT the launcher that uses the SalomeContext API
- if VersionSalome < MMP([7,3,0]):
- binSalome = os.path.join(self.config.APPLICATION.workdir,
- appdir,
- "runAppli")
+ if VersionSalome < MMP([7, 3, 0]):
+ binSalome = os.path.join(
+ self.config.APPLICATION.workdir, appdir, "runAppli"
+ )
binPython = "python"
killSalome = "killSalome.py"
src.environment.load_environment(self.config, False, self.logger)
# Case where SALOME has the launcher that uses the SalomeContext API
else:
launcher_name = src.get_launcher_name(self.config)
- binSalome = os.path.join(self.config.APPLICATION.workdir,
- launcher_name)
+ binSalome = os.path.join(self.config.APPLICATION.workdir, launcher_name)
- binPython = binSalome + ' shell'
- killSalome = binSalome + ' killall'
+ binPython = binSalome + " shell"
+ killSalome = binSalome + " killall"
return binSalome, binPython, killSalome
return binSalome, binPython, killSalome
-
##
# Runs tests of a session (using a single instance of Salome).
def run_tests(self, listTest, ignoreList):
- out_path = os.path.join(self.currentDir,
- self.currentgrid,
- self.currentsession)
- if verbose: print("run_tests '%s'\nlistTest: %s\nignoreList: %s" %
- (self.currentDir, PP.pformat(listTest), PP.pformat(ignoreList))) # cvw TODO
+ out_path = os.path.join(self.currentDir, self.currentgrid, self.currentsession)
+ if verbose:
+ print(
+ "run_tests '%s'\nlistTest: %s\nignoreList: %s"
+ % (self.currentDir, PP.pformat(listTest), PP.pformat(ignoreList))
+ ) # cvw TODO
sessionname = "%s/%s" % (self.currentgrid, self.currentsession)
- time_out = self.get_test_timeout(sessionname,
- DEFAULT_TIMEOUT)
+ time_out = self.get_test_timeout(sessionname, DEFAULT_TIMEOUT)
time_out_salome = DEFAULT_TIMEOUT
# generate wrapper script
- script_path = os.path.join(out_path, 'wrapperScript.py')
+ script_path = os.path.join(out_path, "wrapperScript.py")
self.generate_script(listTest, script_path, ignoreList)
tmpDir = self.get_tmp_dir()
binSalome, binPython, killSalome = self.generate_launching_commands()
- if "run_with_grids" in self.settings and \
- sessionname in self.settings["run_with_grids"]:
- binSalome = (binSalome + " -m %s" % self.settings["run_with_grids"][sessionname])
+ if (
+ "run_with_grids" in self.settings
+ and sessionname in self.settings["run_with_grids"]
+ ):
+ binSalome = (
+ binSalome + " -m %s" % self.settings["run_with_grids"][sessionname]
+ )
logWay = os.path.join(self.tmp_working_dir, "WORK", "log_cxx")
if self.currentsession.startswith("NOGUI_"):
# runSalome -t (bash)
status, elapsed = fork.batch(
- binSalome,
- self.logger,
- os.path.join(self.tmp_working_dir, "WORK"),
- [ "-t", "--shutdown-server=1", script_path ],
- delai=time_out,
- log=logWay)
+ binSalome,
+ self.logger,
+ os.path.join(self.tmp_working_dir, "WORK"),
+ ["-t", "--shutdown-server=1", script_path],
+ delai=time_out,
+ log=logWay,
+ )
elif self.currentsession.startswith("PY_"):
# python script.py
status, elapsed = fork.batch(
- binPython,
- self.logger,
- os.path.join(self.tmp_working_dir, "WORK"),
- [script_path],
- delai=time_out,
- log=logWay)
+ binPython,
+ self.logger,
+ os.path.join(self.tmp_working_dir, "WORK"),
+ [script_path],
+ delai=time_out,
+ log=logWay,
+ )
else:
opt = "-z 0"
- if self.show_desktop: opt = "--show-desktop=0"
+ if self.show_desktop:
+ opt = "--show-desktop=0"
status, elapsed = fork.batch_salome(
- binSalome,
- self.logger,
- os.path.join( self.tmp_working_dir, "WORK"),
- [ opt, "--shutdown-server=1", script_path ],
- getTmpDir=tmpDir,
- fin=killSalome,
- delai=time_out,
- log=logWay,
- delaiapp=time_out_salome)
+ binSalome,
+ self.logger,
+ os.path.join(self.tmp_working_dir, "WORK"),
+ [opt, "--shutdown-server=1", script_path],
+ getTmpDir=tmpDir,
+ fin=killSalome,
+ delai=time_out,
+ log=logWay,
+ delaiapp=time_out_salome,
+ )
self.logger.write("status = %s, elapsed = %s\n" % (status, elapsed), 5)
script_info.time = script_results[sr][1]
if script_info.res == src.TIMEOUT_STATUS:
script_info.time = time_out
- if script_info.time < 1e-3: script_info.time = 0
+ if script_info.time < 1e-3:
+ script_info.time = 0
callback = script_results[sr][2]
if script_info.res != src.OK_STATUS and len(callback) > 0:
script_info.out = script_results[sr][5]
# add it to the list of results
- test_info.script.append(script_info, '')
+ test_info.script.append(script_info, "")
# display the results
if script_info.time > 0:
sp = "." * (35 - len(script_info.name))
self.logger.write(self.write_test_margin(3), 3)
- self.logger.write("script %s %s %s %s\n" % (
- src.printcolors.printcLabel(script_info.name),
- sp,
- src.printcolors.printc(script_info.res),
- exectime), 3, False)
+ self.logger.write(
+ "script %s %s %s %s\n"
+ % (
+ src.printcolors.printcLabel(script_info.name),
+ sp,
+ src.printcolors.printc(script_info.res),
+ exectime,
+ ),
+ 3,
+ False,
+ )
if script_info and len(callback) > 0:
- self.logger.write("Exception in %s\n%s\n" % \
- (script_info.name,
- src.printcolors.printcWarning(callback)), 2, False)
+ self.logger.write(
+ "Exception in %s\n%s\n"
+ % (script_info.name, src.printcolors.printcWarning(callback)),
+ 2,
+ False,
+ )
if script_info.res == src.OK_STATUS:
self.nb_succeed += 1
elif script_info.res == "?":
self.nb_not_run += 1
-
- self.config.TESTS.append(test_info, '')
+ self.config.TESTS.append(test_info, "")
##
# Runs all tests of a session.
def run_session_tests(self):
self.logger.write(self.write_test_margin(2), 3)
- self.logger.write("Session = %s\n" % src.printcolors.printcLabel(
- self.currentsession), 3, False)
+ self.logger.write(
+ "Session = %s\n" % src.printcolors.printcLabel(self.currentsession),
+ 3,
+ False,
+ )
# prepare list of tests to run
- tests = os.listdir(os.path.join(self.currentDir,
- self.currentgrid,
- self.currentsession))
+ tests = os.listdir(
+ os.path.join(self.currentDir, self.currentgrid, self.currentsession)
+ )
# avoid result files of previous tests, if presents
# tests = filter(lambda l: l.endswith(".py"), tests)
- tests = [t for t in tests if t.endswith(".py") \
- and not ( t.endswith(".out.py") or \
- t.endswith(".result.py") or \
- t.endswith("wrapperScript.py") \
- ) ]
+ tests = [
+ t
+ for t in tests
+ if t.endswith(".py")
+ and not (
+ t.endswith(".out.py")
+ or t.endswith(".result.py")
+ or t.endswith("wrapperScript.py")
+ )
+ ]
tests = sorted(tests, key=str.lower)
# build list of known failures
ignoreDict = {}
for k in self.ignore_tests.keys():
if k.startswith(cat):
- ignoreDict[k[len(cat):]] = self.ignore_tests[k]
+ ignoreDict[k[len(cat) :]] = self.ignore_tests[k]
self.run_tests(tests, ignoreDict)
# Runs all tests of a grid.
def run_grid_tests(self):
self.logger.write(self.write_test_margin(1), 3)
- self.logger.write("grid = %s\n" % src.printcolors.printcLabel(
- self.currentgrid), 3, False)
+ self.logger.write(
+ "grid = %s\n" % src.printcolors.printcLabel(self.currentgrid), 3, False
+ )
grid_path = os.path.join(self.currentDir, self.currentgrid)
sessions = []
if self.sessions is not None:
- sessions = self.sessions # user choice
+ sessions = self.sessions # user choice
else:
# use all scripts in grid
- sessions = filter(lambda l: l not in C_IGNORE_GRIDS,
- os.listdir(grid_path))
- sessions = filter(lambda l: os.path.isdir(os.path.join(grid_path,
- l)), sessions)
+ sessions = filter(lambda l: l not in C_IGNORE_GRIDS, os.listdir(grid_path))
+ sessions = filter(
+ lambda l: os.path.isdir(os.path.join(grid_path, l)), sessions
+ )
sessions = sorted(sessions, key=str.lower)
existingSessions = self.getSubDirectories(grid_path)
Session '%s' not found
Existing sessions are:
%s
-""" % (session_, PP.pformat(sorted(existingSessions)))
+""" % (
+ session_,
+ PP.pformat(sorted(existingSessions)),
+ )
self.logger.write(src.printcolors.printcWarning(msg), 3, False)
else:
self.currentsession = session_
excluding '.git' etc as beginning with '.'
"""
res = os.listdir(aDir)
- res = [d for d in res if os.path.isdir(os.path.join(aDir, d)) and d[0] != '.']
+ res = [d for d in res if os.path.isdir(os.path.join(aDir, d)) and d[0] != "."]
# print("getSubDirectories %s are:\n%s" % (aDir, PP.pformat(res)))
return res
# Runs test testbase.
def run_testbase_tests(self):
res_dir = os.path.join(self.currentDir, "RESSOURCES")
- os.environ['PYTHONPATH'] = (res_dir +
- os.pathsep +
- os.environ['PYTHONPATH'])
- os.environ['TT_BASE_RESSOURCES'] = res_dir
- src.printcolors.print_value(self.logger,
- "TT_BASE_RESSOURCES",
- res_dir,
- 4)
+ os.environ["PYTHONPATH"] = res_dir + os.pathsep + os.environ["PYTHONPATH"]
+ os.environ["TT_BASE_RESSOURCES"] = res_dir
+ src.printcolors.print_value(self.logger, "TT_BASE_RESSOURCES", res_dir, 4)
self.logger.write("\n", 4, False)
self.logger.write(self.write_test_margin(0), 3)
testbase_label = "Test base = %s\n" % src.printcolors.printcLabel(
- self.currentTestBase)
+ self.currentTestBase
+ )
self.logger.write(testbase_label, 3, False)
- self.logger.write("-" * len(src.printcolors.cleancolor(testbase_label)),
- 3)
+ self.logger.write("-" * len(src.printcolors.cleancolor(testbase_label)), 3)
self.logger.write("\n", 3, False)
# load settings
gdic, ldic = {}, {}
execfile(settings_file, gdic, ldic)
self.logger.write("Load test settings '%s'\n" % settings_file, 5)
- self.settings = ldic['settings_dic']
- self.ignore_tests = ldic['known_failures_list']
+ self.settings = ldic["settings_dic"]
+ self.ignore_tests = ldic["known_failures_list"]
if isinstance(self.ignore_tests, list):
self.ignore_tests = {}
- self.logger.write(src.printcolors.printcWarning(
- "known_failures_list must be a dictionary (not a list)") + "\n", 1, False)
+ self.logger.write(
+ src.printcolors.printcWarning(
+ "known_failures_list must be a dictionary (not a list)"
+ )
+ + "\n",
+ 1,
+ False,
+ )
else:
self.ignore_tests = {}
self.settings.clear()
# read known failures pyconf
if "testerror" in self.config.LOCAL:
- #import testerror
- #self.known_errors = testerror.read_test_failures(
+ # import testerror
+ # self.known_errors = testerror.read_test_failures(
# self.config.TOOLS.testerror.file_path,
# do_error=False)
pass
self.known_errors = None
if self.grids is not None:
- grids = self.grids # given by user
+ grids = self.grids # given by user
else:
# select all the grids (i.e. directories) in the directory
- grids = filter(lambda l: l not in C_IGNORE_GRIDS,
- os.listdir(self.currentDir))
- grids = filter(lambda l: os.path.isdir(
- os.path.join(self.currentDir, l)),
- grids)
+ grids = filter(
+ lambda l: l not in C_IGNORE_GRIDS, os.listdir(self.currentDir)
+ )
+ grids = filter(
+ lambda l: os.path.isdir(os.path.join(self.currentDir, l)), grids
+ )
grids = sorted(grids, key=str.lower)
existingGrids = self.getSubDirectories(self.currentDir)
Grid '%s' does not exist
Existing grids are:
%s
-""" % (grid, PP.pformat(sorted(existingGrids)))
+""" % (
+ grid,
+ PP.pformat(sorted(existingGrids)),
+ )
self.logger.write(src.printcolors.printcWarning(msg), 3, False)
else:
self.currentgrid = grid
self.run_grid_tests()
def run_script(self, script_name):
- if ('APPLICATION' in self.config and
- script_name in self.config.APPLICATION):
+ if "APPLICATION" in self.config and script_name in self.config.APPLICATION:
script = self.config.APPLICATION[script_name]
if len(script) == 0:
return
self.logger.write("\n", 2, False)
if not os.path.exists(script):
- self.logger.write(src.printcolors.printcWarning("WARNING: scrip"
- "t not found: %s" % script) + "\n", 2)
+ self.logger.write(
+ src.printcolors.printcWarning(
+ "WARNING: scrip" "t not found: %s" % script
+ )
+ + "\n",
+ 2,
+ )
else:
- self.logger.write(src.printcolors.printcHeader("----------- sta"
- "rt %s" % script_name) + "\n", 2)
+ self.logger.write(
+ src.printcolors.printcHeader(
+ "----------- sta" "rt %s" % script_name
+ )
+ + "\n",
+ 2,
+ )
self.logger.write("Run script: %s\n" % script, 2)
subprocess.Popen(script, shell=True).wait()
- self.logger.write(src.printcolors.printcHeader("----------- end"
- " %s" % script_name) + "\n", 2)
+ self.logger.write(
+ src.printcolors.printcHeader("----------- end" " %s" % script_name)
+ + "\n",
+ 2,
+ )
def run_all_tests(self):
initTime = datetime.datetime.now()
- self.run_script('test_setup')
+ self.run_script("test_setup")
self.logger.write("\n", 2, False)
- self.logger.write(src.printcolors.printcHeader(
- _("=== STARTING TESTS")) + "\n", 2)
+ self.logger.write(
+ src.printcolors.printcHeader(_("=== STARTING TESTS")) + "\n", 2
+ )
self.logger.write("\n", 2, False)
- self.currentDir = os.path.join(self.tmp_working_dir,
- 'BASES',
- self.currentTestBase)
+ self.currentDir = os.path.join(
+ self.tmp_working_dir, "BASES", self.currentTestBase
+ )
self.run_testbase_tests()
# calculate total execution time
totalTime -= datetime.timedelta(microseconds=totalTime.microseconds)
self.logger.write("\n", 2, False)
self.logger.write(src.printcolors.printcHeader(_("=== END TESTS")), 2)
- self.logger.write(" %s\n" % src.printcolors.printcInfo(str(totalTime)),
- 2,
- False)
+ self.logger.write(
+ " %s\n" % src.printcolors.printcInfo(str(totalTime)), 2, False
+ )
#
# Start the tests
#
- self.run_script('test_cleanup')
+ self.run_script("test_cleanup")
self.logger.write("\n", 2, False)
# evaluate results
- res_out = _("Tests Results: %(succeed)d / %(total)d\n") % \
- { 'succeed': self.nb_succeed, 'total': self.nb_run }
+ res_out = _("Tests Results: %(succeed)d / %(total)d\n") % {
+ "succeed": self.nb_succeed,
+ "total": self.nb_run,
+ }
if self.nb_succeed == self.nb_run:
res_out = src.printcolors.printcSuccess(res_out)
else:
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2018 CEA/DEN
#
import subprocess as SP
import src.returnCode as RCO
-import src.debug as DBG # Easy print stderr (for DEBUG only)
+import src.debug as DBG # Easy print stderr (for DEBUG only)
##############################################################################
# subprocess utilities, with logger functionnalities (trace etc.)
##############################################################################
-
-def Popen(command, shell=True, cwd=None, env=None, stdout=SP.PIPE, stderr=SP.PIPE, logger=None):
- """
- make subprocess.Popen(cmd), with
- call logger.trace and logger.error if problem as returncode != 0
- """
- if True: #try:
- proc = SP.Popen(command, shell=shell, cwd=cwd, env=env, stdout=stdout, stderr=SP.STDOUT)
- res_out, res_err = proc.communicate() # res_err = None as stderr=SP.STDOUT
- rc = proc.returncode
-
- DBG.write("Popen logger returncode", (rc, res_out))
-
- if rc == 0:
- if logger is not None:
- logger.trace("<OK> launch command rc=%s cwd=%s:\n%s" % (rc, cwd, command))
- logger.trace("<OK> result command stdout&stderr:\n%s" % res_out)
- return RCO.ReturnCode("OK", "Popen command done", value=res_out)
- else:
- if logger is not None:
- logger.warning("<KO> launch command rc=%s cwd=%s:\n%s" % (rc, cwd, command))
- logger.warning("<KO> result command stdout&stderr:\n%s" % res_out)
- return RCO.ReturnCode("KO", "Popen command problem", value=res_out)
- else: #except Exception as e:
- logger.error("<KO> launch command cwd=%s:\n%s" % (cwd, command))
- logger.error("launch command exception:\n%s" % e)
- return RCO.ReturnCode("KO", "Popen command problem")
+
+
+def Popen(
+ command, shell=True, cwd=None, env=None, stdout=SP.PIPE, stderr=SP.PIPE, logger=None
+):
+ """
+ make subprocess.Popen(cmd), with
+ call logger.trace and logger.error if problem as returncode != 0
+ """
+ if True: # try:
+ proc = SP.Popen(
+ command, shell=shell, cwd=cwd, env=env, stdout=stdout, stderr=SP.STDOUT
+ )
+ res_out, res_err = proc.communicate() # res_err = None as stderr=SP.STDOUT
+ rc = proc.returncode
+
+ DBG.write("Popen logger returncode", (rc, res_out))
+
+ if rc == 0:
+ if logger is not None:
+ logger.trace(
+ "<OK> launch command rc=%s cwd=%s:\n%s" % (rc, cwd, command)
+ )
+ logger.trace("<OK> result command stdout&stderr:\n%s" % res_out)
+ return RCO.ReturnCode("OK", "Popen command done", value=res_out)
+ else:
+ if logger is not None:
+ logger.warning(
+ "<KO> launch command rc=%s cwd=%s:\n%s" % (rc, cwd, command)
+ )
+ logger.warning("<KO> result command stdout&stderr:\n%s" % res_out)
+ return RCO.ReturnCode("KO", "Popen command problem", value=res_out)
+ else: # except Exception as e:
+ logger.error("<KO> launch command cwd=%s:\n%s" % (cwd, command))
+ logger.error("launch command exception:\n%s" % e)
+ return RCO.ReturnCode("KO", "Popen command problem")
def sleep(sec):
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2018 CEA/DEN
#
import os
import sys
-verbose = False # True
+verbose = False # True
#############################################
def only_numbers(aStr):
- """
- Remove non numericals characters from string,
+ """
+ Remove non numericals characters from string,
+
+ :param aStr: string to work
+ :return: None if no number presence
+ """
+ res = "".join([nb for nb in aStr if nb in "0123456789"])
+ if res == "":
+ return None
+ else:
+ return res
- :param aStr: string to work
- :return: None if no number presence
- """
- res = ''.join([nb for nb in aStr if nb in '0123456789'])
- if res == "":
- return None
- else:
- return res
#############################################
def remove_startswith(aStr, startsToCheck):
- """
- remove starting strings, if begining of aStr correspond
- order of list startsToCheck matter
- do the stuff only for the first correspondence in startsToCheck
- """
- for s in startsToCheck:
- if aStr.startswith(s):
- return aStr[len(s):]
- return aStr
+ """
+ remove starting strings, if begining of aStr correspond
+ order of list startsToCheck matter
+ do the stuff only for the first correspondence in startsToCheck
+ """
+ for s in startsToCheck:
+ if aStr.startswith(s):
+ return aStr[len(s) :]
+ return aStr
+
#############################################
def toList_majorMinorPatch(aStr, verbose=False):
- """
- Returns list of integer as [major, minor, patch] from a string,
+ """
+ Returns list of integer as [major, minor, patch] from a string,
+
+ | accepts '1.2.3' '1_2_3' 'version_1.2.3' 'version1.2.3' 'v1.2.3',
+ | completion '123' means '123.0.0', '1.2' means '1.2.0'
+ | lower or upper
+ | raise exception if problem
+ """
+ if verbose:
+ print("toList_majorMinorPatch('%s')" % aStr)
+ res = aStr.replace(" ", "")
+ res = res.lower()
+ res = remove_startswith(res, "version_ version v".split())
+ res = res.replace(".", "_").split("_")
+ if len(res) > 3:
+ msg = "Not a major_minor_patch correct syntax: '%s'" % aStr
+ raise Exception(msg)
+ if len(res) == 0:
+ msg = "An empty string is not a major_minor_patch syntax"
+ raise Exception(msg)
+
+ # complete MINOR.PATCH if not existing
+ if len(res) == 1:
+ res.append("0")
+ if len(res) == 2:
+ res.append("0")
+
+ try:
+ ii = int(res[0])
+ except:
+ msg = "major in major_minor_patch is not integer: '%s'" % aStr
+ raise Exception(msg)
+ if ii < 0:
+ msg = "major in major_minor_patch is negative integer: '%s'" % aStr
+ raise Exception(msg)
+
+ try:
+ ii = int(res[1])
+ except:
+ msg = "minor in major_minor_patch is not integer: '%s'" % aStr
+ raise Exception(msg)
+ if ii < 0:
+ msg = "minor in major_minor_patch is negative integer: '%s'" % aStr
+ raise Exception(msg)
+
+ try:
+ ii = int(res[2])
+ except:
+ msg = "patch in major_minor_patch is not integer: '%s'" % aStr
+ raise Exception(msg)
+ if ii < 0:
+ msg = "patch in major_minor_patch is negative integer: '%s'" % aStr
+ raise Exception(msg)
+
+ return [int(i) for i in res]
- | accepts '1.2.3' '1_2_3' 'version_1.2.3' 'version1.2.3' 'v1.2.3',
- | completion '123' means '123.0.0', '1.2' means '1.2.0'
- | lower or upper
- | raise exception if problem
- """
- if verbose: print("toList_majorMinorPatch('%s')" % aStr)
- res = aStr.replace(" ", "")
- res = res.lower()
- res = remove_startswith(res, "version_ version v".split())
- res = res.replace(".", "_").split("_")
- if len(res) > 3:
- msg = "Not a major_minor_patch correct syntax: '%s'" % aStr
- raise Exception(msg)
- if len(res) == 0:
- msg = "An empty string is not a major_minor_patch syntax"
- raise Exception(msg)
-
- # complete MINOR.PATCH if not existing
- if len(res) == 1:
- res.append("0")
- if len(res) == 2:
- res.append("0")
-
- try:
- ii = int(res[0])
- except:
- msg = "major in major_minor_patch is not integer: '%s'" % aStr
- raise Exception(msg)
- if ii < 0:
- msg = "major in major_minor_patch is negative integer: '%s'" % aStr
- raise Exception(msg)
-
- try:
- ii = int(res[1])
- except:
- msg = "minor in major_minor_patch is not integer: '%s'" % aStr
- raise Exception(msg)
- if ii < 0:
- msg = "minor in major_minor_patch is negative integer: '%s'" % aStr
- raise Exception(msg)
-
- try:
- ii = int(res[2])
- except:
- msg = "patch in major_minor_patch is not integer: '%s'" % aStr
- raise Exception(msg)
- if ii < 0:
- msg = "patch in major_minor_patch is negative integer: '%s'" % aStr
- raise Exception(msg)
-
- return [int(i) for i in res]
#############################################
def toCompactStr_majorMinorPatch(version):
- """
- OBSOLETE method
- parameter version is list of integer as [major, minor, patch]
-
- | returns "789" for [7, 8, 9]
- | warning:
- | minor, pach have to be integer less than 10
- | raise exception for [7, 10, 11]
- | (which returns "71011" as ambigous 710.1.1 for example)
- """
- # forbidden use from nov. 2023 and SALOME 9.10.0
- raise Exception("obsolete toCompactStr_majorMinorPatch method: forbiden use of compact representation of '%s', fix problem in caller" % version)
+ """
+ OBSOLETE method
+ parameter version is list of integer as [major, minor, patch]
+
+ | returns "789" for [7, 8, 9]
+ | warning:
+ | minor, pach have to be integer less than 10
+ | raise exception for [7, 10, 11]
+ | (which returns "71011" as ambigous 710.1.1 for example)
+ """
+ # forbidden use from nov. 2023 and SALOME 9.10.0
+ raise Exception(
+ "obsolete toCompactStr_majorMinorPatch method: forbiden use of compact representation of '%s', fix problem in caller"
+ % version
+ )
#############################################
def getRange_majorMinorPatch(aStr, verbose=False):
- """
- extract from aStr a version range, defined as
- '*_from_aMinVersionTag_to_aMaxVersionTag' or
- '*version_aMinVersionTag_to_aMaxVersionTag'.
+ """
+ extract from aStr a version range, defined as
+ '*_from_aMinVersionTag_to_aMaxVersionTag' or
+ '*version_aMinVersionTag_to_aMaxVersionTag'.
+
+ where aMinVersionTag and aMaxVersionTag are compatible with MinorMajorPatch class syntaxes
+ '1.2.3' or '1_2_3' etc.
+ if not found '_from_' or 'version_' first then aMinVersionTag is '0.0.0'
+
+ :param aStr: string to work
+ :return: list [min, max], where min, max are MinorMajorPatch instances.
+ else None if not found
+ """
+ tmp1 = aStr.lower().split("_to_")
+
+ if len(tmp1) < 2:
+ return None # no '_to_'
+ if len(tmp1) > 2:
+ msg = "more than one '_to_' is incorrect for version range: '%s'" % aStr
+ raise Exception(msg)
+ aMax = tmp1[1]
+
+ # accept older syntax as 'version_1_0_0_to_2_0_0', (as '_from_1_0_0_to_2_0_0')
+ if "version_" in tmp1[0] and "_from_" not in tmp1[0]:
+ aStr_with_from = aStr.lower().replace("version_", "_from_", 1)
+ else:
+ aStr_with_from = aStr.lower()
- where aMinVersionTag and aMaxVersionTag are compatible with MinorMajorPatch class syntaxes
- '1.2.3' or '1_2_3' etc.
- if not found '_from_' or 'version_' first then aMinVersionTag is '0.0.0'
+ # print("aStr_with_from '%s' -> '%s'" % (aStr, aStr_with_from))
- :param aStr: string to work
- :return: list [min, max], where min, max are MinorMajorPatch instances.
- else None if not found
- """
- tmp1 = aStr.lower().split("_to_")
-
- if len(tmp1) < 2:
- return None # no '_to_'
- if len(tmp1) > 2:
- msg = "more than one '_to_' is incorrect for version range: '%s'" % aStr
- raise Exception(msg)
- aMax = tmp1[1]
-
- # accept older syntax as 'version_1_0_0_to_2_0_0', (as '_from_1_0_0_to_2_0_0')
- if "version_" in tmp1[0] and "_from_" not in tmp1[0]:
- aStr_with_from = aStr.lower().replace("version_", "_from_", 1)
- else:
- aStr_with_from = aStr.lower()
-
- # print("aStr_with_from '%s' -> '%s'" % (aStr, aStr_with_from))
-
- tmp0 = aStr_with_from.split("_from_")
- tmp1 = aStr_with_from.split("_to_")
-
- if len(tmp0) > 2:
- msg = "more than one '_from_' is incorrect for version range: '%s'" % aStr
- raise Exception(msg)
-
- tmp2 = tmp1[0].split("_from_")
-
- if len(tmp2) == 2:
- aMin = tmp2[1]
- else:
- aMin ="0.0.0"
-
- if verbose:
- msg = "version min '%s' and version max '%s' in version range: '%s'" % (aMin, aMax, aStr)
- print(msg)
-
- try:
- rMin = MinorMajorPatch(aMin)
- rMax = MinorMajorPatch(aMax)
- except:
- msg = "problem version range in '%s'" % aStr
- raise Exception(msg)
- """if verbose:
+ tmp0 = aStr_with_from.split("_from_")
+ tmp1 = aStr_with_from.split("_to_")
+
+ if len(tmp0) > 2:
+ msg = "more than one '_from_' is incorrect for version range: '%s'" % aStr
+ raise Exception(msg)
+
+ tmp2 = tmp1[0].split("_from_")
+
+ if len(tmp2) == 2:
+ aMin = tmp2[1]
+ else:
+ aMin = "0.0.0"
+
+ if verbose:
+ msg = "version min '%s' and version max '%s' in version range: '%s'" % (
+ aMin,
+ aMax,
+ aStr,
+ )
+ print(msg)
+
+ try:
+ rMin = MinorMajorPatch(aMin)
+ rMax = MinorMajorPatch(aMax)
+ except:
+ msg = "problem version range in '%s'" % aStr
+ raise Exception(msg)
+ """if verbose:
print("WARNING: problem version range in '%s'" % aStr)
return None"""
- if rMin > rMax:
- msg = "version min '%s' > version max '%s' in version range: '%s'" % (rMin, rMax, aStr)
- raise Exception(msg)
+ if rMin > rMax:
+ msg = "version min '%s' > version max '%s' in version range: '%s'" % (
+ rMin,
+ rMax,
+ aStr,
+ )
+ raise Exception(msg)
+
+ return [rMin, rMax]
- return [rMin, rMax]
#############################################
class MinorMajorPatch(object):
- """\
+ """\
class to define a version as MAJOR.MINOR.PATCH
| Given a version number MAJOR.MINOR.PATCH separator "_" or "."
| PATCH version when you make backwards-compatible bug fixes.
"""
- def __init__(self, version):
- if type(version) == list:
- aStr = '_'.join([str(i) for i in version])
- v = toList_majorMinorPatch(aStr)
- else:
- v = toList_majorMinorPatch(version)
- self.major = v[0]
- self.minor = v[1]
- self.patch = v[2]
-
- def __repr__(self, sep="_"):
- """example is 'version_1_2_3' """
- res = "version_%i%s%i%s%i" % (self.major, sep, self.minor, sep, self.patch)
- return res
-
- def __str__(self, sep="."):
- """example is '1.2.3' """
- res = "%i%s%i%s%i" % (self.major, sep, self.minor, sep, self.patch)
- return res
-
- def strSalome(self):
- """example is '1_2_3' """
- return self.__str__(sep="_")
-
- def strClassic(self):
- """example is '1.2.3' """
- return self.__str__(sep=".")
-
- def strCompact(self):
- """example is '123' from '1.2.3' """
- # forbidden use from nov. 2023 and SALOME 9.10.0
- raise Exception("obsolete strCompact method: forbiden use of compact representation of '%s', fix problem in caller" % str(self))
- # return toCompactStr_majorMinorPatch(self.toList())
-
- def toList(self):
- """example is list of integer [1, 2, 3] from '1.2.3' """
- return [self.major, self.minor, self.patch]
-
- def __lt__(self, other):
- res = (self.toList() < other.toList())
- return res
-
- def __le__(self, other):
- res = (self.toList() <= other.toList())
- return res
-
- def __gt__(self, other):
- res = (self.toList() > other.toList())
- return res
-
- def __ge__(self, other):
- res = (self.toList() >= other.toList())
- return res
-
- def __eq__(self, other):
- res = (self.toList() == other.toList())
- return res
-
- def __ne__(self, other):
- res = (self.toList() != other.toList())
- return res
+ def __init__(self, version):
+ if type(version) == list:
+ aStr = "_".join([str(i) for i in version])
+ v = toList_majorMinorPatch(aStr)
+ else:
+ v = toList_majorMinorPatch(version)
+ self.major = v[0]
+ self.minor = v[1]
+ self.patch = v[2]
+
+ def __repr__(self, sep="_"):
+ """example is 'version_1_2_3'"""
+ res = "version_%i%s%i%s%i" % (self.major, sep, self.minor, sep, self.patch)
+ return res
+
+ def __str__(self, sep="."):
+ """example is '1.2.3'"""
+ res = "%i%s%i%s%i" % (self.major, sep, self.minor, sep, self.patch)
+ return res
+
+ def strSalome(self):
+ """example is '1_2_3'"""
+ return self.__str__(sep="_")
+
+ def strClassic(self):
+ """example is '1.2.3'"""
+ return self.__str__(sep=".")
+
+ def strCompact(self):
+ """example is '123' from '1.2.3'"""
+ # forbidden use from nov. 2023 and SALOME 9.10.0
+ raise Exception(
+ "obsolete strCompact method: forbiden use of compact representation of '%s', fix problem in caller"
+ % str(self)
+ )
+ # return toCompactStr_majorMinorPatch(self.toList())
+
+ def toList(self):
+ """example is list of integer [1, 2, 3] from '1.2.3'"""
+ return [self.major, self.minor, self.patch]
+
+ def __lt__(self, other):
+ res = self.toList() < other.toList()
+ return res
+
+ def __le__(self, other):
+ res = self.toList() <= other.toList()
+ return res
+
+ def __gt__(self, other):
+ res = self.toList() > other.toList()
+ return res
+
+ def __ge__(self, other):
+ res = self.toList() >= other.toList()
+ return res
+
+ def __eq__(self, other):
+ res = self.toList() == other.toList()
+ return res
+
+ def __ne__(self, other):
+ res = self.toList() != other.toList()
+ return res
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2013 CEA/DEN
#
# This library is free software; you can redistribute it and/or
import os
import shutil
-try: # For python2
+try: # For python2
import sys
- reload(sys)
- sys.setdefaultencoding('utf8')
+
+ reload(sys)
+ sys.setdefaultencoding("utf8")
except:
pass
verbose = False
+
class XmlLogFile(object):
- '''Class to manage writing in salomeTools xml log file
- '''
- def __init__(self, filePath, rootname, attrib = {}):
- '''Initialization
-
+ """Class to manage writing in salomeTools xml log file"""
+
+ def __init__(self, filePath, rootname, attrib={}):
+ """Initialization
+
:param filePath str: The path to the file where to write the log file
:param rootname str: The name of the root node of the xml file
- :param attrib dict: the dictionary that contains the attributes
+ :param attrib dict: the dictionary that contains the attributes
and value of the root node
- '''
- # Initialize the filePath and ensure that the directory
+ """
+ # Initialize the filePath and ensure that the directory
# that contain the file exists (make it if necessary)
self.logFile = filePath
src.ensure_path_exists(os.path.dirname(filePath))
# Initialize the field that contain the xml in memory
- self.xmlroot = etree.Element(rootname, attrib = attrib)
+ self.xmlroot = etree.Element(rootname, attrib=attrib)
+
+ def write_tree(self, stylesheet=None, file_path=None):
+ """Write the xml tree in the log file path. Add the stylesheet if asked.
- def write_tree(self, stylesheet=None, file_path = None):
- '''Write the xml tree in the log file path. Add the stylesheet if asked.
-
:param stylesheet str: The stylesheet to apply to the xml file
- '''
+ """
log_file_path = self.logFile
if file_path:
- log_file_path = file_path
+ log_file_path = file_path
try:
- with open(log_file_path, 'w') as f:
- f.write("<?xml version='1.0' encoding='utf-8'?>\n")
- if stylesheet:
- # example as href='./hat.xsl'
- # as local file xml with local file xsl
- # with 'python3 -m http.server 8765 &' and
- # 'chromium-browser http://localhost:8765/hat.xml' or
- # 'firefox http://localhost:8765/hat.xml'
- f.write("<?xml-stylesheet type='text/xsl' href='./%s'?>\n" % stylesheet)
- pass
- res= etree.tostring(self.xmlroot, encoding='utf-8')
- f.write(res)
+ with open(log_file_path, "w") as f:
+ f.write("<?xml version='1.0' encoding='utf-8'?>\n")
+ if stylesheet:
+ # example as href='./hat.xsl'
+ # as local file xml with local file xsl
+ # with 'python3 -m http.server 8765 &' and
+ # 'chromium-browser http://localhost:8765/hat.xml' or
+ # 'firefox http://localhost:8765/hat.xml'
+ f.write(
+ "<?xml-stylesheet type='text/xsl' href='./%s'?>\n" % stylesheet
+ )
+ pass
+ res = etree.tostring(self.xmlroot, encoding="utf-8")
+ f.write(res)
except IOError:
- pass
-
+ pass
+
def add_simple_node(self, node_name, text=None, attrib={}):
- '''Add a node with some attibutes and text to the root node.
-
+ """Add a node with some attibutes and text to the root node.
+
:param node_name str: the name of the node to add
:param text str: the text of the node
- :param attrib dict: the dictionary containing the
+ :param attrib dict: the dictionary containing the
attribute of the new node
- '''
+ """
n = etree.Element(node_name, attrib=attrib)
n.text = text
self.xmlroot.append(n)
return n
-
+
def append_node_text(self, node_name, text):
- '''Append a new text to the node that has node_name as name
-
+ """Append a new text to the node that has node_name as name
+
:param node_name str: The name of the node on which append text
:param text str: The text to append
- '''
+ """
# find the corresponding node
for field in self.xmlroot:
if field.tag == node_name:
field.text += text
def append_node_attrib(self, node_name, attrib):
- '''Append a new attributes to the node that has node_name as name
-
+ """Append a new attributes to the node that has node_name as name
+
:param node_name str: The name of the node on which append text
:param attrib dixt: The attrib to append
- '''
+ """
self.xmlroot.find(node_name).attrib.update(attrib)
+
class ReadXmlFile(object):
- '''Class to manage reading of an xml log file
- '''
+ """Class to manage reading of an xml log file"""
+
def __init__(self, filePath):
- '''Initialization
-
+ """Initialization
+
:param filePath str: The xml file to be read
- '''
+ """
self.filePath = filePath
etree_inst = etree.parse(filePath)
self.xmlroot = etree_inst.parse(filePath)
def getRootAttrib(self):
- '''Get the attibutes of the self.xmlroot
-
+ """Get the attibutes of the self.xmlroot
+
:return: The attributes of the root node
:rtype: dict
- '''
+ """
return self.xmlroot.attrib
-
+
def get_attrib(self, node_name):
- '''Get the attibutes of the node node_name in self.xmlroot
-
+ """Get the attibutes of the node node_name in self.xmlroot
+
:param node_name str: the name of the node
:return: the attibutes of the node node_name in self.xmlroot
:rtype: dict
- '''
+ """
attrib = self.xmlroot.find(node_name).attrib
# To be python 3 compatible, convert bytes to str if there are any
fixedAttrib = {}
value = attrib[k]
fixedAttrib[key] = value
return fixedAttrib
-
+
def get_node_text(self, node):
- '''Get the text of the first node that has name
+ """Get the text of the first node that has name
that corresponds to the parameter node
-
+
:param node str: the name of the node from which get the text
- :return: the text of the first node that has name
+ :return: the text of the first node that has name
that corresponds to the parameter node
:rtype: str
- '''
+ """
return self.xmlroot.find(node).text
-
+
+
def add_simple_node(root_node, node_name, text=None, attrib={}):
- '''Add a node with some attibutes and text to the root node.
+ """Add a node with some attibutes and text to the root node.
- :param root_node etree.Element: the Etree element where to add the new node
+ :param root_node etree.Element: the Etree element where to add the new node
:param node_name str: the name of the node to add
:param text str: the text of the node
- :param attrib dict: the dictionary containing the
+ :param attrib dict: the dictionary containing the
attribute of the new node
- '''
+ """
n = etree.Element(node_name, attrib=attrib)
n.text = text
root_node.append(n)
return n
+
def append_node_attrib(root_node, attrib):
- '''Append a new attributes to the node that has node_name as name
-
- :param root_node etree.Element: the Etree element
+ """Append a new attributes to the node that has node_name as name
+
+ :param root_node etree.Element: the Etree element
where to append the new attibutes
:param attrib dixt: The attrib to append
- '''
+ """
root_node.attrib.update(attrib)
+
def find_node_by_attrib(xmlroot, name_node, key, value):
- '''Find the nfirst ode from xmlroot that has name name_node and that has in
+ """Find the nfirst ode from xmlroot that has name name_node and that has in
its attributes {key : value}. Return the node
-
+
:param xmlroot etree.Element: the Etree element where to search
:param name_node str: the name of node to search
:param key str: the key to search
:param value str: the value to search
:return: the found node
:rtype: xmlroot etree.Element
- '''
- l_nodes = xmlroot.findall(name_node)
+ """
+ l_nodes = xmlroot.findall(name_node)
for node in l_nodes:
if key not in node.attrib.keys():
continue
if node.attrib[key] == value:
return node
return None
-
+
def write_report(filename, xmlroot, stylesheet):
"""Writes a report file from a XML tree.
-
+
:param filename str: The path to the file to create
:param xmlroot etree.Element: the Etree element to write to the file
:param stylesheet str: The stylesheet to add to the begin of the file
"""
dirname = os.path.dirname(filename)
if not os.path.exists(dirname):
- os.makedirs(dirname)
+ os.makedirs(dirname)
if len(stylesheet) > 0:
- styleName = stylesheet
+ styleName = stylesheet
else:
- styleName = None
+ styleName = None
with open(filename, "w") as f:
- f.write("<?xml version='1.0' encoding='utf-8'?>\n")
- if styleName is not None:
- f.write("<?xml-stylesheet type='text/xsl' href='%s'?>\n" % styleName)
- res = etree.tostring(xmlroot, encoding='utf-8')
- # print("********** etree.tostring %s" % res)
- f.write(res)
+ f.write("<?xml version='1.0' encoding='utf-8'?>\n")
+ if styleName is not None:
+ f.write("<?xml-stylesheet type='text/xsl' href='%s'?>\n" % styleName)
+ res = etree.tostring(xmlroot, encoding="utf-8")
+ # print("********** etree.tostring %s" % res)
+ f.write(res)
# create fileStyle in dirname if not existing
if styleName is not None:
- styleFile = os.path.join(dirname, styleName)
- if not os.path.exists(styleFile):
- # copy if from "salomeTools/src/xsl"
- srcdir = os.path.dirname(src.__file__)
- srcFile = os.path.join(srcdir, "xsl", styleName)
- if verbose: print("write_report %s style %s" % (srcFile, styleFile))
- shutil.copy(srcFile, dirname)
+ styleFile = os.path.join(dirname, styleName)
+ if not os.path.exists(styleFile):
+ # copy if from "salomeTools/src/xsl"
+ srcdir = os.path.dirname(src.__file__)
+ srcFile = os.path.join(srcdir, "xsl", styleName)
+ if verbose:
+ print("write_report %s style %s" % (srcFile, styleFile))
+ shutil.copy(srcFile, dirname)
+
def escapeSequence(aStr):
"""
' (apostrophe or single quote) as '
" (double-quote) as "
"""
- replaces = [ ('&', '&'),
- ('>', '>'),
- ('<', '<'),
- ("'", '''),
- ('"', '"'),
- ]
+ replaces = [
+ ("&", "&"),
+ (">", ">"),
+ ("<", "<"),
+ ("'", "'"),
+ ('"', """),
+ ]
res = aStr
- for ini, fin in replaces: # order matters
- res = res.replace(ini, fin)
+ for ini, fin in replaces: # order matters
+ res = res.replace(ini, fin)
return res
-
-
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2018 CEA/DEN
#
# sys.stderr.write("INFO : initializeTest needs '%s' in sys.path:\n%s\n" % (satdir, PP.pformat(sys.path)))
if satdir not in sys.path:
- # get path to salomeTools sources FIRST as prepend
- # Make the src & commands package accessible from all test code
- sys.path.insert(0, satdir)
- sys.stderr.write("""\
+ # get path to salomeTools sources FIRST as prepend
+ # Make the src & commands package accessible from all test code
+ sys.path.insert(0, satdir)
+ sys.stderr.write(
+ """\
WARNING : sys.path not set for salomeTools, fixed for you:
sys.path prepend '%s'
- sys.path:\n%s\n""" % (satdir, PP.pformat(sys.path)))
- # os.environ PATH is not set...
- # supposedly useful only for subprocess launch from sat
- # see https://docs.python.org/2/library/os.html
- # On some platforms, including FreeBSD and Mac OS X,
- # setting environ may cause memory leaks.
- # sys.stderr.write("os.environ PATH:\n%s\n" % PP.pformat(os.environ["PATH"].split(":")))
- sys.stderr.write("INFO : to fix this message type:\n 'export PYTHONPATH=%s:${PYTHONPATH}'\n" % satdir)
-
-
+ sys.path:\n%s\n"""
+ % (satdir, PP.pformat(sys.path))
+ )
+ # os.environ PATH is not set...
+ # supposedly useful only for subprocess launch from sat
+ # see https://docs.python.org/2/library/os.html
+ # On some platforms, including FreeBSD and Mac OS X,
+ # setting environ may cause memory leaks.
+ # sys.stderr.write("os.environ PATH:\n%s\n" % PP.pformat(os.environ["PATH"].split(":")))
+ sys.stderr.write(
+ "INFO : to fix this message type:\n 'export PYTHONPATH=%s:${PYTHONPATH}'\n"
+ % satdir
+ )
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2018 CEA/DEN
#
import sys
import unittest
-import initializeTest # set PATH etc for test
+import initializeTest # set PATH etc for test
-import src.debug as DBG # Easy print stderr (for DEBUG only)
-import src.pyconf as PYF # 0.3.7
+import src.debug as DBG # Easy print stderr (for DEBUG only)
+import src.pyconf as PYF # 0.3.7
_EXAMPLES = {
-1 : """\
+ 1: """\
messages:
[
{
}
]
""",
-
-2 : """\
+ 2: """\
aa: 111
bb: $aa + 222
""",
-
-3 : """\
+ 3: """\
aa: Yves
bb: "Herve" # avoid Hervé -> 'utf8' codec can't decode byte
""",
-
-4 : """\
+ 4: """\
aa: Yves
bb: "Hervé" # avoid Hervé -> 'utf8' codec can't decode byte
""",
-
-
}
class TestCase(unittest.TestCase):
- "Test the debug.py"""
-
- def test_000(self):
- # one shot setUp() for this TestCase
- # DBG.push_debug(True)
- # SAT.setNotLocale() # test english
- return
-
- def test_005(self):
- res = DBG.getLocalEnv()
- self.assertTrue(len(res.split()) > 0)
- self.assertTrue("USER :" in res)
- self.assertTrue("LANG :" in res)
-
- def test_010(self):
- inStream = DBG.InStream(_EXAMPLES[1])
- self.assertEqual(inStream.getvalue(), _EXAMPLES[1])
- cfg = PYF.Config(inStream)
- self.assertEqual(len(cfg.messages), 3)
- outStream = DBG.OutStream()
- DBG.saveConfigStd(cfg, outStream)
- res = outStream.value
- DBG.write("test_010 cfg std", res)
- self.assertTrue("messages :" in res)
- self.assertTrue("'sys.stderr'" in res)
-
- def test_020(self):
- inStream = DBG.InStream(_EXAMPLES[2])
- cfg = PYF.Config(inStream)
- res = DBG.getStrConfigDbg(cfg)
- DBG.write("test_020 cfg dbg", res)
- ress = res.split("\n")
- self.assertTrue(".aa" in ress[0])
- self.assertTrue(": '111'" in ress[0])
- self.assertTrue(".bb" in ress[1])
- self.assertTrue(": $aa + 222 " in ress[1])
- self.assertTrue("--> '333'" in ress[1])
-
- def test_025(self):
- inStream = DBG.InStream(_EXAMPLES[1])
- cfg = PYF.Config(inStream)
- outStream = DBG.OutStream()
- DBG.saveConfigDbg(cfg, outStream)
- res = outStream.value
- DBG.write("test_025 cfg dbg", res)
- for i in range(len(cfg.messages)):
- self.assertTrue("messages[%i].name" % i in res)
- self.assertTrue("--> 'HELLO sys.stderr'" in res)
+ "Test the debug.py" ""
+
+ def test_000(self):
+ # one shot setUp() for this TestCase
+ # DBG.push_debug(True)
+ # SAT.setNotLocale() # test english
+ return
+
+ def test_005(self):
+ res = DBG.getLocalEnv()
+ self.assertTrue(len(res.split()) > 0)
+ self.assertTrue("USER :" in res)
+ self.assertTrue("LANG :" in res)
-
- def test_999(self):
- # one shot tearDown() for this TestCase
- # SAT.setLocale() # end test english
- # DBG.pop_debug()
- return
-
-if __name__ == '__main__':
+ def test_010(self):
+ inStream = DBG.InStream(_EXAMPLES[1])
+ self.assertEqual(inStream.getvalue(), _EXAMPLES[1])
+ cfg = PYF.Config(inStream)
+ self.assertEqual(len(cfg.messages), 3)
+ outStream = DBG.OutStream()
+ DBG.saveConfigStd(cfg, outStream)
+ res = outStream.value
+ DBG.write("test_010 cfg std", res)
+ self.assertTrue("messages :" in res)
+ self.assertTrue("'sys.stderr'" in res)
+
+ def test_020(self):
+ inStream = DBG.InStream(_EXAMPLES[2])
+ cfg = PYF.Config(inStream)
+ res = DBG.getStrConfigDbg(cfg)
+ DBG.write("test_020 cfg dbg", res)
+ ress = res.split("\n")
+ self.assertTrue(".aa" in ress[0])
+ self.assertTrue(": '111'" in ress[0])
+ self.assertTrue(".bb" in ress[1])
+ self.assertTrue(": $aa + 222 " in ress[1])
+ self.assertTrue("--> '333'" in ress[1])
+
+ def test_025(self):
+ inStream = DBG.InStream(_EXAMPLES[1])
+ cfg = PYF.Config(inStream)
+ outStream = DBG.OutStream()
+ DBG.saveConfigDbg(cfg, outStream)
+ res = outStream.value
+ DBG.write("test_025 cfg dbg", res)
+ for i in range(len(cfg.messages)):
+ self.assertTrue("messages[%i].name" % i in res)
+ self.assertTrue("--> 'HELLO sys.stderr'" in res)
+
+ def test_999(self):
+ # one shot tearDown() for this TestCase
+ # SAT.setLocale() # end test english
+ # DBG.pop_debug()
+ return
+
+
+if __name__ == "__main__":
unittest.main(exit=False)
pass
-
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2018 CEA/DEN
#
import unittest
import pprint as PP
-import initializeTest # set PATH etc for test
+import initializeTest # set PATH etc for test
import src.versionMinorMajorPatch as VMMP
-verbose = False # True
+verbose = False # True
+
class TestCase(unittest.TestCase):
- "Test the versionMajorMinorPatch.py"""
-
- def test_010(self):
- if verbose: print(PP.pformat(dir(self)))
- self.assertTrue(VMMP.only_numbers("") is None)
- self.assertEqual(VMMP.only_numbers("1.2.3"), "123")
- self.assertEqual(VMMP.only_numbers("\n11.12.13\n"), "111213")
- self.assertEqual(VMMP.only_numbers(" \n 11.\t\n\t..12.13-rc2\n"), "1112132")
-
- def test_015(self):
- res = "a_b_c"
- self.assertEqual(VMMP.remove_startswith("version_a_b_c", "version_".split()), res)
- self.assertEqual(VMMP.remove_startswith("v_a_b_c", "version_ v_".split()), res)
- self.assertEqual(VMMP.remove_startswith("va_b_c", "version_ v_ v".split()), res)
-
- ini = "version_a_b_c"
- self.assertEqual(VMMP.remove_startswith(ini, "V".split()), ini)
- self.assertEqual(VMMP.remove_startswith(ini, "_".split()), ini)
- self.assertEqual(VMMP.remove_startswith(ini, "a_b_c".split()), ini)
- self.assertEqual(VMMP.remove_startswith(ini, "VERSION".split()), ini)
-
-
- def test_020(self):
- res = [11, 222, 3333]
- self.assertEqual(VMMP.toList_majorMinorPatch("11.222.3333"), res)
- self.assertEqual(VMMP.toList_majorMinorPatch("11_222_3333"), res)
- self.assertEqual(VMMP.toList_majorMinorPatch("11.222_3333"), res)
- self.assertEqual(VMMP.toList_majorMinorPatch(" 11. 222 . 3333 "), res)
- self.assertEqual(VMMP.toList_majorMinorPatch("\n 11 . 222 . 3333 \n"), res)
- self.assertEqual(VMMP.toList_majorMinorPatch(" \n11.\t222.\r3333\n "), res) # could be tricky
-
- self.assertEqual(VMMP.toList_majorMinorPatch("V11.222.3333"), res)
- self.assertEqual(VMMP.toList_majorMinorPatch("Version11_222_3333"), res)
- self.assertEqual(VMMP.toList_majorMinorPatch("Version_11_222_3333"), res)
-
-
- self.assertEqual(VMMP.toList_majorMinorPatch("11"), [11, 0, 0])
- self.assertEqual(VMMP.toList_majorMinorPatch("11.0"), [11, 0, 0])
- self.assertEqual(VMMP.toList_majorMinorPatch("11.2"), [11, 2, 0])
- self.assertEqual(VMMP.toList_majorMinorPatch("\n1 . 2 \n"), [1, 2, 0])
-
- with self.assertRaises(Exception): VMMP.toList_majorMinorPatch("")
- with self.assertRaises(Exception): VMMP.toList_majorMinorPatch("11.")
- with self.assertRaises(Exception): VMMP.toList_majorMinorPatch("11.2.")
- with self.assertRaises(Exception): VMMP.toList_majorMinorPatch("11.2.3.")
- with self.assertRaises(Exception): VMMP.toList_majorMinorPatch(".11")
- with self.assertRaises(Exception): VMMP.toList_majorMinorPatch("1_2_3_4")
- with self.assertRaises(Exception): VMMP.toList_majorMinorPatch("_1_2_3_")
- with self.assertRaises(Exception): VMMP.toList_majorMinorPatch(" \n 11...22.333-rc2\n")
- with self.assertRaises(Exception): VMMP.toList_majorMinorPatch(" \n 11...22.333-rc2\n")
- with self.assertRaises(Exception): VMMP.toList_majorMinorPatch(" \n 11...22.333-rc2\n")
-
-
- def test_040(self):
- MMP = VMMP.MinorMajorPatch
- v = [1, 2, 3]
- self.assertEqual(MMP(v).__str__(), "1.2.3")
- self.assertEqual(MMP(v).__str__(sep="_"), "1_2_3")
- self.assertEqual(str(MMP(v)), "1.2.3")
-
- self.assertEqual(MMP(v).__repr__(), "version_1_2_3")
- self.assertEqual(MMP(v).__repr__(sep="."), "version_1.2.3")
-
- self.assertEqual(MMP(v).strSalome(), "1_2_3")
- self.assertEqual(MMP(v).strClassic(), "1.2.3")
-
- self.assertEqual(MMP([' 123 \n', 2, 10]).strClassic(), "123.2.10")
- self.assertEqual(MMP([' 123 \n', 2, 10]).strSalome(), "123_2_10")
-
- with self.assertRaises(Exception): MMP([-5, 2, 10])
- with self.assertRaises(Exception): MMP([5, -2, 10])
- with self.assertRaises(Exception): MMP([5, 2, -10])
- with self.assertRaises(Exception): MMP(['-123', 2, 10])
-
- def test_050(self):
- MMP = VMMP.MinorMajorPatch
- v000 = MMP("0.0.0")
- v010 = MMP("0.1.0")
- v100 = MMP("1.0.0")
- v101 = MMP("1.0.1")
-
- va = v000
- vb = MMP("0.0.0")
- self.assertTrue(va == vb)
- self.assertTrue(va >= vb)
- self.assertTrue(va <= vb)
- self.assertFalse(va != vb)
- self.assertFalse(va > vb)
- self.assertFalse(va < vb)
-
- va = v000
- vb = v010
- self.assertFalse(va == vb)
- self.assertFalse(va >= vb)
- self.assertTrue(va <= vb)
- self.assertTrue(va != vb)
- self.assertFalse(va > vb)
- self.assertTrue(va < vb)
-
- va = v101
- vb = v100
- self.assertFalse(va == vb)
- self.assertTrue(va >= vb)
- self.assertFalse(va <= vb)
- self.assertTrue(va != vb)
- self.assertTrue(va > vb)
- self.assertFalse(va < vb)
-
- def test_060(self):
- MMP = VMMP.MinorMajorPatch
- v0 = MMP("0")
- v1 = MMP("1")
- v2 = MMP("2")
- v123 = MMP("1.2.3")
- v456 = MMP("4.5.6")
-
- tests = """\
+ "Test the versionMajorMinorPatch.py" ""
+
+ def test_010(self):
+ if verbose:
+ print(PP.pformat(dir(self)))
+ self.assertTrue(VMMP.only_numbers("") is None)
+ self.assertEqual(VMMP.only_numbers("1.2.3"), "123")
+ self.assertEqual(VMMP.only_numbers("\n11.12.13\n"), "111213")
+ self.assertEqual(VMMP.only_numbers(" \n 11.\t\n\t..12.13-rc2\n"), "1112132")
+
+ def test_015(self):
+ res = "a_b_c"
+ self.assertEqual(
+ VMMP.remove_startswith("version_a_b_c", "version_".split()), res
+ )
+ self.assertEqual(VMMP.remove_startswith("v_a_b_c", "version_ v_".split()), res)
+ self.assertEqual(VMMP.remove_startswith("va_b_c", "version_ v_ v".split()), res)
+
+ ini = "version_a_b_c"
+ self.assertEqual(VMMP.remove_startswith(ini, "V".split()), ini)
+ self.assertEqual(VMMP.remove_startswith(ini, "_".split()), ini)
+ self.assertEqual(VMMP.remove_startswith(ini, "a_b_c".split()), ini)
+ self.assertEqual(VMMP.remove_startswith(ini, "VERSION".split()), ini)
+
+ def test_020(self):
+ res = [11, 222, 3333]
+ self.assertEqual(VMMP.toList_majorMinorPatch("11.222.3333"), res)
+ self.assertEqual(VMMP.toList_majorMinorPatch("11_222_3333"), res)
+ self.assertEqual(VMMP.toList_majorMinorPatch("11.222_3333"), res)
+ self.assertEqual(VMMP.toList_majorMinorPatch(" 11. 222 . 3333 "), res)
+ self.assertEqual(
+ VMMP.toList_majorMinorPatch("\n 11 . 222 . 3333 \n"), res
+ )
+ self.assertEqual(
+ VMMP.toList_majorMinorPatch(" \n11.\t222.\r3333\n "), res
+ ) # could be tricky
+
+ self.assertEqual(VMMP.toList_majorMinorPatch("V11.222.3333"), res)
+ self.assertEqual(VMMP.toList_majorMinorPatch("Version11_222_3333"), res)
+ self.assertEqual(VMMP.toList_majorMinorPatch("Version_11_222_3333"), res)
+
+ self.assertEqual(VMMP.toList_majorMinorPatch("11"), [11, 0, 0])
+ self.assertEqual(VMMP.toList_majorMinorPatch("11.0"), [11, 0, 0])
+ self.assertEqual(VMMP.toList_majorMinorPatch("11.2"), [11, 2, 0])
+ self.assertEqual(VMMP.toList_majorMinorPatch("\n1 . 2 \n"), [1, 2, 0])
+
+ with self.assertRaises(Exception):
+ VMMP.toList_majorMinorPatch("")
+ with self.assertRaises(Exception):
+ VMMP.toList_majorMinorPatch("11.")
+ with self.assertRaises(Exception):
+ VMMP.toList_majorMinorPatch("11.2.")
+ with self.assertRaises(Exception):
+ VMMP.toList_majorMinorPatch("11.2.3.")
+ with self.assertRaises(Exception):
+ VMMP.toList_majorMinorPatch(".11")
+ with self.assertRaises(Exception):
+ VMMP.toList_majorMinorPatch("1_2_3_4")
+ with self.assertRaises(Exception):
+ VMMP.toList_majorMinorPatch("_1_2_3_")
+ with self.assertRaises(Exception):
+ VMMP.toList_majorMinorPatch(" \n 11...22.333-rc2\n")
+ with self.assertRaises(Exception):
+ VMMP.toList_majorMinorPatch(" \n 11...22.333-rc2\n")
+ with self.assertRaises(Exception):
+ VMMP.toList_majorMinorPatch(" \n 11...22.333-rc2\n")
+
+ def test_040(self):
+ MMP = VMMP.MinorMajorPatch
+ v = [1, 2, 3]
+ self.assertEqual(MMP(v).__str__(), "1.2.3")
+ self.assertEqual(MMP(v).__str__(sep="_"), "1_2_3")
+ self.assertEqual(str(MMP(v)), "1.2.3")
+
+ self.assertEqual(MMP(v).__repr__(), "version_1_2_3")
+ self.assertEqual(MMP(v).__repr__(sep="."), "version_1.2.3")
+
+ self.assertEqual(MMP(v).strSalome(), "1_2_3")
+ self.assertEqual(MMP(v).strClassic(), "1.2.3")
+
+ self.assertEqual(MMP([" 123 \n", 2, 10]).strClassic(), "123.2.10")
+ self.assertEqual(MMP([" 123 \n", 2, 10]).strSalome(), "123_2_10")
+
+ with self.assertRaises(Exception):
+ MMP([-5, 2, 10])
+ with self.assertRaises(Exception):
+ MMP([5, -2, 10])
+ with self.assertRaises(Exception):
+ MMP([5, 2, -10])
+ with self.assertRaises(Exception):
+ MMP(["-123", 2, 10])
+
+ def test_050(self):
+ MMP = VMMP.MinorMajorPatch
+ v000 = MMP("0.0.0")
+ v010 = MMP("0.1.0")
+ v100 = MMP("1.0.0")
+ v101 = MMP("1.0.1")
+
+ va = v000
+ vb = MMP("0.0.0")
+ self.assertTrue(va == vb)
+ self.assertTrue(va >= vb)
+ self.assertTrue(va <= vb)
+ self.assertFalse(va != vb)
+ self.assertFalse(va > vb)
+ self.assertFalse(va < vb)
+
+ va = v000
+ vb = v010
+ self.assertFalse(va == vb)
+ self.assertFalse(va >= vb)
+ self.assertTrue(va <= vb)
+ self.assertTrue(va != vb)
+ self.assertFalse(va > vb)
+ self.assertTrue(va < vb)
+
+ va = v101
+ vb = v100
+ self.assertFalse(va == vb)
+ self.assertTrue(va >= vb)
+ self.assertFalse(va <= vb)
+ self.assertTrue(va != vb)
+ self.assertTrue(va > vb)
+ self.assertFalse(va < vb)
+
+ def test_060(self):
+ MMP = VMMP.MinorMajorPatch
+ v0 = MMP("0")
+ v1 = MMP("1")
+ v2 = MMP("2")
+ v123 = MMP("1.2.3")
+ v456 = MMP("4.5.6")
+
+ tests = """\
toto_from_1_to_2
_from_1.0.0_to_2.0.0
_from_1_0. 0_to_ 2.0_0
_from_V1.0.0_to_2.0.0
_from_version_1.0.0_to_2.0.0
version_1.0.0_to_2.0.0
-VERSION_1.0.0_to_2.0.0""".split("\n")
-
- for a in tests:
- # print("test '%s'" % a)
- r1, r2 = VMMP.getRange_majorMinorPatch(a)
- self.assertEqual(r1, v1)
- self.assertEqual(r2, v2)
-
- a = "toto_to_2"
- r1, r2 = VMMP.getRange_majorMinorPatch(a)
- self.assertEqual(r1, v0)
- self.assertEqual(r2, v2)
-
- a = "toto_to_Version2"
- r1, r2 = VMMP.getRange_majorMinorPatch(a)
- self.assertEqual(r1, v0)
- self.assertEqual(r2, v2)
-
- a = "toto_from_1.2.3_to_Version4_5_6"
- r1, r2 = VMMP.getRange_majorMinorPatch(a)
- self.assertEqual(r1, v123)
- self.assertEqual(r2, v456)
-
- a = "toto_from_1.2.3_to_Version1_2_3"
- r1, r2 = VMMP.getRange_majorMinorPatch(a)
- self.assertEqual(r1, v123)
- self.assertEqual(r2, v123)
-
- # _from_ without _to_ does not matter
- tests = """\
+VERSION_1.0.0_to_2.0.0""".split(
+ "\n"
+ )
+
+ for a in tests:
+ # print("test '%s'" % a)
+ r1, r2 = VMMP.getRange_majorMinorPatch(a)
+ self.assertEqual(r1, v1)
+ self.assertEqual(r2, v2)
+
+ a = "toto_to_2"
+ r1, r2 = VMMP.getRange_majorMinorPatch(a)
+ self.assertEqual(r1, v0)
+ self.assertEqual(r2, v2)
+
+ a = "toto_to_Version2"
+ r1, r2 = VMMP.getRange_majorMinorPatch(a)
+ self.assertEqual(r1, v0)
+ self.assertEqual(r2, v2)
+
+ a = "toto_from_1.2.3_to_Version4_5_6"
+ r1, r2 = VMMP.getRange_majorMinorPatch(a)
+ self.assertEqual(r1, v123)
+ self.assertEqual(r2, v456)
+
+ a = "toto_from_1.2.3_to_Version1_2_3"
+ r1, r2 = VMMP.getRange_majorMinorPatch(a)
+ self.assertEqual(r1, v123)
+ self.assertEqual(r2, v123)
+
+ # _from_ without _to_ does not matter
+ tests = """\
toto
from
to
_from_
-toto_from_2""".split("\n")
-
- for a in tests:
- rx = VMMP.getRange_majorMinorPatch(a, verbose=False)
- self.assertEqual(rx, None)
-
- # _to_ without _from_ does not matter, as implicit _from_ '0.0.0'
- # empty _to_ raise error
- with self.assertRaises(Exception): VMMP.getRange_majorMinorPatch("_to_")
- with self.assertRaises(Exception): VMMP.getRange_majorMinorPatch("_from_to_")
- with self.assertRaises(Exception): VMMP.getRange_majorMinorPatch("_from__to_")
- with self.assertRaises(Exception): VMMP.getRange_majorMinorPatch("toto_from__to_")
- with self.assertRaises(Exception): VMMP.getRange_majorMinorPatch("toto_from_123_to_")
- with self.assertRaises(Exception): VMMP.getRange_majorMinorPatch("version_123_to_")
- with self.assertRaises(Exception): VMMP.getRange_majorMinorPatch("version_to_")
-
- # min > max does matter
- with self.assertRaises(Exception): VMMP.getRange_majorMinorPatch("_from_3_to_2")
- with self.assertRaises(Exception): VMMP.getRange_majorMinorPatch("_from_3.2.5_to_V2_1_1")
-
-if __name__ == '__main__':
- unittest.main(exit=False)
- pass
+toto_from_2""".split(
+ "\n"
+ )
+
+ for a in tests:
+ rx = VMMP.getRange_majorMinorPatch(a, verbose=False)
+ self.assertEqual(rx, None)
+
+ # _to_ without _from_ does not matter, as implicit _from_ '0.0.0'
+ # empty _to_ raise error
+ with self.assertRaises(Exception):
+ VMMP.getRange_majorMinorPatch("_to_")
+ with self.assertRaises(Exception):
+ VMMP.getRange_majorMinorPatch("_from_to_")
+ with self.assertRaises(Exception):
+ VMMP.getRange_majorMinorPatch("_from__to_")
+ with self.assertRaises(Exception):
+ VMMP.getRange_majorMinorPatch("toto_from__to_")
+ with self.assertRaises(Exception):
+ VMMP.getRange_majorMinorPatch("toto_from_123_to_")
+ with self.assertRaises(Exception):
+ VMMP.getRange_majorMinorPatch("version_123_to_")
+ with self.assertRaises(Exception):
+ VMMP.getRange_majorMinorPatch("version_to_")
+
+ # min > max does matter
+ with self.assertRaises(Exception):
+ VMMP.getRange_majorMinorPatch("_from_3_to_2")
+ with self.assertRaises(Exception):
+ VMMP.getRange_majorMinorPatch("_from_3.2.5_to_V2_1_1")
+
+
+if __name__ == "__main__":
+ unittest.main(exit=False)
+ pass
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2018 CEA/DEN
#
import src.debug as DBG
-verbose = False #True
+verbose = False # True
+
+_TRACE = LOGI.INFO - 2 # just below info
-_TRACE = LOGI.INFO - 2 # just below info
class LoggerSat(LOGI.Logger):
- """
- Elementary prototype for logger sat
- add a level TRACE as log.trace(msg)
- below log.info(msg)
- above log.debug(msg)
- to assume store long log asci in files txt under/outside files xml
-
- see: /usr/lib64/python2.7/logging/xxx__init__.py etc.
- """
-
- def __init__(self, name, level=LOGI.INFO):
- """
- Initialize the logger with a name and an optional level.
"""
- super(LoggerSat, self).__init__(name, level)
- LOGI.addLevelName(_TRACE, "TRACE")
- # LOGI.TRACE = _TRACE # only for coherency,
-
- def trace(self, msg, *args, **kwargs):
+ Elementary prototype for logger sat
+ add a level TRACE as log.trace(msg)
+ below log.info(msg)
+ above log.debug(msg)
+ to assume store long log asci in files txt under/outside files xml
+
+ see: /usr/lib64/python2.7/logging/xxx__init__.py etc.
"""
- Log 'msg % args' with severity '_TRACE'.
- To pass exception information, use the keyword argument exc_info with
- a true value, e.g.
+ def __init__(self, name, level=LOGI.INFO):
+ """
+ Initialize the logger with a name and an optional level.
+ """
+ super(LoggerSat, self).__init__(name, level)
+ LOGI.addLevelName(_TRACE, "TRACE")
+ # LOGI.TRACE = _TRACE # only for coherency,
+
+ def trace(self, msg, *args, **kwargs):
+ """
+ Log 'msg % args' with severity '_TRACE'.
+
+ To pass exception information, use the keyword argument exc_info with
+ a true value, e.g.
+
+ logger.trace("Houston, we have a %s", "long trace to follow")
+ """
+ if self.isEnabledFor(_TRACE):
+ self._log(_TRACE, msg, args, **kwargs)
- logger.trace("Houston, we have a %s", "long trace to follow")
- """
- if self.isEnabledFor(_TRACE):
- self._log(_TRACE, msg, args, **kwargs)
class TestCase(unittest.TestCase):
- "Test the debug.py"""
-
- initialLoggerClass = [] # to keep clean module logging
-
- def test_000(self):
- # one shot setUp() for this TestCase
- self.initialLoggerClass.append(LOGI._loggerClass)
- LOGI.setLoggerClass(LoggerSat)
- if verbose:
- DBG.push_debug(True)
- # DBG.write("assert unittest", [a for a in dir(self) if "assert" in a])
- pass
-
- def test_999(self):
- # one shot tearDown() for this TestCase
- if verbose:
- DBG.pop_debug()
- LOGI.setLoggerClass(self.initialLoggerClass[0])
- return
-
- def test_010(self):
- # LOGI.setLoggerClass(LoggerSat) # done once in test_000
- name = "testLogging"
- lgr = LOGI.getLogger(name) # create it
- lgr.setLevel("DEBUG")
- self.assertEqual(lgr.__class__, LoggerSat)
- self.assertEqual(lgr.name, name)
- self.assertIn("trace", dir(lgr))
- self.assertIn("TRACE", LOGI._levelNames.keys())
- self.assertIn(_TRACE, LOGI._levelNames.keys())
- self.assertEqual(LOGI.getLevelName(LOGI.INFO), "INFO")
- self.assertEqual(LOGI.getLevelName(_TRACE), "TRACE")
-
- # creation d'un handler pour chaque log sur la console
- formatter = LOGI.Formatter('%(levelname)-8s :: %(message)s')
- # stream_handler = LOGI.handlers.StreamHandler() # log outputs in console
- stream_handler = LOGI.handlers.BufferingHandler(1000) # log outputs in memory
- stream_handler.setLevel(LOGI.DEBUG)
- stream_handler.setFormatter(formatter)
- lgr.addHandler(stream_handler)
- # print # skip one line if outputs in console
- lgr.warning("!!! test warning")
- lgr.info("!!! test info")
- lgr.trace("!!! test trace")
- lgr.debug("!!! test debug")
- self.assertEqual(len(stream_handler.buffer), 4)
- rec = stream_handler.buffer[-1]
- self.assertEqual(rec.levelname, "DEBUG")
- self.assertEqual(rec.msg, "!!! test debug")
- self.assertEqual(stream_handler.get_name(), None) # what to serve ?
-
- def test_020(self):
- # LOGI.setLoggerClass(LoggerSat)
- name = "testLogging"
- lgr = LOGI.getLogger(name) # find it as created yet in test_010
- stream_handler = lgr.handlers[0]
- rec = stream_handler.buffer[-1]
- self.assertEqual(rec.levelname, "DEBUG")
- self.assertEqual(rec.msg, "!!! test debug")
-
-
-
-
-if __name__ == '__main__':
+ "Test the debug.py" ""
+
+ initialLoggerClass = [] # to keep clean module logging
+
+ def test_000(self):
+ # one shot setUp() for this TestCase
+ self.initialLoggerClass.append(LOGI._loggerClass)
+ LOGI.setLoggerClass(LoggerSat)
+ if verbose:
+ DBG.push_debug(True)
+ # DBG.write("assert unittest", [a for a in dir(self) if "assert" in a])
+ pass
+
+ def test_999(self):
+ # one shot tearDown() for this TestCase
+ if verbose:
+ DBG.pop_debug()
+ LOGI.setLoggerClass(self.initialLoggerClass[0])
+ return
+
+ def test_010(self):
+ # LOGI.setLoggerClass(LoggerSat) # done once in test_000
+ name = "testLogging"
+ lgr = LOGI.getLogger(name) # create it
+ lgr.setLevel("DEBUG")
+ self.assertEqual(lgr.__class__, LoggerSat)
+ self.assertEqual(lgr.name, name)
+ self.assertIn("trace", dir(lgr))
+ self.assertIn("TRACE", LOGI._levelNames.keys())
+ self.assertIn(_TRACE, LOGI._levelNames.keys())
+ self.assertEqual(LOGI.getLevelName(LOGI.INFO), "INFO")
+ self.assertEqual(LOGI.getLevelName(_TRACE), "TRACE")
+
+ # creation d'un handler pour chaque log sur la console
+ formatter = LOGI.Formatter("%(levelname)-8s :: %(message)s")
+ # stream_handler = LOGI.handlers.StreamHandler() # log outputs in console
+ stream_handler = LOGI.handlers.BufferingHandler(1000) # log outputs in memory
+ stream_handler.setLevel(LOGI.DEBUG)
+ stream_handler.setFormatter(formatter)
+ lgr.addHandler(stream_handler)
+ # print # skip one line if outputs in console
+ lgr.warning("!!! test warning")
+ lgr.info("!!! test info")
+ lgr.trace("!!! test trace")
+ lgr.debug("!!! test debug")
+ self.assertEqual(len(stream_handler.buffer), 4)
+ rec = stream_handler.buffer[-1]
+ self.assertEqual(rec.levelname, "DEBUG")
+ self.assertEqual(rec.msg, "!!! test debug")
+ self.assertEqual(stream_handler.get_name(), None) # what to serve ?
+
+ def test_020(self):
+ # LOGI.setLoggerClass(LoggerSat)
+ name = "testLogging"
+ lgr = LOGI.getLogger(name) # find it as created yet in test_010
+ stream_handler = lgr.handlers[0]
+ rec = stream_handler.buffer[-1]
+ self.assertEqual(rec.levelname, "DEBUG")
+ self.assertEqual(rec.msg, "!!! test debug")
+
+
+if __name__ == "__main__":
unittest.main(exit=False)
pass
-
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2018 CEA/DEN
#
import sys
import unittest
-import initializeTest # set PATH etc for test
+import initializeTest # set PATH etc for test
-import src.debug as DBG # Easy print stderr (for DEBUG only)
-import src.pyconf as PYF # 0.3.7
+import src.debug as DBG # Easy print stderr (for DEBUG only)
+import src.pyconf as PYF # 0.3.7
_EXAMPLES = {
-1 : """\
+ 1: """\
messages:
[
{
}
]
""",
-
-2 : """\
+ 2: """\
aa: 111
bb: $aa + 222
""",
-
-3 : """\
+ 3: """\
aa: Yves
bb: "Herve" # avoid Hervé -> 'utf8' codec can't decode byte
""",
-
-4 : """\
+ 4: """\
aa: Yves
bb: "Hervé" # avoid Hervé -> 'utf8' codec can't decode byte
""",
-
-5 : """\
+ 5: """\
aa: Yves
bb: "Herve"
cc: [
d4 : $bb + " bye"
}
""",
-
-# error circular
-6 : """\
+ # error circular
+ 6: """\
aa: Yves
bb: $cc
cc: $bb
""",
-
-7 : """\
+ 7: """\
aa: Yves
bb: $cc
cc: [
$bb
]
""",
-
-8 : """\
+ 8: """\
aa: Yves
bb: $cc
cc: {
cc2: $bb
}
""",
-
}
class TestCase(unittest.TestCase):
- "Test the pyconf.py"""
-
- def test_000(self):
- # one shot setUp() for this TestCase
- # DBG.push_debug(True)
- # SAT.setNotLocale() # test english
- return
+ "Test the pyconf.py" ""
+
+ def test_000(self):
+ # one shot setUp() for this TestCase
+ # DBG.push_debug(True)
+ # SAT.setNotLocale() # test english
+ return
- def test_010(self):
- # pyconf.py doc example 0.3.7
- # https://www.red-dove.com/config-doc/ is 0.3.9 !
- # which, when run, would yield the console output:
+ def test_010(self):
+ # pyconf.py doc example 0.3.7
+ # https://www.red-dove.com/config-doc/ is 0.3.9 !
+ # which, when run, would yield the console output:
- expected = """\
+ expected = """\
Welcome, Harry
Welkom, Ruud
Bienvenue, Yves
"""
- inStream = DBG.InStream(_EXAMPLES[1])
- cfg = PYF.Config(inStream)
- res = ''
- for m in cfg.messages:
- res += '%s, %s\n' % (m.message, m.name)
- self.assertEqual(res, expected)
- outStream = DBG.OutStream()
- cfg.__save__(outStream) # sat renamed save() in __save__()
- res = outStream.value
- DBG.write("test_010 cfg", res)
- self.assertTrue("name : 'Harry'" in res)
- self.assertTrue("name : 'Ruud'" in res)
- self.assertTrue("name : 'Yves'" in res)
-
- def test_020(self):
- cfg = PYF.Config()
- self.assertEqual(str(cfg), '{}')
- self.assertEqual(cfg.__repr__(), '{}')
- cfg.aa = "1111"
- self.assertEqual(str(cfg), "{'aa': '1111'}")
- cfg.bb = 2222
- self.assertTrue("'bb': 2222" in str(cfg))
- self.assertTrue("'aa': '1111'" in str(cfg))
- cfg.cc = 3333.
- self.assertTrue("'cc': 3333." in str(cfg))
-
- def test_030(self):
- inStream = DBG.InStream(_EXAMPLES[2])
- cfg = PYF.Config(inStream)
- self.assertEqual(str(cfg), "{'aa': 111, 'bb': $aa + 222}")
- self.assertEqual(cfg.aa, 111)
- self.assertEqual(cfg.bb, 333)
-
- def test_040(self):
- inStream = DBG.InStream(_EXAMPLES[3])
- cfg = PYF.Config(inStream)
- self.assertEqual(cfg.aa, "Yves")
- self.assertEqual(cfg.bb, "Herve")
- self.assertEqual(type(cfg.bb), str)
- cfg.bb = "Hervé" # try this
- self.assertEqual(type(cfg.bb), str)
- self.assertEqual(cfg.bb, "Hervé")
-
- def test_045(self):
- # make Hervé valid only with pyconf.py as 0.3.9
- inStream = DBG.InStream(_EXAMPLES[4])
- outStream = DBG.OutStream()
- with self.assertRaises(Exception):
- cfg = PYF.Config(inStream)
+ inStream = DBG.InStream(_EXAMPLES[1])
+ cfg = PYF.Config(inStream)
+ res = ""
+ for m in cfg.messages:
+ res += "%s, %s\n" % (m.message, m.name)
+ self.assertEqual(res, expected)
+ outStream = DBG.OutStream()
+ cfg.__save__(outStream) # sat renamed save() in __save__()
+ res = outStream.value
+ DBG.write("test_010 cfg", res)
+ self.assertTrue("name : 'Harry'" in res)
+ self.assertTrue("name : 'Ruud'" in res)
+ self.assertTrue("name : 'Yves'" in res)
+
+ def test_020(self):
+ cfg = PYF.Config()
+ self.assertEqual(str(cfg), "{}")
+ self.assertEqual(cfg.__repr__(), "{}")
+ cfg.aa = "1111"
+ self.assertEqual(str(cfg), "{'aa': '1111'}")
+ cfg.bb = 2222
+ self.assertTrue("'bb': 2222" in str(cfg))
+ self.assertTrue("'aa': '1111'" in str(cfg))
+ cfg.cc = 3333.0
+ self.assertTrue("'cc': 3333." in str(cfg))
+
+ def test_030(self):
+ inStream = DBG.InStream(_EXAMPLES[2])
+ cfg = PYF.Config(inStream)
+ self.assertEqual(str(cfg), "{'aa': 111, 'bb': $aa + 222}")
+ self.assertEqual(cfg.aa, 111)
+ self.assertEqual(cfg.bb, 333)
+
+ def test_040(self):
+ inStream = DBG.InStream(_EXAMPLES[3])
+ cfg = PYF.Config(inStream)
+ self.assertEqual(cfg.aa, "Yves")
+ self.assertEqual(cfg.bb, "Herve")
+ self.assertEqual(type(cfg.bb), str)
+ cfg.bb = "Hervé" # try this
+ self.assertEqual(type(cfg.bb), str)
+ self.assertEqual(cfg.bb, "Hervé")
+
+ def test_045(self):
+ # make Hervé valid only with pyconf.py as 0.3.9
+ inStream = DBG.InStream(_EXAMPLES[4])
+ outStream = DBG.OutStream()
+ with self.assertRaises(Exception):
+ cfg = PYF.Config(inStream)
+
+ return # TODO only with pyconf.py as 0.3.9
+ cfg.save(outStream) # OK
+ # TODO: cfg = PYF.Config(inStream)
+ # cfg.__save__(outStream) # KO and sat renamed save() in __save__()
+ res = outStream.value
+ DBG.write("test_045 cfg", res)
+ self.assertTrue("aa : 'Yves'" in res)
+ self.assertTrue(r"bb : 'Herv\xc3\xa9'" in res)
+ self.assertEqual(cfg.bb, "Hervé")
+
+ def test_100(self):
+ inStream = DBG.InStream(_EXAMPLES[5])
+ outStream = DBG.OutStream()
+ cfg = PYF.Config(inStream) # KO
+ cfg.__save__(outStream) # sat renamed save() in __save__()
+ res = outStream.value
+ DBG.write("test_100 cfg save", res)
+ DBG.write("test_100 cfg debug", cfg)
+ DBG.write("test_100 cfg.cc debug", cfg.cc)
+
+ cc = cfg.cc
+ # DBG.write("test_100 type cc[3]", dir(cc), True)
+ DBG.write("test_100 cc", [cc.data[i] for i in range(len(cc))])
+
+ def test_100(self):
+ inStream = DBG.InStream(_EXAMPLES[5])
+ outStream = DBG.OutStream()
+ cfg = PYF.Config(inStream) # KO
+ cfg.__save__(outStream) # sat renamed save() in __save__()
+ res = outStream.value
+ DBG.write("test_100 cfg save", res)
+ DBG.write("test_100 cfg debug", cfg)
+ DBG.write("test_100 cfg.cc debug", cfg.cc)
+
+ cc = cfg.cc
+ # DBG.write("test_100 type cc[3]", dir(cc), True)
+ DBG.write("test_100 cc", [cc.data[i] for i in range(len(cc))])
+
+ def test_110(self):
+ inStream = DBG.InStream(_EXAMPLES[6])
+ outStream = DBG.OutStream()
+ cfg = PYF.Config(inStream)
+ cfg.__save__(outStream)
+
+ res = outStream.value
+ DBG.write("test_110 cfg save", res)
+ self.assertNotIn("ERROR", res)
+
+ res = DBG.getStrConfigDbg(cfg)
+ DBG.write("test_110 cfg debug", res)
+ self.assertIn("ERROR", res)
+ self.assertIn("unable to evaluate $cc", res)
+ self.assertIn("unable to evaluate $bb", res)
+
+ def test_120(self):
+ for ii in [7, 8]:
+ inStream = DBG.InStream(_EXAMPLES[ii])
+ outStream = DBG.OutStream()
+ cfg = PYF.Config(inStream)
+ cfg.__save__(outStream)
+
+ res = outStream.value
+ DBG.write("test_120 cfg save", res)
+ self.assertNotIn("ERROR", res)
+
+ res = DBG.getStrConfigDbg(cfg)
+
+ DBG.write("test_120 cfg debug", res)
+ # no error circular !!!
+ # self.assertIn("ERROR", res) # no error circular !!!
+ # self.assertIn("unable to evaluate $cc", res)
+ # self.assertIn("unable to evaluate $bb", res)
+ res = cfg.bb
+ DBG.write("test_120 cfg.bb debug", res)
+
+ res = cfg.cc
+ DBG.write("test_120 cfg.cc debug", res)
- return # TODO only with pyconf.py as 0.3.9
- cfg.save(outStream) # OK
- # TODO: cfg = PYF.Config(inStream)
- # cfg.__save__(outStream) # KO and sat renamed save() in __save__()
- res = outStream.value
- DBG.write("test_045 cfg", res)
- self.assertTrue("aa : 'Yves'" in res)
- self.assertTrue(r"bb : 'Herv\xc3\xa9'" in res)
- self.assertEqual(cfg.bb, "Hervé")
-
- def test_100(self):
- inStream = DBG.InStream(_EXAMPLES[5])
- outStream = DBG.OutStream()
- cfg = PYF.Config(inStream) # KO
- cfg.__save__(outStream) # sat renamed save() in __save__()
- res = outStream.value
- DBG.write("test_100 cfg save", res)
- DBG.write("test_100 cfg debug", cfg)
- DBG.write("test_100 cfg.cc debug", cfg.cc)
-
- cc = cfg.cc
- # DBG.write("test_100 type cc[3]", dir(cc), True)
- DBG.write("test_100 cc", [cc.data[i] for i in range(len(cc))])
-
- def test_100(self):
- inStream = DBG.InStream(_EXAMPLES[5])
- outStream = DBG.OutStream()
- cfg = PYF.Config(inStream) # KO
- cfg.__save__(outStream) # sat renamed save() in __save__()
- res = outStream.value
- DBG.write("test_100 cfg save", res)
- DBG.write("test_100 cfg debug", cfg)
- DBG.write("test_100 cfg.cc debug", cfg.cc)
-
- cc = cfg.cc
- # DBG.write("test_100 type cc[3]", dir(cc), True)
- DBG.write("test_100 cc", [cc.data[i] for i in range(len(cc))])
-
- def test_110(self):
- inStream = DBG.InStream(_EXAMPLES[6])
- outStream = DBG.OutStream()
- cfg = PYF.Config(inStream)
- cfg.__save__(outStream)
-
- res = outStream.value
- DBG.write("test_110 cfg save", res)
- self.assertNotIn("ERROR", res)
-
- res = DBG.getStrConfigDbg(cfg)
- DBG.write("test_110 cfg debug", res)
- self.assertIn("ERROR", res)
- self.assertIn("unable to evaluate $cc", res)
- self.assertIn("unable to evaluate $bb", res)
-
- def test_120(self):
- for ii in [7, 8]:
- inStream = DBG.InStream(_EXAMPLES[ii])
- outStream = DBG.OutStream()
- cfg = PYF.Config(inStream)
- cfg.__save__(outStream)
-
- res = outStream.value
- DBG.write("test_120 cfg save", res)
- self.assertNotIn("ERROR", res)
-
- res = DBG.getStrConfigDbg(cfg)
+ def test_999(self):
+ # one shot tearDown() for this TestCase
+ # SAT.setLocale() # end test english
+ # DBG.pop_debug()
+ return
- DBG.write("test_120 cfg debug", res)
- # no error circular !!!
- # self.assertIn("ERROR", res) # no error circular !!!
- # self.assertIn("unable to evaluate $cc", res)
- # self.assertIn("unable to evaluate $bb", res)
- res = cfg.bb
- DBG.write("test_120 cfg.bb debug", res)
- res = cfg.cc
- DBG.write("test_120 cfg.cc debug", res)
-
- def test_999(self):
- # one shot tearDown() for this TestCase
- # SAT.setLocale() # end test english
- # DBG.pop_debug()
- return
-
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main(exit=False)
pass
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2018 CEA/DEN
#
import sys
import unittest
-import initializeTest # set PATH etc for test
+import initializeTest # set PATH etc for test
import src.salomeTools as SAT
-import src.debug as DBG # Easy print stderr (for DEBUG only)
+import src.debug as DBG # Easy print stderr (for DEBUG only)
import src.loggingSimple as LOG
+
class TestCase(unittest.TestCase):
- "Test the sat --help commands"""
-
- debug = False
-
- def tearDown(self):
- # print "tearDown", __file__
- # assure self.logger clear for next test
- logger = LOG.getUnittestLogger()
- logs = logger.getLogsAndClear()
- # using assertNotIn() is too much verbose
- self.assertFalse("ERROR" in logs)
- self.assertFalse("CRITICAL" in logs)
-
- def test_000(self):
- logger = LOG.getUnittestLogger()
- # one shot setUp() for this TestCase
- if self.debug: DBG.push_debug(True)
- SAT.setNotLocale() # test english
-
- def test_999(self):
- # one shot tearDown() for this TestCase
- SAT.setLocale() # end test english
- if self.debug: DBG.pop_debug()
-
- def test_010(self): # TODO fix logger unittest
- cmd = "sat --help"
- res = SAT.launchSat(cmd)
- self.assertTrue(res.isOk())
- out = res.getValue()
- self.assertTrue(" - config" in out)
- self.assertTrue(" - prepare" in out)
- self.assertTrue(" - compile" in out)
-
- def test_011(self):
- logger = LOG.getUnittestLogger()
- cmd = "--help"
- s = SAT.Sat(logger)
- returnCode = s.execute_cli(cmd)
- self.assertTrue(returnCode.isOk())
- logs = logger.getLogs()
- DBG.write("test_011 logger", logs)
- self.assertTrue(" - config" in logs)
- self.assertTrue(" - prepare" in logs)
- self.assertTrue(" - compile" in logs)
-
- def test_030(self):
- cmd = "sat config --help"
- returnCode = SAT.launchSat(cmd)
- self.assertTrue(returnCode.isOk())
- out = returnCode.getValue()
- DBG.write("test_030 stdout", out)
- self.assertTrue("--value" in out)
-
- def test_031(self):
- logger = LOG.getUnittestLogger()
- cmd = "config --help"
- s = SAT.Sat(logger)
- returnCode = s.execute_cli(cmd)
- self.assertTrue(returnCode.isOk())
- logs = logger.getLogs()
- DBG.write("test_031 logger", logs)
- self.assertTrue("--help" in logs)
-
- def test_032(self):
- logger = LOG.getUnittestLogger()
- cmd = "prepare --help"
- s = SAT.Sat(logger)
- returnCode = s.execute_cli(cmd)
- self.assertTrue(returnCode.isOk())
- logs = logger.getLogs()
- DBG.write("test_031 logger", logs)
- self.assertTrue("--help" in logs)
-
- def test_040(self):
- logger = LOG.getUnittestLogger()
- cmd = "config --list"
- s = SAT.Sat(logger)
- returnCode = s.execute_cli(cmd)
- self.assertTrue(returnCode.isOk())
- logs = logger.getLogs()
- self.assertTrue("Applications" in logs)
-
- def test_050(self):
- cmds = SAT.getCommandsList()
- DBG.write("test_050 getCommandsList", cmds)
- for c in cmds:
- cmd = "sat %s --help" % c
- DBG.write("test_050", cmd)
- returnCode = SAT.launchSat(cmd)
- if not returnCode.isOk():
- DBG.write("test_050 %s" % cmd, returnCode.getValue(), True)
- self.assertTrue(returnCode.isOk())
- out = returnCode.getValue()
- DBG.write("test_050 %s stdout" % c, out)
- self.assertTrue("The %s command" % c in out)
- self.assertTrue("Available options" in out)
-
- def test_051(self):
- logger = LOG.getUnittestLogger()
- cmds = SAT.getCommandsList()
- for c in cmds:
- cmd = "%s --help" % c
- DBG.write("test_051", cmd)
- s = SAT.Sat(logger)
- returnCode = s.execute_cli(cmd)
- self.assertTrue(returnCode.isOk())
- logs = logger.getLogsAndClear()
- DBG.write(cmd, logs)
- self.assertTrue("The %s command" % c in logs)
- self.assertTrue("Available options" in logs)
-
-if __name__ == '__main__':
+ "Test the sat --help commands" ""
+
+ debug = False
+
+ def tearDown(self):
+ # print "tearDown", __file__
+ # assure self.logger clear for next test
+ logger = LOG.getUnittestLogger()
+ logs = logger.getLogsAndClear()
+ # using assertNotIn() is too much verbose
+ self.assertFalse("ERROR" in logs)
+ self.assertFalse("CRITICAL" in logs)
+
+ def test_000(self):
+ logger = LOG.getUnittestLogger()
+ # one shot setUp() for this TestCase
+ if self.debug:
+ DBG.push_debug(True)
+ SAT.setNotLocale() # test english
+
+ def test_999(self):
+ # one shot tearDown() for this TestCase
+ SAT.setLocale() # end test english
+ if self.debug:
+ DBG.pop_debug()
+
+ def test_010(self): # TODO fix logger unittest
+ cmd = "sat --help"
+ res = SAT.launchSat(cmd)
+ self.assertTrue(res.isOk())
+ out = res.getValue()
+ self.assertTrue(" - config" in out)
+ self.assertTrue(" - prepare" in out)
+ self.assertTrue(" - compile" in out)
+
+ def test_011(self):
+ logger = LOG.getUnittestLogger()
+ cmd = "--help"
+ s = SAT.Sat(logger)
+ returnCode = s.execute_cli(cmd)
+ self.assertTrue(returnCode.isOk())
+ logs = logger.getLogs()
+ DBG.write("test_011 logger", logs)
+ self.assertTrue(" - config" in logs)
+ self.assertTrue(" - prepare" in logs)
+ self.assertTrue(" - compile" in logs)
+
+ def test_030(self):
+ cmd = "sat config --help"
+ returnCode = SAT.launchSat(cmd)
+ self.assertTrue(returnCode.isOk())
+ out = returnCode.getValue()
+ DBG.write("test_030 stdout", out)
+ self.assertTrue("--value" in out)
+
+ def test_031(self):
+ logger = LOG.getUnittestLogger()
+ cmd = "config --help"
+ s = SAT.Sat(logger)
+ returnCode = s.execute_cli(cmd)
+ self.assertTrue(returnCode.isOk())
+ logs = logger.getLogs()
+ DBG.write("test_031 logger", logs)
+ self.assertTrue("--help" in logs)
+
+ def test_032(self):
+ logger = LOG.getUnittestLogger()
+ cmd = "prepare --help"
+ s = SAT.Sat(logger)
+ returnCode = s.execute_cli(cmd)
+ self.assertTrue(returnCode.isOk())
+ logs = logger.getLogs()
+ DBG.write("test_031 logger", logs)
+ self.assertTrue("--help" in logs)
+
+ def test_040(self):
+ logger = LOG.getUnittestLogger()
+ cmd = "config --list"
+ s = SAT.Sat(logger)
+ returnCode = s.execute_cli(cmd)
+ self.assertTrue(returnCode.isOk())
+ logs = logger.getLogs()
+ self.assertTrue("Applications" in logs)
+
+ def test_050(self):
+ cmds = SAT.getCommandsList()
+ DBG.write("test_050 getCommandsList", cmds)
+ for c in cmds:
+ cmd = "sat %s --help" % c
+ DBG.write("test_050", cmd)
+ returnCode = SAT.launchSat(cmd)
+ if not returnCode.isOk():
+ DBG.write("test_050 %s" % cmd, returnCode.getValue(), True)
+ self.assertTrue(returnCode.isOk())
+ out = returnCode.getValue()
+ DBG.write("test_050 %s stdout" % c, out)
+ self.assertTrue("The %s command" % c in out)
+ self.assertTrue("Available options" in out)
+
+ def test_051(self):
+ logger = LOG.getUnittestLogger()
+ cmds = SAT.getCommandsList()
+ for c in cmds:
+ cmd = "%s --help" % c
+ DBG.write("test_051", cmd)
+ s = SAT.Sat(logger)
+ returnCode = s.execute_cli(cmd)
+ self.assertTrue(returnCode.isOk())
+ logs = logger.getLogsAndClear()
+ DBG.write(cmd, logs)
+ self.assertTrue("The %s command" % c in logs)
+ self.assertTrue("Available options" in logs)
+
+
+if __name__ == "__main__":
unittest.main(exit=False)
pass
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2018 CEA/DEN
#
import sys
import unittest
-import initializeTest # set PATH etc for test
+import initializeTest # set PATH etc for test
import src.salomeTools as SAT
-import src.debug as DBG # Easy print stderr (for DEBUG only)
+import src.debug as DBG # Easy print stderr (for DEBUG only)
import src.loggingSimple as LOG
+
class TestCase(unittest.TestCase):
- "Test the sat commands on APPLI_TEST configuration pyconf etc. files"""
-
- debug = False
-
- # see test_100, # commands are expected OK
- TRG = "APPLI_TEST" # "SALOME-8.4.0"
- satCommandsToTestOk = [
- "config -l",
- "config -v .",
- "config -g .",
- "config %s --value ." % TRG,
- "config %s --debug ." % TRG,
- "config %s --info KERNEL" % TRG,
- "config %s --show_patchs" % TRG,
- ]
- # see test_110, # commands are expected KO
- satCommandsToTestKo = [
- "config %s --info oops" % TRG,
- "config --oops",
- ]
- # see test_120, # commands are expected Raise,
- # but if fixed go to satCommandsToTestKo
- satCommandsToTestRaise = [
- "oopsconfig --oops .",
- ]
-
- def tearDown(self):
- # print "tearDown", __file__
- # assure self.logger clear for next test
- logger = LOG.getUnittestLogger()
- logs = logger.getLogsAndClear()
- # using assertNotIn() is too much verbose
- self.assertFalse("ERROR ::" in logs)
- self.assertFalse("CRITICAL ::" in logs)
-
- def test_000(self):
- logger = LOG.getUnittestLogger()
- # one shot setUp() for this TestCase
- if self.debug: DBG.push_debug(True)
- SAT.setNotLocale() # test english
-
- def test_999(self):
- # one shot tearDown() for this TestCase
- SAT.setLocale() # end test english
- if self.debug: DBG.pop_debug()
-
- def test_010(self):
- logger = LOG.getUnittestLogger()
- DBG.write("test_010 logger", logger.name)
- cmd = "config -l"
- s = SAT.Sat(logger)
- DBG.write("s.getConfig()", s.getConfig()) #none
- DBG.write("s.__dict__", s.__dict__) # have
- returnCode = s.execute_cli(cmd)
- DBG.write("test_010", returnCode)
- logs = logger.getLogs()
- DBG.write("test_010 logger", logs)
- self.assertTrue(returnCode.isOk())
-
- def xtest_100(self): # TODO
- # test all satCommands expected OK
- logger = LOG.getUnittestLogger()
- dbg = self.debug
- for cmd in self.satCommandsToTestOk:
- s = SAT.Sat(logger)
- returnCode = s.execute_cli(cmd)
- DBG.write("test_100 'sat %s'" % cmd, str(returnCode), dbg)
- logs = logger.getLogsAndClear()
- DBG.write("logs", logs, dbg)
- # using assertNotIn() is too much verbose
- self.assertFalse("ERROR ::" in logs)
- self.assertFalse("CRITICAL ::" in logs)
-
- def test_110(self):
- # test all satCommands expected KO
- logger = LOG.getUnittestLogger()
- dbg = self.debug
- for cmd in self.satCommandsToTestKo:
- s = SAT.Sat(logger)
- returnCode = s.execute_cli(cmd)
- DBG.write("test_110 'sat %s'" % cmd, returnCode, dbg)
- logs = logger.getLogsAndClear()
- DBG.write("logs", logs, dbg)
-
- def test_120(self):
- # test all satCommands expected raise
- logger = LOG.getUnittestLogger()
- dbg = self.debug
- for cmd in self.satCommandsToTestRaise:
- s = SAT.Sat(logger)
- DBG.write("test_120 'sat %s'" % cmd, "expected raise", dbg)
- with self.assertRaises(Exception):
+ "Test the sat commands on APPLI_TEST configuration pyconf etc. files" ""
+
+ debug = False
+
+ # see test_100, # commands are expected OK
+ TRG = "APPLI_TEST" # "SALOME-8.4.0"
+ satCommandsToTestOk = [
+ "config -l",
+ "config -v .",
+ "config -g .",
+ "config %s --value ." % TRG,
+ "config %s --debug ." % TRG,
+ "config %s --info KERNEL" % TRG,
+ "config %s --show_patchs" % TRG,
+ ]
+ # see test_110, # commands are expected KO
+ satCommandsToTestKo = [
+ "config %s --info oops" % TRG,
+ "config --oops",
+ ]
+ # see test_120, # commands are expected Raise,
+ # but if fixed go to satCommandsToTestKo
+ satCommandsToTestRaise = [
+ "oopsconfig --oops .",
+ ]
+
+ def tearDown(self):
+ # print "tearDown", __file__
+ # assure self.logger clear for next test
+ logger = LOG.getUnittestLogger()
+ logs = logger.getLogsAndClear()
+ # using assertNotIn() is too much verbose
+ self.assertFalse("ERROR ::" in logs)
+ self.assertFalse("CRITICAL ::" in logs)
+
+ def test_000(self):
+ logger = LOG.getUnittestLogger()
+ # one shot setUp() for this TestCase
+ if self.debug:
+ DBG.push_debug(True)
+ SAT.setNotLocale() # test english
+
+ def test_999(self):
+ # one shot tearDown() for this TestCase
+ SAT.setLocale() # end test english
+ if self.debug:
+ DBG.pop_debug()
+
+ def test_010(self):
+ logger = LOG.getUnittestLogger()
+ DBG.write("test_010 logger", logger.name)
+ cmd = "config -l"
+ s = SAT.Sat(logger)
+ DBG.write("s.getConfig()", s.getConfig()) # none
+ DBG.write("s.__dict__", s.__dict__) # have
returnCode = s.execute_cli(cmd)
- logs = logger.getLogsAndClear()
- DBG.write("logs", logs, dbg)
-
-
-if __name__ == '__main__':
+ DBG.write("test_010", returnCode)
+ logs = logger.getLogs()
+ DBG.write("test_010 logger", logs)
+ self.assertTrue(returnCode.isOk())
+
+ def xtest_100(self): # TODO
+ # test all satCommands expected OK
+ logger = LOG.getUnittestLogger()
+ dbg = self.debug
+ for cmd in self.satCommandsToTestOk:
+ s = SAT.Sat(logger)
+ returnCode = s.execute_cli(cmd)
+ DBG.write("test_100 'sat %s'" % cmd, str(returnCode), dbg)
+ logs = logger.getLogsAndClear()
+ DBG.write("logs", logs, dbg)
+ # using assertNotIn() is too much verbose
+ self.assertFalse("ERROR ::" in logs)
+ self.assertFalse("CRITICAL ::" in logs)
+
+ def test_110(self):
+ # test all satCommands expected KO
+ logger = LOG.getUnittestLogger()
+ dbg = self.debug
+ for cmd in self.satCommandsToTestKo:
+ s = SAT.Sat(logger)
+ returnCode = s.execute_cli(cmd)
+ DBG.write("test_110 'sat %s'" % cmd, returnCode, dbg)
+ logs = logger.getLogsAndClear()
+ DBG.write("logs", logs, dbg)
+
+ def test_120(self):
+ # test all satCommands expected raise
+ logger = LOG.getUnittestLogger()
+ dbg = self.debug
+ for cmd in self.satCommandsToTestRaise:
+ s = SAT.Sat(logger)
+ DBG.write("test_120 'sat %s'" % cmd, "expected raise", dbg)
+ with self.assertRaises(Exception):
+ returnCode = s.execute_cli(cmd)
+ logs = logger.getLogsAndClear()
+ DBG.write("logs", logs, dbg)
+
+
+if __name__ == "__main__":
unittest.main(exit=False)
pass
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2018 CEA/DEN
#
verbose = False
+
class TestCase(unittest.TestCase):
- "Test a paramiko connection"""
-
- def setLoggerParamiko(self):
- """to get logs of paramiko, useful if problems"""
- import logging as LOGI
- loggerPrmk = LOGI.getLogger("paramiko")
- if len(loggerPrmk.handlers) != 0:
- print("logging.__file__ %s" % LOGI.__file__)
- print("logger paramiko have handler set yet, is a surprise")
- return
- if not verbose:
- # stay as it, null
- return
-
- #set a paramiko logger verbose
- handler = LOGI.StreamHandler()
- msg = "create paramiko logger, with handler on stdout"
-
- # handler = LOGI.MemoryHandler()
- # etc... https://docs.python.org/2/library/logging.handlers.html
- # msg = "create paramiko logger, with handler in memory"
-
- # original frm from paramiko
- # frm = '%(levelname)-.3s [%(asctime)s.%(msecs)03d] thr=%(thread)-3d %(name)s: %(message)s' # noqa
- frm = '%(levelname)-5s :: %(asctime)s :: %(name)s :: %(message)s'
- handler.setFormatter(LOGI.Formatter(frm, '%y%m%d_%H%M%S'))
- loggerPrmk.addHandler(handler)
-
- # logger is not notset but low, handlers needs setlevel greater
- loggerPrmk.setLevel(LOGI.DEBUG)
- handler.setLevel(LOGI.INFO) # LOGI.DEBUG) # may be other one
-
- loggerPrmk.info(msg)
-
-
- '''example from internet
+ "Test a paramiko connection" ""
+
+ def setLoggerParamiko(self):
+ """to get logs of paramiko, useful if problems"""
+ import logging as LOGI
+
+ loggerPrmk = LOGI.getLogger("paramiko")
+ if len(loggerPrmk.handlers) != 0:
+ print("logging.__file__ %s" % LOGI.__file__)
+ print("logger paramiko have handler set yet, is a surprise")
+ return
+ if not verbose:
+ # stay as it, null
+ return
+
+ # set a paramiko logger verbose
+ handler = LOGI.StreamHandler()
+ msg = "create paramiko logger, with handler on stdout"
+
+ # handler = LOGI.MemoryHandler()
+ # etc... https://docs.python.org/2/library/logging.handlers.html
+ # msg = "create paramiko logger, with handler in memory"
+
+ # original frm from paramiko
+ # frm = '%(levelname)-.3s [%(asctime)s.%(msecs)03d] thr=%(thread)-3d %(name)s: %(message)s' # noqa
+ frm = "%(levelname)-5s :: %(asctime)s :: %(name)s :: %(message)s"
+ handler.setFormatter(LOGI.Formatter(frm, "%y%m%d_%H%M%S"))
+ loggerPrmk.addHandler(handler)
+
+ # logger is not notset but low, handlers needs setlevel greater
+ loggerPrmk.setLevel(LOGI.DEBUG)
+ handler.setLevel(LOGI.INFO) # LOGI.DEBUG) # may be other one
+
+ loggerPrmk.info(msg)
+
+ """example from internet
def fetch_netmask(self, hostname, port=22):
private_key = os.path.expanduser('~/.ssh/id_rsa')
connection = open_ssh_connection('wambeke', hostname, port=port, key=private_key)
client.set_missing_host_key_policy(PK.AutoAddPolicy())
client.connect(hostname, port=port, timeout=5, username=username, key_filename=key)
return client
- '''
-
- def test_000(self):
- self.setLoggerParamiko()
-
-
- def test_010(self):
- # http://docs.paramiko.org/en/2.4/api/agent.html
-
- try:
- import paramiko as PK
- except:
- print("\nproblem 'import paramiko', no tests")
- return
-
- # port=22 # useless
- username = getpass.getuser()
- hostname = os.uname()[1]
- aFile = "/tmp/%s_test_paramiko.tmp" % username
- cmd = ("pwd; ls -alt {0}; cat {0}").format(aFile)
-
- # connect
- client = PK.SSHClient()
- client.set_missing_host_key_policy(PK.AutoAddPolicy())
- # client.connect(hostname, username=username, password="xxxxx")
- # client.connect(hostname, username=username, passphrase="yyyy", key_filename="/home/wambeke/.ssh/id_rsa_satjobs_passphrase")
- # client.connect(hostname, username=username)
-
- # timeout in seconds
- client.connect(hostname, username=username, timeout=1.)
-
- # obtain session
- session = client.get_transport().open_session()
- # Forward local agent
- PK.agent.AgentRequestHandler(session)
- # commands executed after this point will see the forwarded agent on the remote end.
-
- # one api
- session.exec_command("date > %s" % aFile)
- cmd = ("pwd; ls -alt {0}; cat {0} && echo OK").format(aFile)
- # another api
- stdin, stdout, stderr = client.exec_command(cmd)
- output = stdout.read()
- if verbose:
- print('stdout:\n%s' % output)
- self.assertTrue(aFile in output)
- self.assertTrue("OK" in output)
- client.close()
-
-if __name__ == '__main__':
+ """
+
+ def test_000(self):
+ self.setLoggerParamiko()
+
+ def test_010(self):
+ # http://docs.paramiko.org/en/2.4/api/agent.html
+
+ try:
+ import paramiko as PK
+ except:
+ print("\nproblem 'import paramiko', no tests")
+ return
+
+ # port=22 # useless
+ username = getpass.getuser()
+ hostname = os.uname()[1]
+ aFile = "/tmp/%s_test_paramiko.tmp" % username
+ cmd = ("pwd; ls -alt {0}; cat {0}").format(aFile)
+
+ # connect
+ client = PK.SSHClient()
+ client.set_missing_host_key_policy(PK.AutoAddPolicy())
+ # client.connect(hostname, username=username, password="xxxxx")
+ # client.connect(hostname, username=username, passphrase="yyyy", key_filename="/home/wambeke/.ssh/id_rsa_satjobs_passphrase")
+ # client.connect(hostname, username=username)
+
+ # timeout in seconds
+ client.connect(hostname, username=username, timeout=1.0)
+
+ # obtain session
+ session = client.get_transport().open_session()
+ # Forward local agent
+ PK.agent.AgentRequestHandler(session)
+ # commands executed after this point will see the forwarded agent on the remote end.
+
+ # one api
+ session.exec_command("date > %s" % aFile)
+ cmd = ("pwd; ls -alt {0}; cat {0} && echo OK").format(aFile)
+ # another api
+ stdin, stdout, stderr = client.exec_command(cmd)
+ output = stdout.read()
+ if verbose:
+ print("stdout:\n%s" % output)
+ self.assertTrue(aFile in output)
+ self.assertTrue("OK" in output)
+ client.close()
+
+
+if __name__ == "__main__":
# verbose = True # human eyes
unittest.main(exit=False)
pass
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2018 CEA/DEN
#
import src.product
from src.salomeTools import Sat
+
class TestCase(unittest.TestCase):
"""Test of the compile command"""
def test_010(self):
# Test the compile command with '--products' option
- OK = 'KO'
+ OK = "KO"
- appli = 'appli-test'
- product_name = 'PRODUCT_GIT'
+ appli = "appli-test"
+ product_name = "PRODUCT_GIT"
sat = Sat()
-
- sat.prepare(appli + ' --product ' + product_name)
- expected_install_dir = src.product.get_product_config(sat.cfg, product_name).install_dir
- expected_file_path = os.path.join(expected_install_dir, 'bin/hello')
-
- sat.clean(appli + ' --build --install --product ' + product_name, batch=True)
- sat.compile(appli + ' --product ' + product_name)
-
+
+ sat.prepare(appli + " --product " + product_name)
+ expected_install_dir = src.product.get_product_config(
+ sat.cfg, product_name
+ ).install_dir
+ expected_file_path = os.path.join(expected_install_dir, "bin/hello")
+
+ sat.clean(appli + " --build --install --product " + product_name, batch=True)
+ sat.compile(appli + " --product " + product_name)
+
if os.path.exists(expected_file_path):
- OK = 'OK'
+ OK = "OK"
# pyunit method to compare 2 str
- self.assertEqual(OK, 'OK')
+ self.assertEqual(OK, "OK")
def test_020(self):
# Test the configure command with '--fathers' option
- OK = 'KO'
+ OK = "KO"
- appli = 'appli-test'
- product_name = 'PRODUCT_GIT'
- product_name2 = 'PRODUCT_ARCHIVE'
+ appli = "appli-test"
+ product_name = "PRODUCT_GIT"
+ product_name2 = "PRODUCT_ARCHIVE"
sat = Sat()
-
- sat.prepare(appli + ' --product ' + product_name +"," +product_name2)
- expected_install_dir = src.product.get_product_config(sat.cfg, product_name).install_dir
- expected_file_path = os.path.join(expected_install_dir, 'bin/hello')
- expected_install_dir2 = src.product.get_product_config(sat.cfg, product_name2).install_dir
- expected_file_path2 = os.path.join(expected_install_dir2, 'bin/hello-archive')
-
- sat.clean(appli + ' --build --install --product ' + product_name +"," +product_name2, batch=True)
- sat.compile(appli + ' --with_fathers --product ' + product_name)
-
+
+ sat.prepare(appli + " --product " + product_name + "," + product_name2)
+ expected_install_dir = src.product.get_product_config(
+ sat.cfg, product_name
+ ).install_dir
+ expected_file_path = os.path.join(expected_install_dir, "bin/hello")
+ expected_install_dir2 = src.product.get_product_config(
+ sat.cfg, product_name2
+ ).install_dir
+ expected_file_path2 = os.path.join(expected_install_dir2, "bin/hello-archive")
+
+ sat.clean(
+ appli
+ + " --build --install --product "
+ + product_name
+ + ","
+ + product_name2,
+ batch=True,
+ )
+ sat.compile(appli + " --with_fathers --product " + product_name)
+
if os.path.exists(expected_file_path) and os.path.exists(expected_file_path2):
- OK = 'OK'
+ OK = "OK"
# pyunit method to compare 2 str
- self.assertEqual(OK, 'OK')
-
+ self.assertEqual(OK, "OK")
+
def test_030(self):
# Test the configure command with '--children' option
- OK = 'KO'
+ OK = "KO"
- appli = 'appli-test'
- product_name = 'PRODUCT_GIT'
- product_name2 = 'PRODUCT_ARCHIVE'
+ appli = "appli-test"
+ product_name = "PRODUCT_GIT"
+ product_name2 = "PRODUCT_ARCHIVE"
sat = Sat()
-
- sat.prepare(appli + ' --product ' + product_name +"," +product_name2)
- expected_install_dir = src.product.get_product_config(sat.cfg, product_name).install_dir
- expected_file_path = os.path.join(expected_install_dir, 'bin/hello')
- expected_install_dir2 = src.product.get_product_config(sat.cfg, product_name2).install_dir
- expected_file_path2 = os.path.join(expected_install_dir2, 'bin/hello-archive')
-
- sat.clean(appli + ' --build --install --product ' + product_name +"," +product_name2, batch=True)
- sat.compile(appli + ' --with_children --product ' + product_name2)
-
+
+ sat.prepare(appli + " --product " + product_name + "," + product_name2)
+ expected_install_dir = src.product.get_product_config(
+ sat.cfg, product_name
+ ).install_dir
+ expected_file_path = os.path.join(expected_install_dir, "bin/hello")
+ expected_install_dir2 = src.product.get_product_config(
+ sat.cfg, product_name2
+ ).install_dir
+ expected_file_path2 = os.path.join(expected_install_dir2, "bin/hello-archive")
+
+ sat.clean(
+ appli
+ + " --build --install --product "
+ + product_name
+ + ","
+ + product_name2,
+ batch=True,
+ )
+ sat.compile(appli + " --with_children --product " + product_name2)
+
if os.path.exists(expected_file_path) and os.path.exists(expected_file_path2):
- OK = 'OK'
+ OK = "OK"
# pyunit method to compare 2 str
- self.assertEqual(OK, 'OK')
+ self.assertEqual(OK, "OK")
def test_040(self):
# Test the configure command with '--clean_all' option
- OK = 'KO'
+ OK = "KO"
- appli = 'appli-test'
- product_name = 'PRODUCT_GIT'
- product_name2 = 'PRODUCT_ARCHIVE'
+ appli = "appli-test"
+ product_name = "PRODUCT_GIT"
+ product_name2 = "PRODUCT_ARCHIVE"
sat = Sat()
-
- sat.prepare(appli + ' --product ' + product_name +"," +product_name2)
- expected_install_dir = src.product.get_product_config(sat.cfg, product_name).install_dir
- expected_file_path = os.path.join(expected_install_dir, 'bin/hello')
- expected_install_dir2 = src.product.get_product_config(sat.cfg, product_name2).install_dir
- expected_file_path2 = os.path.join(expected_install_dir2, 'bin/hello-archive')
-
- sat.compile(appli + ' --with_children --product ' + product_name2)
-
- sat.compile(appli + ' --clean_all --with_children --product ' + product_name2, batch=True)
-
+
+ sat.prepare(appli + " --product " + product_name + "," + product_name2)
+ expected_install_dir = src.product.get_product_config(
+ sat.cfg, product_name
+ ).install_dir
+ expected_file_path = os.path.join(expected_install_dir, "bin/hello")
+ expected_install_dir2 = src.product.get_product_config(
+ sat.cfg, product_name2
+ ).install_dir
+ expected_file_path2 = os.path.join(expected_install_dir2, "bin/hello-archive")
+
+ sat.compile(appli + " --with_children --product " + product_name2)
+
+ sat.compile(
+ appli + " --clean_all --with_children --product " + product_name2,
+ batch=True,
+ )
+
if os.path.exists(expected_file_path) and os.path.exists(expected_file_path2):
- OK = 'OK'
+ OK = "OK"
# pyunit method to compare 2 str
- self.assertEqual(OK, 'OK')
+ self.assertEqual(OK, "OK")
def test_050(self):
# Test the configure command with '--clean_install' option
- OK = 'KO'
+ OK = "KO"
- appli = 'appli-test'
- product_name = 'PRODUCT_GIT'
- product_name2 = 'PRODUCT_ARCHIVE'
+ appli = "appli-test"
+ product_name = "PRODUCT_GIT"
+ product_name2 = "PRODUCT_ARCHIVE"
sat = Sat()
-
- sat.prepare(appli + ' --product ' + product_name +"," +product_name2)
- expected_install_dir = src.product.get_product_config(sat.cfg, product_name).install_dir
- expected_file_path = os.path.join(expected_install_dir, 'bin/hello')
- expected_install_dir2 = src.product.get_product_config(sat.cfg, product_name2).install_dir
- expected_file_path2 = os.path.join(expected_install_dir2, 'bin/hello-archive')
-
- sat.compile(appli + ' --with_children --product ' + product_name2)
-
- sat.compile(appli + ' --clean_install --with_children --product ' + product_name2, batch=True)
-
+
+ sat.prepare(appli + " --product " + product_name + "," + product_name2)
+ expected_install_dir = src.product.get_product_config(
+ sat.cfg, product_name
+ ).install_dir
+ expected_file_path = os.path.join(expected_install_dir, "bin/hello")
+ expected_install_dir2 = src.product.get_product_config(
+ sat.cfg, product_name2
+ ).install_dir
+ expected_file_path2 = os.path.join(expected_install_dir2, "bin/hello-archive")
+
+ sat.compile(appli + " --with_children --product " + product_name2)
+
+ sat.compile(
+ appli + " --clean_install --with_children --product " + product_name2,
+ batch=True,
+ )
+
if os.path.exists(expected_file_path) and os.path.exists(expected_file_path2):
- OK = 'OK'
+ OK = "OK"
# pyunit method to compare 2 str
- self.assertEqual(OK, 'OK')
+ self.assertEqual(OK, "OK")
def test_060(self):
# Test the configure command with '--make_flags' option
- OK = 'KO'
+ OK = "KO"
- appli = 'appli-test'
- product_name = 'PRODUCT_GIT'
+ appli = "appli-test"
+ product_name = "PRODUCT_GIT"
sat = Sat()
-
- sat.prepare(appli + ' --product ' + product_name)
- expected_install_dir = src.product.get_product_config(sat.cfg, product_name).install_dir
- expected_file_path = os.path.join(expected_install_dir, 'bin/hello')
-
- sat.clean(appli + ' --build --install --product ' + product_name, batch=True)
- sat.compile(appli + ' --make_flags 3 --product ' + product_name)
-
+
+ sat.prepare(appli + " --product " + product_name)
+ expected_install_dir = src.product.get_product_config(
+ sat.cfg, product_name
+ ).install_dir
+ expected_file_path = os.path.join(expected_install_dir, "bin/hello")
+
+ sat.clean(appli + " --build --install --product " + product_name, batch=True)
+ sat.compile(appli + " --make_flags 3 --product " + product_name)
+
if os.path.exists(expected_file_path):
- OK = 'OK'
+ OK = "OK"
# pyunit method to compare 2 str
- self.assertEqual(OK, 'OK')
+ self.assertEqual(OK, "OK")
def test_070(self):
# Test the configure command with '--show' option
- OK = 'KO'
+ OK = "KO"
- appli = 'appli-test'
- product_name = 'PRODUCT_GIT'
+ appli = "appli-test"
+ product_name = "PRODUCT_GIT"
sat = Sat()
-
- sat.prepare(appli + ' --product ' + product_name)
- expected_install_dir = src.product.get_product_config(sat.cfg, product_name).install_dir
- expected_file_path = os.path.join(expected_install_dir, 'bin/hello')
-
- sat.clean(appli + ' --build --install --product ' + product_name, batch=True)
- sat.compile(appli + ' --show --product ' + product_name)
-
- if not(os.path.exists(expected_file_path)):
- OK = 'OK'
+
+ sat.prepare(appli + " --product " + product_name)
+ expected_install_dir = src.product.get_product_config(
+ sat.cfg, product_name
+ ).install_dir
+ expected_file_path = os.path.join(expected_install_dir, "bin/hello")
+
+ sat.clean(appli + " --build --install --product " + product_name, batch=True)
+ sat.compile(appli + " --show --product " + product_name)
+
+ if not (os.path.exists(expected_file_path)):
+ OK = "OK"
# pyunit method to compare 2 str
- self.assertEqual(OK, 'OK')
+ self.assertEqual(OK, "OK")
def test_080(self):
# Test the configure command with '--stop_first_fail' option
- OK = 'KO'
+ OK = "KO"
- appli = 'appli-test'
+ appli = "appli-test"
sat = Sat()
-
- sat.prepare(appli + ' --product PRODUCT_CVS,Python')
- expected_install_dir = src.product.get_product_config(sat.cfg, "PRODUCT_CVS").install_dir
-
- sat.clean(appli + ' --build --install --product PRODUCT_CVS', batch=True)
- sat.compile(appli + ' --stop_first_fail --product PRODUCT_CVS,Python')
-
- if not(os.path.exists(expected_install_dir)):
- OK = 'OK'
+
+ sat.prepare(appli + " --product PRODUCT_CVS,Python")
+ expected_install_dir = src.product.get_product_config(
+ sat.cfg, "PRODUCT_CVS"
+ ).install_dir
+
+ sat.clean(appli + " --build --install --product PRODUCT_CVS", batch=True)
+ sat.compile(appli + " --stop_first_fail --product PRODUCT_CVS,Python")
+
+ if not (os.path.exists(expected_install_dir)):
+ OK = "OK"
# pyunit method to compare 2 str
- self.assertEqual(OK, 'OK')
+ self.assertEqual(OK, "OK")
def test_090(self):
- # Test the 'sat -h compile' command to get description
+ # Test the 'sat -h compile' command to get description
OK = "KO"
import compile
-
+
if "The compile command constructs the products" in compile.description():
OK = "OK"
# pyunit method to compare 2 str
self.assertEqual(OK, "OK")
+
# test launch
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
pass
-
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2018 CEA/DEN
#
import src.product
from src.salomeTools import Sat
+
class TestCase(unittest.TestCase):
"""Test of the configure command"""
def test_010(self):
# Test the configure command with a product in cmake
- OK = 'KO'
+ OK = "KO"
- appli = 'appli-test'
- product_name = 'PRODUCT_GIT'
+ appli = "appli-test"
+ product_name = "PRODUCT_GIT"
sat = Sat()
-
- sat.prepare(appli + ' --product ' + product_name)
- expected_build_dir = src.product.get_product_config(sat.cfg, product_name).build_dir
- expected_file_path = os.path.join(expected_build_dir, 'CMakeCache.txt')
-
- sat.configure(appli + ' --product ' + product_name)
-
+
+ sat.prepare(appli + " --product " + product_name)
+ expected_build_dir = src.product.get_product_config(
+ sat.cfg, product_name
+ ).build_dir
+ expected_file_path = os.path.join(expected_build_dir, "CMakeCache.txt")
+
+ sat.configure(appli + " --product " + product_name)
+
if os.path.exists(os.path.join(expected_build_dir, expected_file_path)):
- OK = 'OK'
+ OK = "OK"
# pyunit method to compare 2 str
- self.assertEqual(OK, 'OK')
+ self.assertEqual(OK, "OK")
def test_020(self):
# Test the configure command with a product in autotools
- OK = 'KO'
+ OK = "KO"
- appli = 'appli-test'
- product_name = 'PRODUCT_CVS'
+ appli = "appli-test"
+ product_name = "PRODUCT_CVS"
sat = Sat()
-
- sat.prepare(appli + ' --product ' + product_name)
- expected_build_dir = src.product.get_product_config(sat.cfg, product_name).build_dir
- expected_file_path = os.path.join(expected_build_dir, 'config.log')
-
- sat.configure(appli + ' --product ' + product_name)
-
+
+ sat.prepare(appli + " --product " + product_name)
+ expected_build_dir = src.product.get_product_config(
+ sat.cfg, product_name
+ ).build_dir
+ expected_file_path = os.path.join(expected_build_dir, "config.log")
+
+ sat.configure(appli + " --product " + product_name)
+
if os.path.exists(os.path.join(expected_build_dir, expected_file_path)):
- OK = 'OK'
+ OK = "OK"
# pyunit method to compare 2 str
- self.assertEqual(OK, 'OK')
+ self.assertEqual(OK, "OK")
def test_030(self):
# Test the configure command with a product in script mode
- OK = 'KO'
+ OK = "KO"
- appli = 'appli-test'
- product_name = 'Python'
+ appli = "appli-test"
+ product_name = "Python"
sat = Sat()
-
- sat.prepare(appli + ' --product ' + product_name)
- expected_build_dir = src.product.get_product_config(sat.cfg, product_name).build_dir
-
- sat.configure(appli + ' --product ' + product_name)
-
+
+ sat.prepare(appli + " --product " + product_name)
+ expected_build_dir = src.product.get_product_config(
+ sat.cfg, product_name
+ ).build_dir
+
+ sat.configure(appli + " --product " + product_name)
+
if os.path.exists(expected_build_dir):
- OK = 'OK'
+ OK = "OK"
# pyunit method to compare 2 str
- self.assertEqual(OK, 'OK')
+ self.assertEqual(OK, "OK")
def test_040(self):
# Test the 'sat -h configure'
OK = "KO"
import configure
-
- if "The configure command executes in the build directory" in configure.description():
+
+ if (
+ "The configure command executes in the build directory"
+ in configure.description()
+ ):
OK = "OK"
# pyunit method to compare 2 str
self.assertEqual(OK, "OK")
+
# test launch
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
pass
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2018 CEA/DEN
#
import src.product
from src.salomeTools import Sat
+
class TestCase(unittest.TestCase):
"""Test of the make command"""
def test_010(self):
# Test the configure command without any option
- OK = 'KO'
+ OK = "KO"
- appli = 'appli-test'
- product_name = 'PRODUCT_GIT'
+ appli = "appli-test"
+ product_name = "PRODUCT_GIT"
sat = Sat()
-
- sat.prepare(appli + ' --product ' + product_name)
- expected_build_dir = src.product.get_product_config(sat.cfg, product_name).build_dir
- expected_file_path = os.path.join(expected_build_dir, 'hello')
-
- sat.configure(appli + ' --product ' + product_name)
- sat.make(appli + ' --product ' + product_name)
-
+
+ sat.prepare(appli + " --product " + product_name)
+ expected_build_dir = src.product.get_product_config(
+ sat.cfg, product_name
+ ).build_dir
+ expected_file_path = os.path.join(expected_build_dir, "hello")
+
+ sat.configure(appli + " --product " + product_name)
+ sat.make(appli + " --product " + product_name)
+
if os.path.exists(os.path.join(expected_build_dir, expected_file_path)):
- OK = 'OK'
+ OK = "OK"
# pyunit method to compare 2 str
- self.assertEqual(OK, 'OK')
+ self.assertEqual(OK, "OK")
def test_020(self):
# Test the make command with an option
- OK = 'KO'
- appli = 'appli-test'
- product_name = 'PRODUCT_GIT'
+ OK = "KO"
+ appli = "appli-test"
+ product_name = "PRODUCT_GIT"
sat = Sat()
-
- sat.prepare(appli + ' --product ' + product_name)
- expected_build_dir = src.product.get_product_config(sat.cfg, product_name).build_dir
- expected_file_path = os.path.join(expected_build_dir, 'hello')
-
- sat.configure(appli + ' --product ' + product_name)
- sat.make(appli + ' --product ' + product_name + ' --option -j3')
-
+
+ sat.prepare(appli + " --product " + product_name)
+ expected_build_dir = src.product.get_product_config(
+ sat.cfg, product_name
+ ).build_dir
+ expected_file_path = os.path.join(expected_build_dir, "hello")
+
+ sat.configure(appli + " --product " + product_name)
+ sat.make(appli + " --product " + product_name + " --option -j3")
+
if os.path.exists(os.path.join(expected_build_dir, expected_file_path)):
- OK = 'OK'
+ OK = "OK"
# pyunit method to compare 2 str
- self.assertEqual(OK, 'OK')
+ self.assertEqual(OK, "OK")
def test_030(self):
# Test the make command with a product in script mode
- OK = 'KO'
+ OK = "KO"
- appli = 'appli-test'
- product_name = 'Python'
+ appli = "appli-test"
+ product_name = "Python"
sat = Sat()
-
- sat.prepare(appli + ' --product ' + product_name)
- expected_install_dir = src.product.get_product_config(sat.cfg, product_name).install_dir
+
+ sat.prepare(appli + " --product " + product_name)
+ expected_install_dir = src.product.get_product_config(
+ sat.cfg, product_name
+ ).install_dir
expected_file = "bin/python2.7"
-
- sat.make(appli + ' --product ' + product_name)
-
+
+ sat.make(appli + " --product " + product_name)
+
if os.path.exists(os.path.join(expected_install_dir, expected_file)):
- OK = 'OK'
+ OK = "OK"
# pyunit method to compare 2 str
- self.assertEqual(OK, 'OK')
+ self.assertEqual(OK, "OK")
def test_040(self):
- # Test the sat -h make
+ # Test the sat -h make
OK = "KO"
import make
-
- if "The make command executes the \"make\" command" in make.description():
+
+ if 'The make command executes the "make" command' in make.description():
OK = "OK"
# pyunit method to compare 2 str
self.assertEqual(OK, "OK")
+
# test launch
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
pass
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2018 CEA/DEN
#
import src.product
from src.salomeTools import Sat
+
class TestMakeinstall(unittest.TestCase):
"""Test of the makeinstall command"""
def test_010(self):
# Test the configure-make-makeinstall command without any option
- OK = 'KO'
+ OK = "KO"
- appli = 'appli-test'
- product_name = 'PRODUCT_GIT'
+ appli = "appli-test"
+ product_name = "PRODUCT_GIT"
sat = Sat()
-
- sat.prepare(appli + ' --product ' + product_name)
- expected_install_dir = src.product.get_product_config(sat.cfg, product_name).install_dir
- expected_file_path = os.path.join(expected_install_dir, 'bin/hello')
-
- sat.configure(appli + ' --product ' + product_name)
-
- sat.make(appli + ' --product ' + product_name)
-
- sat.makeinstall(appli + ' --product ' + product_name)
-
+
+ sat.prepare(appli + " --product " + product_name)
+ expected_install_dir = src.product.get_product_config(
+ sat.cfg, product_name
+ ).install_dir
+ expected_file_path = os.path.join(expected_install_dir, "bin/hello")
+
+ sat.configure(appli + " --product " + product_name)
+
+ sat.make(appli + " --product " + product_name)
+
+ sat.makeinstall(appli + " --product " + product_name)
+
if os.path.exists(expected_file_path):
- OK = 'OK'
+ OK = "OK"
# pyunit method to compare 2 str
- self.assertEqual(OK, 'OK')
+ self.assertEqual(OK, "OK")
def test_020(self):
# Test the sat -h make
OK = "KO"
import makeinstall
-
- if "The makeinstall command executes the 'make install' command" in makeinstall.description():
+
+ if (
+ "The makeinstall command executes the 'make install' command"
+ in makeinstall.description()
+ ):
OK = "OK"
# pyunit method to compare 2 str
self.assertEqual(OK, "OK")
+
# test launch
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
pass
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2018 CEA/DEN
#
from src.salomeTools import Sat
+
class TestCase(unittest.TestCase):
"""sat config --copy"""
-
+
def test_010(self):
# Test the copy of a pyconf
res = "KO"
appli_to_copy = "appli-test"
- expected_file = os.path.expanduser(os.path.join('~','.salomeTools', 'Applications', 'LOCAL_' + appli_to_copy + '.pyconf'))
+ expected_file = os.path.expanduser(
+ os.path.join(
+ "~",
+ ".salomeTools",
+ "Applications",
+ "LOCAL_" + appli_to_copy + ".pyconf",
+ )
+ )
if os.path.exists(expected_file):
os.remove(expected_file)
-
+
# The command to test
- sat = Sat('')
- sat.config('appli-test -c')
+ sat = Sat("")
+ sat.config("appli-test -c")
if os.path.exists(expected_file):
res = "OK"
os.remove(expected_file)
self.assertEqual(res, "OK")
+
# test launch
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
pass
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2018 CEA/DEN
#
sleep_time = 2
+
class TestCase(unittest.TestCase):
"""sat config --edit"""
-
+
def test_010(self):
# Test the launch of the editor when invoking the config -e
OK = "KO"
sat = Sat("-oUSER.editor='cooledit'")
sat.config()
- cmd_config = threading.Thread(target=sat.config, args=('-e',))
+ cmd_config = threading.Thread(target=sat.config, args=("-e",))
cmd_config.start()
time.sleep(sleep_time)
editor = sat.cfg.USER.editor
- pid = check_proc_existence_and_kill_multi(editor + ".*" + "salomeTools\.pyconf", 10)
+ pid = check_proc_existence_and_kill_multi(
+ editor + ".*" + "salomeTools\.pyconf", 10
+ )
if pid:
OK = "OK"
sat = Sat("-oUSER.editor='cooledit'")
sat.config()
- cmd_config = threading.Thread(target=sat.config, args=('appli-test -e',))
+ cmd_config = threading.Thread(target=sat.config, args=("appli-test -e",))
cmd_config.start()
time.sleep(sleep_time)
editor = sat.cfg.USER.editor
- pid = check_proc_existence_and_kill_multi(editor + ".*" + "appli-test\.pyconf", 10)
+ pid = check_proc_existence_and_kill_multi(
+ editor + ".*" + "appli-test\.pyconf", 10
+ )
if pid:
OK = "OK"
self.assertEqual(OK, "OK")
-
+
+
# test launch
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
pass
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2018 CEA/DEN
#
from src.salomeTools import Sat
from unittestpy.tools import outRedirection
+
class TestCase(unittest.TestCase):
"""sat config --value"""
-
+
def test_010(self):
# Test the display of the right value of "sat config -v VARS.hostname"
OK = "KO"
# The command to test
sat = Sat()
- sat.config('-v VARS.hostname')
+ sat.config("-v VARS.hostname")
# stop output redirection
my_out.end_redirection()
# The command to test
sat = Sat()
- sat.config('-l')
+ sat.config("-l")
# stop output redirection
my_out.end_redirection()
if "ERROR" not in res:
OK = "OK"
self.assertEqual(OK, "OK")
-
+
"""
def test_030(self):
# Test the exception when salomeTools.pyconf has errors
shutil.copyfile(salomeToolspyconfPath_save, salomeToolspyconfPath)
os.remove(salomeToolspyconfPath_save)
self.assertEqual(OK, "OK")
- """
-
+ """
+
+
# test launch
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
pass
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2018 CEA/DEN
#
from src.salomeTools import Sat
from unittestpy.tools import outRedirection
+
class TestCase(unittest.TestCase):
"""sat config -v VARS.python"""
-
+
def test_010(self):
# Test the display of the right value of 'sat config -v VARS.python'
- OK = 'KO'
+ OK = "KO"
# output redirection
my_out = outRedirection()
# The command to test
- sat = Sat('')
- sat.config('-v VARS.python')
+ sat = Sat("")
+ sat.config("-v VARS.python")
# stop output redirection
my_out.end_redirection()
# get results
res = my_out.read_results()
-
-
+
if platform.python_version() in res:
- OK = 'OK'
- self.assertEqual(OK, 'OK')
+ OK = "OK"
+ self.assertEqual(OK, "OK")
def test_020(self):
# Test the display of the right value of 'sat config -s'
- OK = 'KO'
+ OK = "KO"
# output redirection
my_out = outRedirection()
# The command to test
- sat = Sat('')
- sat.config('-s')
+ sat = Sat("")
+ sat.config("-s")
# stop output redirection
my_out.end_redirection()
# get results
res = my_out.read_results()
-
-
- if 'INTERNAL' in res:
- OK = 'OK'
- self.assertEqual(OK, 'OK')
-
+
+ if "INTERNAL" in res:
+ OK = "OK"
+ self.assertEqual(OK, "OK")
+
def test_030(self):
# Test the display of the right value of 'sat config --info'
- application = 'appli-test'
- product = 'PRODUCT_DEV'
-
- OK = 'KO'
+ application = "appli-test"
+ product = "PRODUCT_DEV"
+
+ OK = "KO"
# output redirection
my_out = outRedirection()
# The command to test
- sat = Sat('')
- sat.config(application + ' --info ' + product)
+ sat = Sat("")
+ sat.config(application + " --info " + product)
# stop output redirection
my_out.end_redirection()
# get results
res = my_out.read_results()
-
-
- if 'compilation method = cmake' in res:
- OK = 'OK'
- self.assertEqual(OK, 'OK')
+
+ if "compilation method = cmake" in res:
+ OK = "OK"
+ self.assertEqual(OK, "OK")
+
# test launch
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
pass
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2018 CEA/DEN
#
from src.salomeTools import Sat
+
class TestSource(unittest.TestCase):
"""Test of the environ command"""
-
+
def test_010(self):
# Test the environ command without any option
- OK = 'KO'
-
- appli = 'appli-test'
+ OK = "KO"
+
+ appli = "appli-test"
+
+ file_env_name = "env_launch.sh"
- file_env_name = 'env_launch.sh'
-
sat = Sat()
sat.config(appli)
sat.environ(appli)
if os.path.exists(expected_file_path):
- OK = 'OK'
- self.assertEqual(OK, 'OK')
+ OK = "OK"
+ self.assertEqual(OK, "OK")
def test_020(self):
# Test the environ command with option '--products'
- OK = 'KO'
-
- appli = 'appli-test'
- product_name = 'PRODUCT_GIT'
-
- file_env_name = 'env_launch.sh'
-
+ OK = "KO"
+
+ appli = "appli-test"
+ product_name = "PRODUCT_GIT"
+
+ file_env_name = "env_launch.sh"
+
sat = Sat()
sat.config(appli)
if os.path.exists(expected_file_path):
os.remove(expected_file_path)
- sat.environ(appli + ' --products ' + product_name)
+ sat.environ(appli + " --products " + product_name)
if os.path.exists(expected_file_path):
- OK = 'OK'
- self.assertEqual(OK, 'OK')
+ OK = "OK"
+ self.assertEqual(OK, "OK")
def test_030(self):
# Test the environ command with option --target
- OK = 'KO'
-
- appli = 'appli-test'
-
- file_env_name = 'env_launch.sh'
-
+ OK = "KO"
+
+ appli = "appli-test"
+
+ file_env_name = "env_launch.sh"
+
sat = Sat()
sat.config(appli)
- expected_file_path = os.path.join('.', file_env_name)
- expected_file_path2 = os.path.join('.', 'env_build.sh')
+ expected_file_path = os.path.join(".", file_env_name)
+ expected_file_path2 = os.path.join(".", "env_build.sh")
if os.path.exists(expected_file_path):
os.remove(expected_file_path)
- sat.environ(appli + ' --target .')
+ sat.environ(appli + " --target .")
if os.path.exists(expected_file_path):
- OK = 'OK'
+ OK = "OK"
if os.path.exists(expected_file_path):
os.remove(expected_file_path)
os.remove(expected_file_path2)
# pyunit method to compare 2 str
- self.assertEqual(OK, 'OK')
+ self.assertEqual(OK, "OK")
def test_040(self):
# Test the environ command with option --prefix
- OK = 'KO'
-
- appli = 'appli-test'
- prefix = 'TEST'
- file_env_name = prefix + '_launch.sh'
-
+ OK = "KO"
+
+ appli = "appli-test"
+ prefix = "TEST"
+ file_env_name = prefix + "_launch.sh"
+
sat = Sat()
sat.config(appli)
if os.path.exists(expected_file_path):
os.remove(expected_file_path)
- sat.environ(appli + ' --prefix ' + prefix)
+ sat.environ(appli + " --prefix " + prefix)
if os.path.exists(expected_file_path):
- OK = 'OK'
- self.assertEqual(OK, 'OK')
+ OK = "OK"
+ self.assertEqual(OK, "OK")
def test_050(self):
# Test the environ command with option --shell
- OK = 'KO'
-
- appli = 'appli-test'
- shell = 'bat'
- file_env_name = 'env_launch.bat'
-
+ OK = "KO"
+
+ appli = "appli-test"
+ shell = "bat"
+ file_env_name = "env_launch.bat"
+
sat = Sat()
sat.config(appli)
if os.path.exists(expected_file_path):
os.remove(expected_file_path)
- sat.environ(appli + ' --shell ' + shell)
+ sat.environ(appli + " --shell " + shell)
if os.path.exists(expected_file_path):
- OK = 'OK'
- self.assertEqual(OK, 'OK')
+ OK = "OK"
+ self.assertEqual(OK, "OK")
+
# test launch
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
pass
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2018 CEA/DEN
#
from src.salomeTools import Sat
+
class TestCase(unittest.TestCase):
"""Test the job command"""
def test_010(self):
# Test the job command
- OK = 'KO'
+ OK = "KO"
tmp_file = "/tmp/test.txt"
sat = Sat("-l " + tmp_file)
-
+
# Execute the job command
- sat.job("--jobs_config .test --name Job 1" )
+ sat.job("--jobs_config .test --name Job 1")
ff = open(tmp_file, "r")
log_files = ff.readlines()
ff.close()
os.remove(tmp_file)
- log_config = [line.replace("\n", "") for line in log_files if 'config.xml' in line]
-
+ log_config = [
+ line.replace("\n", "") for line in log_files if "config.xml" in line
+ ]
+
text = open(log_config[0], "r").read()
if "nb_proc" in text:
- OK = 'OK'
- self.assertEqual(OK, 'OK')
-
+ OK = "OK"
+ self.assertEqual(OK, "OK")
def test_020(self):
# Test the job command with a failing command
- OK = 'KO'
+ OK = "KO"
tmp_file = "/tmp/test.txt"
sat = Sat("-l " + tmp_file)
-
+
# Execute the job command
- res = sat.job("--jobs_config .test --name Job 4" )
+ res = sat.job("--jobs_config .test --name Job 4")
if res == 1:
- OK = 'OK'
+ OK = "OK"
# pyunit method to compare 2 str
- self.assertEqual(OK, 'OK')
+ self.assertEqual(OK, "OK")
def test_030(self):
# Test the job command with a wrong file configuration
- OK = 'KO'
+ OK = "KO"
tmp_file = "/tmp/test.txt"
sat = Sat("-l " + tmp_file)
-
+
# Execute the job command
- res = sat.job("--jobs_config NOTEXIST --name Job 4" )
+ res = sat.job("--jobs_config NOTEXIST --name Job 4")
if res == 1:
- OK = 'OK'
- self.assertEqual(OK, 'OK')
+ OK = "OK"
+ self.assertEqual(OK, "OK")
def test_040(self):
# Test the job command without --jobs_config option
- OK = 'KO'
+ OK = "KO"
tmp_file = "/tmp/test.txt"
sat = Sat("-l " + tmp_file)
-
+
# Execute the job command
- res = sat.job("--name Job 4" )
+ res = sat.job("--name Job 4")
if res == 1:
- OK = 'OK'
- self.assertEqual(OK, 'OK')
+ OK = "OK"
+ self.assertEqual(OK, "OK")
def test_050(self):
# Test the job command without --jobs_config option
- OK = 'KO'
+ OK = "KO"
tmp_file = "/tmp/test.txt"
sat = Sat("-l " + tmp_file)
-
+
# Execute the job command
- res = sat.job("--jobs_config .test --name NOTEXIST" )
+ res = sat.job("--jobs_config .test --name NOTEXIST")
if res == 1:
- OK = 'OK'
- self.assertEqual(OK, 'OK')
+ OK = "OK"
+ self.assertEqual(OK, "OK")
def test_060(self):
- # Test the sat -h job
+ # Test the sat -h job
OK = "KO"
import job
-
- if "Executes the commands of the job defined in the jobs configuration file" in job.description():
+
+ if (
+ "Executes the commands of the job defined in the jobs configuration file"
+ in job.description()
+ ):
OK = "OK"
self.assertEqual(OK, "OK")
+
# test launch
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
pass
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2018 CEA/DEN
#
from src.salomeTools import Sat
from unittestpy.tools import outRedirection
+
class TestCase(unittest.TestCase):
- "Test the jobs command"""
+ "Test the jobs command" ""
def test_010(self):
# Test the jobs command
- OK = 'KO'
+ OK = "KO"
tmp_file = "/tmp/test.txt"
sat = Sat("-l " + tmp_file)
-
+
# Execute the jobs command
- sat.jobs("--name .test --publish" )
+ sat.jobs("--name .test --publish")
ff = open(tmp_file, "r")
log_files = ff.readlines()
ff.close()
os.remove(tmp_file)
- log_jobs = [line.replace("\n", "") for line in log_files if 'jobs.xml' in line]
-
+ log_jobs = [line.replace("\n", "") for line in log_files if "jobs.xml" in line]
+
text = open(log_jobs[0], "r").read()
-
+
expected_res = [
- "Establishing connection with all the machines",
- "Executing the jobs",
- "Results for job"
+ "Establishing connection with all the machines",
+ "Executing the jobs",
+ "Results for job",
]
-
+
res = 0
for exp_res in expected_res:
if exp_res not in text:
res += 1
-
+
if res == 0:
- OK = 'OK'
- self.assertEqual(OK, 'OK')
+ OK = "OK"
+ self.assertEqual(OK, "OK")
def test_020(self):
# Test the jobs command with option --only_jobs
- OK = 'KO'
+ OK = "KO"
tmp_file = "/tmp/test.txt"
sat = Sat("-l " + tmp_file)
-
+
# Execute the jobs command
- sat.jobs("--name .test --publish --only_jobs Job 1" )
+ sat.jobs("--name .test --publish --only_jobs Job 1")
ff = open(tmp_file, "r")
log_files = ff.readlines()
ff.close()
os.remove(tmp_file)
- log_jobs = [line.replace("\n", "") for line in log_files if 'jobs.xml' in line]
-
+ log_jobs = [line.replace("\n", "") for line in log_files if "jobs.xml" in line]
+
text = open(log_jobs[0], "r").read()
-
+
expected_res = [
- "Establishing connection with all the machines",
- "Executing the jobs",
- "Results for job"
+ "Establishing connection with all the machines",
+ "Executing the jobs",
+ "Results for job",
]
-
+
res = 0
for exp_res in expected_res:
if exp_res not in text:
res += 1
-
+
if res == 0:
- OK = 'OK'
- self.assertEqual(OK, 'OK')
+ OK = "OK"
+ self.assertEqual(OK, "OK")
def test_030(self):
# Test the jobs command without --name option
- OK = 'KO'
+ OK = "KO"
tmp_file = "/tmp/test.txt"
sat = Sat("-l " + tmp_file)
-
+
# Execute the job command
res = sat.jobs()
if res == 1:
- OK = 'OK'
- self.assertEqual(OK, 'OK')
-
+ OK = "OK"
+ self.assertEqual(OK, "OK")
+
def test_040(self):
# Test the jobs command with a wrong file configuration
- OK = 'KO'
+ OK = "KO"
tmp_file = "/tmp/test.txt"
sat = Sat("-l " + tmp_file)
-
+
# Execute the job command
- res = sat.jobs("--name NOTEXIST" )
+ res = sat.jobs("--name NOTEXIST")
if res == 1:
- OK = 'OK'
- self.assertEqual(OK, 'OK')
+ OK = "OK"
+ self.assertEqual(OK, "OK")
def test_050(self):
# Test the display of the right value of 'sat jobs --list'
# The command to test
sat = Sat()
- sat.jobs('--list')
+ sat.jobs("--list")
# stop output redirection
my_out.end_redirection()
self.assertEqual(OK, "OK")
def test_060(self):
- # Test the sat -h jobs
+ # Test the sat -h jobs
OK = "KO"
import jobs
-
- if "The jobs command launches maintenances that are described in the dedicated jobs configuration file." in jobs.description():
+
+ if (
+ "The jobs command launches maintenances that are described in the dedicated jobs configuration file."
+ in jobs.description()
+ ):
OK = "OK"
self.assertEqual(OK, "OK")
+
# test launch
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
pass
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2018 CEA/DEN
#
sleep_time = 2
+
class TestCase(unittest.TestCase):
"""Test of log command: launch of browser"""
-
+
def test_010(self):
# Test the write of xml log when invoking a command
OK = "KO"
-
+
# launch the command that will write a log
sat = Sat()
- sat.config('appli-test -v USER.browser')
-
+ sat.config("appli-test -v USER.browser")
+
# get log file path
logDir = sat.cfg.USER.log_dir
- logPath = os.path.join(logDir, sat.cfg.VARS.datehour + "_" + sat.cfg.VARS.command + ".xml")
-
+ logPath = os.path.join(
+ logDir, sat.cfg.VARS.datehour + "_" + sat.cfg.VARS.command + ".xml"
+ )
+
if os.path.exists(logPath):
OK = "OK"
self.assertEqual(OK, "OK")
def test_020(self):
# Test the terminal option without application
OK = "KO"
-
+
# launch the command that will write a log
sat = Sat()
-
+
one = u"1"
sys.stdin = io.StringIO(one)
-
-
+
try:
- sat.log('-t')
+ sat.log("-t")
OK = "OK"
sys.stdin = sys.__stdin__
except:
def test_030(self):
# Test the terminal option with application
OK = "KO"
-
+
# launch the command that will write a log
sat = Sat()
-
- sat.config('appli-test -v VARS.python')
-
+
+ sat.config("appli-test -v VARS.python")
+
one = u"1"
sys.stdin = io.StringIO(one)
-
+
try:
- sat.log('appli-test -t --last')
+ sat.log("appli-test -t --last")
OK = "OK"
sys.stdin = sys.__stdin__
except:
def test_040(self):
# Test the terminal option with 0 as input
OK = "KO"
-
+
# launch the command that will write a log
sat = Sat()
-
- sat.config('appli-test -v VARS.python')
-
+
+ sat.config("appli-test -v VARS.python")
+
zero = u"0\n1"
sys.stdin = io.StringIO(zero)
-
+
try:
- sat.log('--terminal')
+ sat.log("--terminal")
OK = "OK"
finally:
sys.stdin = sys.__stdin__
def test_050(self):
# Test the terminal option with input bigger than the number of logs
OK = "KO"
-
+
# launch the command that will write a log
sat = Sat()
-
- sat.config('appli-test -v VARS.python')
-
+
+ sat.config("appli-test -v VARS.python")
+
nb_logs = len(os.listdir(sat.cfg.USER.log_dir))
-
+
nb_logs_u = unicode(str(nb_logs) + "\n1")
sys.stdin = io.StringIO(nb_logs_u)
-
+
try:
- sat.log('--terminal')
+ sat.log("--terminal")
OK = "OK"
finally:
sys.stdin = sys.__stdin__
def test_060(self):
# Test the terminal option with input return
OK = "KO"
-
+
# launch the command that will write a log
sat = Sat()
-
- sat.config('appli-test -v VARS.python')
-
+
+ sat.config("appli-test -v VARS.python")
+
ret = unicode("\n0")
sys.stdin = io.StringIO(ret)
-
+
try:
- sat.log('--terminal')
+ sat.log("--terminal")
OK = "OK"
finally:
sys.stdin = sys.__stdin__
def test_070(self):
# Test the terminal option with input not int
OK = "KO"
-
+
# launch the command that will write a log
sat = Sat()
-
- sat.config('appli-test -v VARS.python')
-
+
+ sat.config("appli-test -v VARS.python")
+
ret = unicode("blabla\n0")
sys.stdin = io.StringIO(ret)
-
+
try:
- sat.log('--terminal')
+ sat.log("--terminal")
OK = "OK"
finally:
sys.stdin = sys.__stdin__
def test_080(self):
# Test the terminal option and option last
OK = "KO"
-
+
# launch the command that will write a log
sat = Sat()
-
+
try:
- sat.log('--terminal --last')
+ sat.log("--terminal --last")
OK = "OK"
finally:
sys.stdin = sys.__stdin__
-
+
# pyunit method to compare 2 str
self.assertEqual(OK, "OK")
-
+
def test_090(self):
# Test the option --last
OK = "KO"
-
+
# launch the command that will write a log
sat = Sat("-oUSER.browser='konqueror'")
-
- sat.config('appli-test -v VARS.python')
-
-
+
+ sat.config("appli-test -v VARS.python")
+
time.sleep(sleep_time)
- cmd_log = threading.Thread(target=sat.log, args=('appli-test --last',))
+ cmd_log = threading.Thread(target=sat.log, args=("appli-test --last",))
cmd_log.start()
-
+
time.sleep(sleep_time)
browser = sat.cfg.USER.browser
pid = check_proc_existence_and_kill_multi(browser + ".*" + "xml", 10)
-
+
if pid:
OK = "OK"
self.assertEqual(OK, "OK")
-
+
def test_100(self):
# Test the option --clean
OK = "KO"
-
+
# launch the command that will write a log
sat = Sat()
-
- sat.config('-v VARS.user')
-
+
+ sat.config("-v VARS.user")
+
nb_logs_t0 = len(os.listdir(sat.cfg.USER.log_dir))
- sat.log('--clean 1')
-
+ sat.log("--clean 1")
+
nb_logs_t1 = len(os.listdir(sat.cfg.USER.log_dir))
-
- if nb_logs_t1-nb_logs_t0 == 0:
+
+ if nb_logs_t1 - nb_logs_t0 == 0:
OK = "OK"
self.assertEqual(OK, "OK")
def test_120(self):
# Test the option --clean with big number of files to clean
OK = "KO"
-
+
# launch the command that will write a log
sat = Sat()
-
- sat.config('-v VARS.user')
-
+
+ sat.config("-v VARS.user")
+
nb_logs_t0 = len(os.listdir(sat.cfg.USER.log_dir))
-
+
if os.path.exists(sat.cfg.USER.log_dir + "_save"):
shutil.rmtree(sat.cfg.USER.log_dir + "_save")
- print("TODO: risky !!!copytree!!!", sat.cfg.USER.log_dir, sat.cfg.USER.log_dir + "_save")
+ print(
+ "TODO: risky !!!copytree!!!",
+ sat.cfg.USER.log_dir,
+ sat.cfg.USER.log_dir + "_save",
+ )
"""
shutil.copytree(sat.cfg.USER.log_dir,sat.cfg.USER.log_dir + "_save")
OK = "OK"
"""
self.assertEqual(OK, "OK")
-
+
"""
def test_130(self):
# Test the option --full
OK = "KO"
import log
-
+
if "Gives access to the logs produced" in log.description():
OK = "OK"
self.assertEqual(OK, "OK")
+
# test launch
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
pass
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2018 CEA/DEN
#
sleep_time = 2
+
class TestCase(unittest.TestCase):
"""Test of log command: launch of browser"""
sat = Sat("-oUSER.browser='konqueror'")
time.sleep(sleep_time)
- cmd_log = threading.Thread(target=sat.log, args=('',))
+ cmd_log = threading.Thread(target=sat.log, args=("",))
cmd_log.start()
time.sleep(sleep_time)
-
+
sat.config("")
browser = sat.cfg.USER.browser
pid = check_proc_existence_and_kill_multi(browser + ".*" + "hat\.xml", 10)
OK = "OK"
self.assertEqual(OK, "OK")
+
# test launch
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
pass
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2018 CEA/DEN
#
import src.product
from unittestpy.tools import outRedirection
+
class TestCase(unittest.TestCase):
"""Test of the clean command"""
def test_010(self):
# Test the clean command with no arguments (nothing to clean)
- OK = 'KO'
+ OK = "KO"
- appli = 'appli-test'
+ appli = "appli-test"
sat = Sat()
# output redirection
my_out = outRedirection()
-
+
sat.clean(appli)
-
+
# stop output redirection
my_out.end_redirection()
# get results
res = my_out.read_results()
-
+
if "Nothing to suppress" in res:
- OK = 'OK'
- self.assertEqual(OK, 'OK')
+ OK = "OK"
+ self.assertEqual(OK, "OK")
def test_020(self):
# Test the clean of sources
OK = "KO"
- appli = 'appli-test'
+ appli = "appli-test"
product_name = "PRODUCT_GIT"
- sat = Sat()
-
+ sat = Sat()
+
# Make sure the sources exist
sat.prepare(appli + " -p " + product_name)
-
+
# Call the command
sat.clean(appli + " -p " + product_name + " --sources", batch=True)
-
- expected_src_dir = src.product.get_product_config(sat.cfg, product_name).source_dir
-
+
+ expected_src_dir = src.product.get_product_config(
+ sat.cfg, product_name
+ ).source_dir
+
if not os.path.exists(expected_src_dir):
OK = "OK"
self.assertEqual(OK, "OK")
# Test the clean of build
OK = "KO"
- appli = 'appli-test'
+ appli = "appli-test"
product_name = "PRODUCT_GIT"
- sat = Sat()
-
+ sat = Sat()
+
# Make sure the build exists
sat.prepare(appli + " -p " + product_name)
sat.configure(appli + " -p " + product_name)
-
+
# Call the command
sat.clean(appli + " -p " + product_name + " --build", batch=True)
-
- expected_build_dir = src.product.get_product_config(sat.cfg, product_name).build_dir
-
+
+ expected_build_dir = src.product.get_product_config(
+ sat.cfg, product_name
+ ).build_dir
+
if not os.path.exists(expected_build_dir):
OK = "OK"
self.assertEqual(OK, "OK")
# Test the clean of install
OK = "KO"
- appli = 'appli-test'
+ appli = "appli-test"
product_name = "PRODUCT_GIT"
- sat = Sat()
-
+ sat = Sat()
+
# Make sure the build exists
sat.prepare(appli + " -p " + product_name)
sat.configure(appli + " -p " + product_name)
-
+
# Call the command
sat.clean(appli + " -p " + product_name + " --install", batch=True)
-
- expected_install_dir = src.product.get_product_config(sat.cfg, product_name).install_dir
-
+
+ expected_install_dir = src.product.get_product_config(
+ sat.cfg, product_name
+ ).install_dir
+
if not os.path.exists(expected_install_dir):
OK = "OK"
self.assertEqual(OK, "OK")
# Test the clean of all (build, src, install)
OK = "KO"
- appli = 'appli-test'
+ appli = "appli-test"
product_name = "PRODUCT_GIT"
- sat = Sat()
-
+ sat = Sat()
+
# Make sure the build exists
sat.prepare(appli + " -p " + product_name)
sat.compile(appli + " -p " + product_name)
-
+
# Call the command
sat.clean(appli + " -p " + product_name + " --all", batch=True)
-
- expected_install_dir = src.product.get_product_config(sat.cfg, product_name).install_dir
- expected_build_dir = src.product.get_product_config(sat.cfg, product_name).build_dir
- expected_src_dir = src.product.get_product_config(sat.cfg, product_name).source_dir
-
- if not os.path.exists(expected_install_dir) and not os.path.exists(expected_build_dir) and not os.path.exists(expected_src_dir):
+
+ expected_install_dir = src.product.get_product_config(
+ sat.cfg, product_name
+ ).install_dir
+ expected_build_dir = src.product.get_product_config(
+ sat.cfg, product_name
+ ).build_dir
+ expected_src_dir = src.product.get_product_config(
+ sat.cfg, product_name
+ ).source_dir
+
+ if (
+ not os.path.exists(expected_install_dir)
+ and not os.path.exists(expected_build_dir)
+ and not os.path.exists(expected_src_dir)
+ ):
OK = "OK"
self.assertEqual(OK, "OK")
# Test the clean with sources_without_dev option
OK = "KO"
- appli = 'appli-test'
+ appli = "appli-test"
product_name = "PRODUCT_GIT"
product_name2 = "PRODUCT_DEV"
- sat = Sat()
-
+ sat = Sat()
+
# Make sure the build exists
sat.prepare(appli + " -p " + product_name + "," + product_name2)
-
+
# Call the command
sat.clean(appli + " -p " + product_name + " --sources_without_dev", batch=True)
-
- expected_src_dir = src.product.get_product_config(sat.cfg, product_name).source_dir
- expected_src_dir2 = src.product.get_product_config(sat.cfg, product_name2).source_dir
-
+
+ expected_src_dir = src.product.get_product_config(
+ sat.cfg, product_name
+ ).source_dir
+ expected_src_dir2 = src.product.get_product_config(
+ sat.cfg, product_name2
+ ).source_dir
+
if not os.path.exists(expected_src_dir) and os.path.exists(expected_src_dir2):
OK = "OK"
self.assertEqual(OK, "OK")
-
def test_070(self):
# Test the sat -h clean
OK = "KO"
import clean
-
- if "The clean command suppress the source, build, or install" in clean.description():
+
+ if (
+ "The clean command suppress the source, build, or install"
+ in clean.description()
+ ):
OK = "OK"
self.assertEqual(OK, "OK")
+
# test launch
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
pass
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2018 CEA/DEN
#
import src.product
from unittestpy.tools import outRedirection
+
class TestCase(unittest.TestCase):
"""Test of the patch command"""
def test_010(self):
# Test the patch command with a product in dev mode
- OK = 'KO'
+ OK = "KO"
- appli = 'appli-test'
- product_name = 'PRODUCT_DEV'
+ appli = "appli-test"
+ product_name = "PRODUCT_DEV"
sat = Sat("-oUSER.output_level=2")
-
+
sat.config(appli)
-
- expected_src_dir = src.product.get_product_config(sat.cfg, product_name).source_dir
- expected_file_path = os.path.join(expected_src_dir, 'my_test_file.txt')
- expected_text = 'HELLO WORLD\n'
-
+
+ expected_src_dir = src.product.get_product_config(
+ sat.cfg, product_name
+ ).source_dir
+ expected_file_path = os.path.join(expected_src_dir, "my_test_file.txt")
+ expected_text = "HELLO WORLD\n"
+
if os.path.exists(expected_src_dir):
shutil.rmtree(expected_src_dir)
-
- sat.source(appli + ' --product ' + product_name)
-
- f = open(expected_file_path, 'r')
+
+ sat.source(appli + " --product " + product_name)
+
+ f = open(expected_file_path, "r")
text = f.readlines()[0]
- OK1 = 'KO'
+ OK1 = "KO"
if text == expected_text:
- OK1 = 'OK'
-
- sat.patch(appli + ' --product ' + product_name)
-
- new_expected_text = 'HELLO WORLD MODIFIED\n'
- f = open(expected_file_path, 'r')
+ OK1 = "OK"
+
+ sat.patch(appli + " --product " + product_name)
+
+ new_expected_text = "HELLO WORLD MODIFIED\n"
+ f = open(expected_file_path, "r")
text = f.readlines()[0]
-
- OK2 = 'KO'
+
+ OK2 = "KO"
if text == new_expected_text:
- OK2 = 'OK'
+ OK2 = "OK"
- if (OK1, OK2)==('OK', 'OK'):
- OK = 'OK'
- self.assertEqual(OK, 'OK')
+ if (OK1, OK2) == ("OK", "OK"):
+ OK = "OK"
+ self.assertEqual(OK, "OK")
def test_020(self):
# Test the patch command with a product with no sources found
- OK = 'KO'
+ OK = "KO"
- appli = 'appli-test'
- product_name = 'PRODUCT_DEV'
+ appli = "appli-test"
+ product_name = "PRODUCT_DEV"
- sat = Sat('')
+ sat = Sat("")
sat.config(appli)
-
- expected_src_dir = src.product.get_product_config(sat.cfg, product_name).source_dir
-
+
+ expected_src_dir = src.product.get_product_config(
+ sat.cfg, product_name
+ ).source_dir
+
if os.path.exists(expected_src_dir):
shutil.rmtree(expected_src_dir)
-
+
# output redirection
my_out = outRedirection()
-
- sat.patch(appli + ' --product ' + product_name)
-
+
+ sat.patch(appli + " --product " + product_name)
+
# stop output redirection
my_out.end_redirection()
# get results
res = my_out.read_results()
-
- if "No sources found for the " + product_name +" product" in res:
- OK = 'OK'
- self.assertEqual(OK, 'OK')
+
+ if "No sources found for the " + product_name + " product" in res:
+ OK = "OK"
+ self.assertEqual(OK, "OK")
def test_030(self):
# Test the patch command with a product without patch
- OK = 'KO'
+ OK = "KO"
+
+ appli = "appli-test"
+ product_name = "PRODUCT_ARCHIVE"
- appli = 'appli-test'
- product_name = 'PRODUCT_ARCHIVE'
+ sat = Sat("-v4")
+
+ sat.source(appli + " --product " + product_name)
- sat = Sat('-v4')
-
- sat.source(appli + ' --product ' + product_name)
-
# output redirection
my_out = outRedirection()
-
- sat.patch(appli + ' --product ' + product_name)
-
+
+ sat.patch(appli + " --product " + product_name)
+
# stop output redirection
my_out.end_redirection()
# get results
res = my_out.read_results()
-
- if "No patch for the " + product_name +" product" in res:
- OK = 'OK'
- self.assertEqual(OK, 'OK')
+
+ if "No patch for the " + product_name + " product" in res:
+ OK = "OK"
+ self.assertEqual(OK, "OK")
def test_040(self):
# Test the patch command with a product with a not valid patch
- OK = 'KO'
+ OK = "KO"
- appli = 'appli-test'
- product_name = 'PRODUCT_DEV'
+ appli = "appli-test"
+ product_name = "PRODUCT_DEV"
sat = Sat("-oPRODUCTS.PRODUCT_DEV.default.patches=['/']")
-
- sat.source(appli + ' --product ' + product_name)
-
+
+ sat.source(appli + " --product " + product_name)
+
# output redirection
my_out = outRedirection()
-
- sat.patch(appli + ' --product ' + product_name)
-
+
+ sat.patch(appli + " --product " + product_name)
+
# stop output redirection
my_out.end_redirection()
# get results
res = my_out.read_results()
-
+
if "Not a valid patch" in res:
- OK = 'OK'
- self.assertEqual(OK, 'OK')
+ OK = "OK"
+ self.assertEqual(OK, "OK")
def test_050(self):
# Test the sat -h patch
OK = "KO"
import patch
-
- if "The patch command apply the patches on the sources of" in patch.description():
+
+ if (
+ "The patch command apply the patches on the sources of"
+ in patch.description()
+ ):
OK = "OK"
self.assertEqual(OK, "OK")
+
# test launch
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
pass
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2018 CEA/DEN
#
import src
from src.salomeTools import Sat
+
class TestCase(unittest.TestCase):
"""Test of the prepare command"""
def test_010(self):
# Test the prepare command with a product in dev mode
- OK = 'KO'
+ OK = "KO"
- appli = 'appli-test'
- product_name = 'PRODUCT_DEV'
+ appli = "appli-test"
+ product_name = "PRODUCT_DEV"
sat = Sat()
-
+
sat.config(appli)
-
- expected_src_dir = src.product.get_product_config(sat.cfg, product_name).source_dir
- expected_file_path = os.path.join(expected_src_dir, 'my_test_file.txt')
- expected_text = 'HELLO WORLD\n'
-
+
+ expected_src_dir = src.product.get_product_config(
+ sat.cfg, product_name
+ ).source_dir
+ expected_file_path = os.path.join(expected_src_dir, "my_test_file.txt")
+ expected_text = "HELLO WORLD\n"
+
if os.path.exists(expected_src_dir):
shutil.rmtree(expected_src_dir)
-
- sat.prepare(appli + ' --product ' + product_name)
-
- f = open(expected_file_path, 'r')
+
+ sat.prepare(appli + " --product " + product_name)
+
+ f = open(expected_file_path, "r")
text = f.readlines()[0]
if text == expected_text:
- OK = 'OK'
- self.assertEqual(OK, 'OK')
+ OK = "OK"
+ self.assertEqual(OK, "OK")
def test_020(self):
# Test the prepare command with all products
- OK = 'KO'
+ OK = "KO"
- appli = 'appli-test'
- product_name = 'PRODUCT_DEV'
+ appli = "appli-test"
+ product_name = "PRODUCT_DEV"
sat = Sat()
sat.config(appli)
-
- expected_src_dir = src.product.get_product_config(sat.cfg, product_name).source_dir
- expected_file_path = os.path.join(expected_src_dir, 'my_test_file.txt')
- expected_text = 'HELLO WORLD\n'
-
+
+ expected_src_dir = src.product.get_product_config(
+ sat.cfg, product_name
+ ).source_dir
+ expected_file_path = os.path.join(expected_src_dir, "my_test_file.txt")
+ expected_text = "HELLO WORLD\n"
+
if os.path.exists(expected_src_dir):
shutil.rmtree(expected_src_dir)
-
+
sat.prepare(appli)
-
- f = open(expected_file_path, 'r')
+
+ f = open(expected_file_path, "r")
text = f.readlines()[0]
if text == expected_text:
- OK = 'OK'
- self.assertEqual(OK, 'OK')
+ OK = "OK"
+ self.assertEqual(OK, "OK")
def test_030(self):
# Test the prepare command with all products
- OK = 'KO'
+ OK = "KO"
- appli = 'appli-test'
+ appli = "appli-test"
sat = Sat()
sat.config(appli)
-
+
try:
sat.prepare(appli + " --force --force_patch")
- OK = 'OK'
+ OK = "OK"
except:
pass
- self.assertEqual(OK, 'OK')
+ self.assertEqual(OK, "OK")
def test_040(self):
# Test the sat -h prepare
OK = "KO"
import prepare
-
+
if "The prepare command gets the sources" in prepare.description():
OK = "OK"
self.assertEqual(OK, "OK")
+
# test launch
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
pass
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2018 CEA/DEN
#
import src.product
from unittestpy.tools import outRedirection
+
class TestCase(unittest.TestCase):
"""Test of the source command"""
-
+
def test_010(self):
# Test the source command with archive product
- appli = 'appli-test'
- product_name = 'PRODUCT_ARCHIVE'
+ appli = "appli-test"
+ product_name = "PRODUCT_ARCHIVE"
sat = Sat()
- sat.source(appli + ' --product ' + product_name)
+ sat.source(appli + " --product " + product_name)
- expected_src_dir = src.product.get_product_config(sat.cfg, product_name).source_dir
- expected_file_path = os.path.join(expected_src_dir, 'my_test_file.txt')
- expected_text = 'HELLO WORLD\n'
+ expected_src_dir = src.product.get_product_config(
+ sat.cfg, product_name
+ ).source_dir
+ expected_file_path = os.path.join(expected_src_dir, "my_test_file.txt")
+ expected_text = "HELLO WORLD\n"
- f = open(expected_file_path, 'r')
+ f = open(expected_file_path, "r")
text = f.read()
self.assertEqual(text, expected_text)
-
+
def test_020(self):
# Test the source command with git product
- appli = 'appli-test'
- product_name = 'PRODUCT_GIT'
+ appli = "appli-test"
+ product_name = "PRODUCT_GIT"
sat = Sat()
- sat.source(appli + ' --product ' + product_name)
+ sat.source(appli + " --product " + product_name)
- expected_src_dir = src.product.get_product_config(sat.cfg, product_name).source_dir
- expected_file_path = os.path.join(expected_src_dir, 'my_test_file.txt')
- expected_text = 'HELLO WORLD\n'
+ expected_src_dir = src.product.get_product_config(
+ sat.cfg, product_name
+ ).source_dir
+ expected_file_path = os.path.join(expected_src_dir, "my_test_file.txt")
+ expected_text = "HELLO WORLD\n"
- f = open(expected_file_path, 'r')
+ f = open(expected_file_path, "r")
text = f.read()
self.assertEqual(text, expected_text)
def test_030(self):
# Test the source command with cvs product
- appli = 'appli-test'
- product_name = 'PRODUCT_CVS'
+ appli = "appli-test"
+ product_name = "PRODUCT_CVS"
sat = Sat()
- sat.source(appli + ' --product ' + product_name)
+ sat.source(appli + " --product " + product_name)
- expected_src_dir = src.product.get_product_config(sat.cfg, product_name).source_dir
- expected_file_path = os.path.join(expected_src_dir, 'README.FIRST.txt')
- expected_text = 'Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE\n'
+ expected_src_dir = src.product.get_product_config(
+ sat.cfg, product_name
+ ).source_dir
+ expected_file_path = os.path.join(expected_src_dir, "README.FIRST.txt")
+ expected_text = "Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE\n"
- f = open(expected_file_path, 'r')
+ f = open(expected_file_path, "r")
text = f.readlines()[0]
# pyunit method to compare 2 str
self.assertEqual(text, expected_text)
-
+
"""
def test_040(self):
# Test the source command with svn product
def test_050(self):
# Test the source command with native product
- OK = 'KO'
-
- appli = 'appli-test'
- product_name = 'PRODUCT_NATIVE'
+ OK = "KO"
+
+ appli = "appli-test"
+ product_name = "PRODUCT_NATIVE"
sat = Sat()
- sat.source(appli + ' --product ' + product_name)
+ sat.source(appli + " --product " + product_name)
- expected_src_dir = os.path.join(sat.cfg.APPLICATION.workdir, 'SOURCES', product_name)
+ expected_src_dir = os.path.join(
+ sat.cfg.APPLICATION.workdir, "SOURCES", product_name
+ )
if not os.path.exists(expected_src_dir):
- OK = 'OK'
- self.assertEqual(OK, 'OK')
+ OK = "OK"
+ self.assertEqual(OK, "OK")
def test_060(self):
# Test the source command with fixed product
- OK = 'KO'
-
- appli = 'appli-test'
- product_name = 'PRODUCT_FIXED'
+ OK = "KO"
+
+ appli = "appli-test"
+ product_name = "PRODUCT_FIXED"
sat = Sat()
- sat.source(appli + ' --product ' + product_name)
+ sat.source(appli + " --product " + product_name)
- expected_src_dir = src.product.get_product_config(sat.cfg, product_name).install_dir
+ expected_src_dir = src.product.get_product_config(
+ sat.cfg, product_name
+ ).install_dir
if os.path.exists(expected_src_dir):
- OK = 'OK'
- self.assertEqual(OK, 'OK')
+ OK = "OK"
+ self.assertEqual(OK, "OK")
"""
def test_070(self):
OK = "KO"
import source
-
+
if "gets the sources of the application" in source.description():
OK = "OK"
self.assertEqual(OK, "OK")
+
# test launch
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
pass
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2018 CEA/DEN
#
from src.salomeTools import Sat
+
class TestCase(unittest.TestCase):
"""Test of the shell command"""
def test_010(self):
# Test the shell command with the --command option
- OK = 'KO'
+ OK = "KO"
tmp_file = "/tmp/test.txt"
sat = Sat("-l " + tmp_file)
-
+
sat.config()
sat_way = sat.cfg.VARS.salometoolsway
-
+
# Execute the shell command
sat.shell("--command ls " + sat_way)
ff.close()
os.remove(tmp_file)
log_files = [line.replace("\n", "") for line in log_files]
-
+
text = open(log_files[2], "r").read()
if "salomeTools.py" in text:
- OK = 'OK'
- self.assertEqual(OK, 'OK')
+ OK = "OK"
+ self.assertEqual(OK, "OK")
def test_020(self):
# Test the shell command with the --command option with a failing command
- OK = 'KO'
+ OK = "KO"
tmp_file = "/tmp/test.txt"
sat = Sat("-l " + tmp_file)
-
+
sat.config()
-
+
# Execute the shell command
res = sat.shell("--command i_fail")
ff.close()
os.remove(tmp_file)
log_files = [line.replace("\n", "") for line in log_files]
-
+
text = open(log_files[2], "r").read()
if "i_fail" in text and res == 1:
- OK = 'OK'
- self.assertEqual(OK, 'OK')
+ OK = "OK"
+ self.assertEqual(OK, "OK")
def test_030(self):
# Test the sat -h shell
OK = "KO"
import shell
-
+
if "Executes the shell command passed as argument" in shell.description():
OK = "OK"
self.assertEqual(OK, "OK")
+
# test launch
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
pass
#!/usr/bin/env python
-#-*- coding:utf-8 -*-
+# -*- coding:utf-8 -*-
# Copyright (C) 2010-2018 CEA/DEN
#
from src.salomeTools import Sat
+
class TestTest(unittest.TestCase):
"""Test of the test command"""
def test_010(self):
# Test the test command
- OK = 'KO'
+ OK = "KO"
tmp_file = "/tmp/test.txt"
application = "SALOME-7.8.0"
sat = Sat("-l " + tmp_file)
-
+
# Execute the job command
- sat.test(application + " --grid GEOM --session light" )
+ sat.test(application + " --grid GEOM --session light")
ff = open(tmp_file, "r")
log_files = ff.readlines()
ff.close()
os.remove(tmp_file)
- log_testboard = [line.replace("\n", "") for line in log_files if 'testboard.xml' in line]
-
+ log_testboard = [
+ line.replace("\n", "") for line in log_files if "testboard.xml" in line
+ ]
+
text = open(log_testboard[0], "r").read()
if '<session name="light">' in text:
- OK = 'OK'
- self.assertEqual(OK, 'OK')
+ OK = "OK"
+ self.assertEqual(OK, "OK")
def test_020(self):
# Test the test command with PY type
- OK = 'KO'
+ OK = "KO"
tmp_file = "/tmp/test.txt"
application = "SALOME-7.8.0"
sat = Sat("-l " + tmp_file)
-
+
# Execute the job command
- sat.test(application + " --grid MED --session PY_test_withKernel" )
+ sat.test(application + " --grid MED --session PY_test_withKernel")
ff = open(tmp_file, "r")
log_files = ff.readlines()
ff.close()
os.remove(tmp_file)
- log_testboard = [line.replace("\n", "") for line in log_files if 'testboard.xml' in line]
-
+ log_testboard = [
+ line.replace("\n", "") for line in log_files if "testboard.xml" in line
+ ]
+
text = open(log_testboard[0], "r").read()
if '<session name="PY_test_withKernel">' in text:
- OK = 'OK'
- self.assertEqual(OK, 'OK')
+ OK = "OK"
+ self.assertEqual(OK, "OK")
def test_030(self):
# Test the sat -h test
OK = "KO"
import test
-
- if "The test command runs a test base on a SALOME installation" in test.description():
+
+ if (
+ "The test command runs a test base on a SALOME installation"
+ in test.description()
+ ):
OK = "OK"
self.assertEqual(OK, "OK")
+
# test launch
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
pass
# >>> logging.basicConfig(stream=HTMLTestRunner.stdout_redirector)
# >>>
+
class OutputRedirector(object):
- """ Wrapper to redirect stdout or stderr """
+ """Wrapper to redirect stdout or stderr"""
+
def __init__(self, fp):
self.fp = fp
def flush(self):
self.fp.flush()
+
stdout_redirector = OutputRedirector(sys.stdout)
stderr_redirector = OutputRedirector(sys.stderr)
-
# ----------------------------------------------------------------------
# Template
+
class Template_mixin(object):
"""
Define a HTML template for report customerization and generation.
"""
STATUS = {
- 0: 'pass',
- 1: 'fail',
- 2: 'error',
+ 0: "pass",
+ 1: "fail",
+ 2: "error",
}
- DEFAULT_TITLE = 'Unit Test Report'
- DEFAULT_DESCRIPTION = ''
+ DEFAULT_TITLE = "Unit Test Report"
+ DEFAULT_DESCRIPTION = ""
# ------------------------------------------------------------------------
# HTML Template
"""
# variables: (title, generator, stylesheet, heading, report, ending)
-
# ------------------------------------------------------------------------
# Stylesheet
#
</style>
"""
-
-
# ------------------------------------------------------------------------
# Heading
#
<p class='description'>%(description)s</p>
</div>
-""" # variables: (title, parameters, description)
+""" # variables: (title, parameters, description)
HEADING_ATTRIBUTE_TMPL = """<p class='attribute'><strong>%(name)s:</strong> %(value)s</p>
-""" # variables: (name, value)
-
-
+""" # variables: (name, value)
# ------------------------------------------------------------------------
# Report
<td> </td>
</tr>
</table>
-""" # variables: (test_list, count, Pass, fail, error)
+""" # variables: (test_list, count, Pass, fail, error)
REPORT_CLASS_TMPL = r"""
<tr class='%(style)s'>
<td>%(error)s</td>
<td><a href="javascript:showClassDetail('%(cid)s',%(count)s)">Detail</a></td>
</tr>
-""" # variables: (style, desc, count, Pass, fail, error, cid)
-
+""" # variables: (style, desc, count, Pass, fail, error, cid)
REPORT_TEST_WITH_OUTPUT_TMPL = r"""
<tr id='%(tid)s' class='%(Class)s'>
</td>
</tr>
-""" # variables: (tid, Class, style, desc, status)
-
+""" # variables: (tid, Class, style, desc, status)
REPORT_TEST_NO_OUTPUT_TMPL = r"""
<tr id='%(tid)s' class='%(Class)s'>
<td class='%(style)s'><div class='testcase'>%(desc)s</div></td>
<td colspan='5' align='center'>%(status)s</td>
</tr>
-""" # variables: (tid, Class, style, desc, status)
-
+""" # variables: (tid, Class, style, desc, status)
REPORT_TEST_OUTPUT_TMPL = r"""
%(id)s: %(output)s
-""" # variables: (id, output)
-
-
+""" # variables: (id, output)
# ------------------------------------------------------------------------
# ENDING
ENDING_TMPL = """<div id='ending'> </div>"""
+
# -------------------- The end of the Template class -------------------
TestResult = unittest.TestResult
+
class _TestResult(TestResult):
# note: _TestResult is a pure representation of results.
# It lacks the output and reporting ability compares to unittest._TextTestResult.
# )
self.result = []
-
def startTest(self, test):
TestResult.startTest(self, test)
# just one buffer for both stdout and stderr
sys.stdout = stdout_redirector
sys.stderr = stderr_redirector
-
def complete_output(self):
"""
Disconnect output redirection and return buffer.
self.stderr0 = None
return self.outputBuffer.getvalue()
-
def stopTest(self, test):
# Usually one of addSuccess, addError or addFailure would have been called.
# But there are some path in unittest that would bypass this.
# We must disconnect stdout in stopTest(), which is guaranteed to be called.
self.complete_output()
-
def addSuccess(self, test):
self.success_count += 1
TestResult.addSuccess(self, test)
output = self.complete_output()
- self.result.append((0, test, output, ''))
+ self.result.append((0, test, output, ""))
if self.verbosity > 1:
- sys.stderr.write('ok ')
+ sys.stderr.write("ok ")
sys.stderr.write(str(test))
- sys.stderr.write('\n')
+ sys.stderr.write("\n")
else:
- sys.stderr.write('.')
+ sys.stderr.write(".")
def addError(self, test, err):
self.error_count += 1
output = self.complete_output()
self.result.append((2, test, output, _exc_str))
if self.verbosity > 1:
- sys.stderr.write('E ')
+ sys.stderr.write("E ")
sys.stderr.write(str(test))
- sys.stderr.write('\n')
+ sys.stderr.write("\n")
else:
- sys.stderr.write('E')
+ sys.stderr.write("E")
def addFailure(self, test, err):
self.failure_count += 1
output = self.complete_output()
self.result.append((1, test, output, _exc_str))
if self.verbosity > 1:
- sys.stderr.write('F ')
+ sys.stderr.write("F ")
sys.stderr.write(str(test))
- sys.stderr.write('\n')
+ sys.stderr.write("\n")
else:
- sys.stderr.write('F')
+ sys.stderr.write("F")
class HTMLTestRunner(Template_mixin):
- """
- """
+ """ """
+
def __init__(self, stream=sys.stdout, verbosity=1, title=None, description=None):
self.stream = stream
self.verbosity = verbosity
self.startTime = datetime.datetime.now()
-
def run(self, test):
"Run the given test case or test suite."
result = _TestResult(self.verbosity)
test(result)
self.stopTime = datetime.datetime.now()
self.generateReport(test, result)
- print >>sys.stderr, '\nTime Elapsed: %s' % (self.stopTime-self.startTime)
+ print >>sys.stderr, "\nTime Elapsed: %s" % (self.stopTime - self.startTime)
return result
-
def sortResult(self, result_list):
# unittest does not seems to run in any particular order.
# Here at least we want to group them together by class.
rmap = {}
classes = []
- for n,t,o,e in result_list:
+ for n, t, o, e in result_list:
cls = t.__class__
if not cls in rmap:
rmap[cls] = []
classes.append(cls)
- rmap[cls].append((n,t,o,e))
+ rmap[cls].append((n, t, o, e))
r = [(cls, rmap[cls]) for cls in classes]
return r
-
def getReportAttributes(self, result):
"""
Return report attributes as a list of (name, value).
startTime = str(self.startTime)[:19]
duration = str(self.stopTime - self.startTime)
status = []
- if result.success_count: status.append('Pass %s' % result.success_count)
- if result.failure_count: status.append('Failure %s' % result.failure_count)
- if result.error_count: status.append('Error %s' % result.error_count )
+ if result.success_count:
+ status.append("Pass %s" % result.success_count)
+ if result.failure_count:
+ status.append("Failure %s" % result.failure_count)
+ if result.error_count:
+ status.append("Error %s" % result.error_count)
if status:
- status = ' '.join(status)
+ status = " ".join(status)
else:
- status = 'none'
+ status = "none"
return [
- ('Start Time', startTime),
- ('Duration', duration),
- ('Status', status),
+ ("Start Time", startTime),
+ ("Duration", duration),
+ ("Status", status),
]
-
def generateReport(self, test, result):
report_attrs = self.getReportAttributes(result)
- generator = 'HTMLTestRunner %s' % __version__
+ generator = "HTMLTestRunner %s" % __version__
stylesheet = self._generate_stylesheet()
heading = self._generate_heading(report_attrs)
report = self._generate_report(result)
ending = self._generate_ending()
output = self.HTML_TMPL % dict(
- title = saxutils.escape(self.title),
- generator = generator,
- stylesheet = stylesheet,
- heading = heading,
- report = report,
- ending = ending,
+ title=saxutils.escape(self.title),
+ generator=generator,
+ stylesheet=stylesheet,
+ heading=heading,
+ report=report,
+ ending=ending,
)
- self.stream.write(output.encode('utf8'))
-
+ self.stream.write(output.encode("utf8"))
def _generate_stylesheet(self):
return self.STYLESHEET_TMPL
-
def _generate_heading(self, report_attrs):
a_lines = []
for name, value in report_attrs:
line = self.HEADING_ATTRIBUTE_TMPL % dict(
- name = saxutils.escape(name),
- value = saxutils.escape(value),
- )
+ name=saxutils.escape(name),
+ value=saxutils.escape(value),
+ )
a_lines.append(line)
heading = self.HEADING_TMPL % dict(
- title = saxutils.escape(self.title),
- parameters = ''.join(a_lines),
- description = saxutils.escape(self.description),
+ title=saxutils.escape(self.title),
+ parameters="".join(a_lines),
+ description=saxutils.escape(self.description),
)
return heading
-
def _generate_report(self, result):
rows = []
sortedResult = self.sortResult(result.result)
for cid, (cls, cls_results) in enumerate(sortedResult):
# subtotal for a class
np = nf = ne = 0
- for n,t,o,e in cls_results:
- if n == 0: np += 1
- elif n == 1: nf += 1
- else: ne += 1
+ for n, t, o, e in cls_results:
+ if n == 0:
+ np += 1
+ elif n == 1:
+ nf += 1
+ else:
+ ne += 1
# format class description
if cls.__module__ == "__main__":
else:
name = "%s.%s" % (cls.__module__, cls.__name__)
doc = cls.__doc__ and cls.__doc__.split("\n")[0] or ""
- desc = doc and '%s: %s' % (name, doc) or name
+ desc = doc and "%s: %s" % (name, doc) or name
row = self.REPORT_CLASS_TMPL % dict(
- style = ne > 0 and 'errorClass' or nf > 0 and 'failClass' or 'passClass',
- desc = desc,
- count = np+nf+ne,
- Pass = np,
- fail = nf,
- error = ne,
- cid = 'c%s' % (cid+1),
+ style=ne > 0 and "errorClass" or nf > 0 and "failClass" or "passClass",
+ desc=desc,
+ count=np + nf + ne,
+ Pass=np,
+ fail=nf,
+ error=ne,
+ cid="c%s" % (cid + 1),
)
rows.append(row)
- for tid, (n,t,o,e) in enumerate(cls_results):
+ for tid, (n, t, o, e) in enumerate(cls_results):
self._generate_report_test(rows, cid, tid, n, t, o, e)
report = self.REPORT_TMPL % dict(
- test_list = ''.join(rows),
- count = str(result.success_count+result.failure_count+result.error_count),
- Pass = str(result.success_count),
- fail = str(result.failure_count),
- error = str(result.error_count),
+ test_list="".join(rows),
+ count=str(result.success_count + result.failure_count + result.error_count),
+ Pass=str(result.success_count),
+ fail=str(result.failure_count),
+ error=str(result.error_count),
)
return report
-
def _generate_report_test(self, rows, cid, tid, n, t, o, e):
# e.g. 'pt1.1', 'ft1.1', etc
has_output = bool(o or e)
- tid = (n == 0 and 'p' or 'f') + 't%s.%s' % (cid+1,tid+1)
- name = t.id().split('.')[-1]
+ tid = (n == 0 and "p" or "f") + "t%s.%s" % (cid + 1, tid + 1)
+ name = t.id().split(".")[-1]
doc = t.shortDescription() or ""
- desc = doc and ('%s: %s' % (name, doc)) or name
- tmpl = has_output and self.REPORT_TEST_WITH_OUTPUT_TMPL or self.REPORT_TEST_NO_OUTPUT_TMPL
+ desc = doc and ("%s: %s" % (name, doc)) or name
+ tmpl = (
+ has_output
+ and self.REPORT_TEST_WITH_OUTPUT_TMPL
+ or self.REPORT_TEST_NO_OUTPUT_TMPL
+ )
# o and e should be byte string because they are collected from stdout and stderr?
- if isinstance(o,str):
+ if isinstance(o, str):
# TODO: some problem with 'string_escape': it escape \n and mess up formating
# uo = unicode(o.encode('string_escape'))
- uo = o.decode('latin-1')
+ uo = o.decode("latin-1")
else:
uo = o
- if isinstance(e,str):
+ if isinstance(e, str):
# TODO: some problem with 'string_escape': it escape \n and mess up formating
# ue = unicode(e.encode('string_escape'))
- ue = e.decode('latin-1')
+ ue = e.decode("latin-1")
else:
ue = e
script = self.REPORT_TEST_OUTPUT_TMPL % dict(
- id = tid,
- output = saxutils.escape(uo+ue),
+ id=tid,
+ output=saxutils.escape(uo + ue),
)
row = tmpl % dict(
- tid = tid,
- Class = (n == 0 and 'hiddenRow' or 'none'),
- style = n == 2 and 'errorCase' or (n == 1 and 'failCase' or 'none'),
- desc = desc,
- script = script,
- status = self.STATUS[n],
+ tid=tid,
+ Class=(n == 0 and "hiddenRow" or "none"),
+ style=n == 2 and "errorCase" or (n == 1 and "failCase" or "none"),
+ desc=desc,
+ script=script,
+ status=self.STATUS[n],
)
rows.append(row)
if not has_output:
A variation of the unittest.TestProgram. Please refer to the base
class for command line parameters.
"""
+
def runTests(self):
# Pick HTMLTestRunner as the default test runner.
# base class's testRunner parameter is not useful because it means
self.testRunner = HTMLTestRunner(verbosity=self.verbosity)
unittest.TestProgram.runTests(self)
+
main = TestProgram
##############################################################################
