salome.kernel 9.14.0.post6__cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

salome/kernel/salome_version.py

@@ -0,0 +1,164 @@
+#  -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+#
+# Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+# CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+#
+# 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
+#
+
+#  File   : salome_version.py
+#  Author : Vadim SANDLER
+#  Module : SALOME
+#
+__ALL__ = [
+    "getVersion",
+    "getVersionMajor",
+    "getVersionMinor",
+    "getVersionRelease",
+    "getVersions",
+    "getXVersion",
+    "isDevelopmentVersion",
+    ]
+
+_salome_versions = {}
+
+def getVersion( mod = "KERNEL", full = False ):
+    """
+    Get SALOME module version number
+    Parameters:
+    - mod  : SALOME module name, default is 'KERNEL'
+    - full : take into account development marker (in this case 'dev' is added
+             to the end of version value for development version), False by default
+    Returns: version number string or None if VERSION file is not found
+    """
+    global _salome_versions
+    mod = mod.upper()
+    dev_flag = { True : "dev", False : "" }
+    if mod not in _salome_versions:
+        _salome_versions[ mod ] = [ None, "" ]
+        import os
+        root_dir = os.getenv( "%s_ROOT_DIR" % mod )
+        if root_dir:
+            try:
+                filename = root_dir + "/bin/salome/VERSION"
+                if not os.path.exists( filename ):
+                    filename = root_dir + "/bin/VERSION"
+                f = open( filename )
+                data = f.readlines()
+                f.close()
+                for l in data:
+                    if l.strip().startswith("#") or ":" not in l: continue
+                    key = ":".join( l.split( ":" )[ :-1 ] ).strip()
+                    val = l.split( ":" )[ -1 ].strip()
+                    if "development" in key.lower():
+                        _salome_versions[ mod ][ 1 ] = dev_flag[ val == "1" ]
+                    elif "version" in key.lower() or mod in key:
+                        _salome_versions[ mod ][ 0 ] = val
+                    pass
+            except Exception:
+                pass
+    v = _salome_versions[ mod ][ 0 ]
+    if full and v is not None:
+        v += _salome_versions[ mod ][ 1 ]
+    return v is not None and v or ""
+
+def getVersionMajor( mod = "KERNEL" ):
+    """
+    Get SALOME module major version number
+    Parameters:
+    - mod  : SALOME module name, default is 'KERNEL'
+    Returns: version major number string or None if VERSION file is not found
+    """
+    ver = getVersion( mod )
+    try:
+        return ver.split( "." )[ 0 ]
+    except Exception:
+        pass
+    return None
+
+def getVersionMinor( mod = "KERNEL" ):
+    """
+    Get SALOME module minor version number
+    Parameters:
+    - mod  : SALOME module name, default is 'KERNEL'
+    Returns: version minor number string or None if VERSION file is not found
+    """
+    ver = getVersion( mod )
+    try:
+        return ver.split( "." )[ 1 ]
+    except Exception:
+        pass
+    return None
+
+def getVersionRelease( mod = "KERNEL" ):
+    """
+    Get SALOME module release version number
+    Parameters:
+    - mod  : SALOME module name, default is 'KERNEL'
+    Returns: version release number string or None if VERSION file is not found
+    """
+    ver = getVersion( mod )
+    try:
+        return ver.split( "." )[ 2 ]
+    except Exception:
+        pass
+    return None
+
+def getVersions( mod = "KERNEL" ):
+    """
+    Get SALOME module version as list of [major, minor, release] numbers
+    Parameters:
+    - mod  : SALOME module name, default is 'KERNEL'
+    Returns: version numbers list
+    """
+    try:
+        major = int( getVersionMajor( mod ) )
+    except Exception:
+        major = 0
+        pass
+    try:
+        minor = int( getVersionMinor( mod ) )
+    except Exception:
+        minor = 0
+        pass
+    try:
+        rel = int( getVersionRelease( mod ) )
+    except Exception:
+        rel = 0
+        pass
+    return [ major, minor, rel ]
+    
+def getXVersion( mod = "KERNEL" ):
+    """
+    Get SALOME module version as list of [major, minor, release] numbers
+    Parameters:
+    - mod  : SALOME module name, default is 'KERNEL'
+    Returns: version numbers list
+    """
+    major, minor, rel = getVersions( mod )
+    return hex( (major<<16) + (minor<<8) + rel )
+
+def isDevelopmentVersion( mod = "KERNEL" ):
+    """
+    Checks if the version of SALOME module is marked as development one
+    Parameters:
+    - mod  : SALOME module name, default is 'KERNEL'
+    Returns: Return True for delopment version of module or False otherwise
+    """
+    ver = getVersion( mod, True )
+    return ver.endswith( "dev" )

salome/kernel/searchFreePort.py

@@ -0,0 +1,130 @@
+#  -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+#
+# Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+# CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+#
+# 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 os
+import sys
+
+def __setup_config(nsport, args, save_config):
+  #
+  from salome.kernel.salome_utils import generateFileName, getHostName
+  hostname = getHostName()
+  #
+  omniorbUserPath = os.getenv("OMNIORB_USER_PATH")
+  kwargs={}
+  if omniorbUserPath is not None:
+    kwargs["with_username"]=True
+  #
+  from salome.kernel.ORBConfigFile_impl import writeORBConfigFile
+  omniorb_config, giopsize = writeORBConfigFile(omniorbUserPath, hostname, nsport, kwargs)
+  args['port'] = os.environ['NSPORT']
+  #
+  if save_config:
+    last_running_config = generateFileName(omniorbUserPath, prefix="omniORB",
+                                           suffix="last",
+                                           extension="cfg",
+                                           hidden=True,
+                                           **kwargs)
+    os.environ['LAST_RUNNING_CONFIG'] = last_running_config
+    try:
+      if sys.platform == "win32":
+        import shutil
+        shutil.copyfile(omniorb_config, last_running_config)
+      else:
+        try:
+          if os.access(last_running_config, os.F_OK):
+            os.remove(last_running_config)
+        except OSError:
+          pass
+        os.symlink(omniorb_config, last_running_config)
+        pass
+      pass
+    except Exception:
+      pass
+  #
+#
+
+def searchFreePort_withPortManager(queue, args={}, save_config=1, use_port=None):
+  from salome.kernel.PortManager import getPort
+  port = getPort(use_port)
+
+  if use_port:
+    print("Check if port can be used: %d" % use_port, end=' ')
+    if port == use_port and port != -1:
+      print("- OK")
+      __setup_config(use_port, args, save_config)
+      queue.put([os.environ['OMNIORB_CONFIG'],
+                 os.environ['NSPORT'],
+                 os.environ['NSHOST']])
+      return
+    else:
+      print("- KO: port is busy")
+      pass
+  #
+  print("Searching for a free port for naming service:", end=' ')
+  if port == -1: # try again
+    port = getPort(use_port)
+
+  if port != -1:
+    print("%s - OK"%(port))
+    __setup_config(port, args, save_config)
+  else:
+    print("Unable to obtain port")
+
+  queue.put([os.environ['OMNIORB_CONFIG'],
+             os.environ['NSPORT'],
+             os.environ['NSHOST']])
+#
+
+def __savePortToFile(args):
+  # Save Naming service port name into
+  # the file args["ns_port_log_file"]
+  if 'ns_port_log_file' in args:
+    omniorbUserPath = os.getenv("OMNIORB_USER_PATH")
+    file_name = os.path.join(omniorbUserPath, args["ns_port_log_file"])
+    with open(file_name, "w") as f:
+      f.write(os.environ['NSPORT'])
+#
+
+def searchFreePort(args={}, save_config=1, use_port=None):
+  """
+  Search free port for SALOME session.
+  Returns first found free port number.
+  """
+  try:
+    import salome.kernel.PortManager # mandatory
+    from multiprocessing import Process, Queue
+    queue = Queue()
+    p = Process(target = searchFreePort_withPortManager, args=(queue, args, save_config, use_port,))
+    p.start()
+    info = queue.get()
+
+    os.environ['OMNIORB_CONFIG'] = info[0]
+    os.environ['NSPORT'] = info[1]
+    args['port'] = os.environ['NSPORT']
+    os.environ['NSHOST'] = info[2]
+    __savePortToFile(args)
+
+    p.join() # this blocks until the process terminates
+  except ImportError:
+    raise Exception('PortManager module not found')
+#

salome/kernel/server.py

@@ -0,0 +1,154 @@
+#  -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+#
+# Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+# CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+#
+# 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 os, sys, string
+from salome.kernel.salome_utils import getHostName
+process_id = {}
+import logging
+
+# -----------------------------------------------------------------------------
+#
+# Definition des classes d'objets pour le lancement des Server CORBA
+#
+
+class Server:
+    """Generic class for CORBA server launch"""
+
+    server_launch_mode = "daemon"
+
+    def initArgs(self):
+        self.PID=None
+        self.CMD=[]
+        self.ARGS=[]
+        if self.args.get('xterm'):
+          if sys.platform != "win32":
+            self.ARGS=['xterm', '-iconic', '-sb', '-sl', '500', '-hold']
+          else:
+            self.ARGS=['cmd', '/c', 'start  cmd.exe', '/K']
+
+    def __init__(self,args):
+        self.args=args
+        self.initArgs()
+
+    @staticmethod
+    def set_server_launch_mode(mode):
+      if mode == "daemon" or mode == "fork":
+        Server.server_launch_mode = mode
+      else:
+        raise Exception("Unsupported server launch mode: %s" % mode)
+
+    def run(self, daemon=False):
+        global process_id
+        myargs=self.ARGS
+        if self.args.get('xterm'):
+            # (Debian) send LD_LIBRARY_PATH to children shells (xterm)
+          if sys.platform == "darwin":
+              env_ld_library_path=['env', 'DYLD_LIBRARY_PATH='
+                                   + os.getenv("DYLD_FALLBACK_LIBRARY_PATH")]
+              myargs = myargs +['-T']+self.CMD[:1]+['-e'] + env_ld_library_path
+          elif sys.platform != "win32":
+              ldPath = "LD_LIBRARY_PATH"
+              env_ld_library_path = []
+              if ldPath in os.environ:
+                env_ld_library_path=['env', f'{ldPath}=' + os.getenv(ldPath)]
+              myargs = myargs +['-T']+self.CMD[:1]+['-e'] + env_ld_library_path
+        command = myargs + self.CMD
+        for sapcfg in ["SalomeAppSLConfig","SalomeAppConfig"]:
+          if sapcfg in os.environ:
+            logging.getLogger().debug("{}={}".format(sapcfg,os.environ[sapcfg]))
+        command1 = (" ".join(command)).replace("(","\\\(") ; command1 = command1.replace(")","\\\)")
+        logging.getLogger().debug("Command to be launched : {}".format(command1))
+        # print("command = ", command)
+        if sys.platform == "win32":
+          import subprocess
+          if daemon:
+            DETACHED_PROCESS = 0x00000008
+            pid = subprocess.Popen(command, creationflags=DETACHED_PROCESS).pid
+          else:
+            pid = subprocess.Popen(command).pid
+        elif Server.server_launch_mode == "fork":
+          pid = os.spawnvp(os.P_NOWAIT, command[0], command)
+        else: # Server launch mode is daemon
+          pid=self.daemonize(command)
+        if pid is not None:
+          #store process pid if it really exists
+          process_id[pid]=self.CMD
+        self.PID = pid
+        logging.getLogger().debug("PID of launched command : {}".format(pid))
+        return pid
+
+    def daemonize(self,args):
+        # to daemonize a process need to do the UNIX double-fork magic
+        # see Stevens, "Advanced Programming in the UNIX Environment" for details (ISBN 0201563177)
+        # and UNIX Programming FAQ 1.7 How do I get my program to act like a daemon?
+        #     http://www.erlenstar.demon.co.uk/unix/faq_2.html#SEC16
+        #open a pipe
+        c2pread, c2pwrite = os.pipe()
+        #do first fork
+        pid=os.fork()
+        if pid > 0:
+          #first parent
+          os.close(c2pwrite)
+          #receive real pid from child
+          data=os.read(c2pread,24) #read 24 bytes
+          os.waitpid(pid,0) #remove zombie
+          os.close(c2pread)
+          # return : first parent
+          childpid=int(data)
+          if childpid==-1:
+            return None
+          try:
+            os.kill(childpid,0)
+            return childpid
+          except Exception:
+            return None
+
+        #first child
+        # decouple from parent environment
+        os.setsid()
+        os.close(c2pread)
+
+        # do second fork : second child not a session leader
+        try:
+          pid = os.fork()
+          if pid > 0:
+            #send real pid to parent
+            pid_str = "%d" % pid
+            os.write(c2pwrite,pid_str.encode())
+            os.close(c2pwrite)
+            # exit from second parent
+            os._exit(0)
+        except OSError as e:
+          print("fork #2 failed: %d (%s)" % (e.errno, e.strerror), file=sys.stderr)
+          os.write(c2pwrite,"-1")
+          os.close(c2pwrite)
+          sys.exit(1)
+
+        #I am a daemon
+        os.close(0) #close stdin
+        os.open("/dev/null", os.O_RDWR)  # redirect standard input (0) to /dev/null
+        try:
+          os.execvp(args[0], args)
+        except OSError as e:
+          print("(%s) launch failed: %d (%s)" % (args[0],e.errno, e.strerror), file=sys.stderr)
+          os._exit(127)

salome/kernel/setenv_impl.py

@@ -0,0 +1,240 @@
+#!/usr/bin/env python3
+#  -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+#
+# Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+# CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+#
+# 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 sys, os, string, glob, time, pickle
+from .launchConfigureParser import verbose
+
+# this file is extraction of set_env from runSalome.py
+# for reusage in automated tests
+
+# salome_subdir variable is used for composing paths like $KERNEL_ROOT_DIR/share/salome/resources, etc.
+# before moving to SUIT-based gui, instead of salome_subdir there was args['appname'] used.
+# but after - 'appname'  = "SalomeApp", so using it in making the subdirectory is an error.
+salome_subdir = "salome"
+
+
+# -----------------------------------------------------------------------------
+
+def add_path(directory, variable_name):
+    """Function helper to add environment variables"""
+    if variable_name not in os.environ:
+        os.environ[variable_name] = ""
+        pass
+    if os.path.exists(directory):
+        newpath=[]
+        for _dir in os.environ[variable_name].split(os.pathsep):
+            if os.path.exists(_dir):
+                if not os.path.samefile(_dir, directory):
+                    newpath.append(_dir)
+            else:
+                if os.path.abspath(_dir) != os.path.abspath(directory):
+                  newpath.append(_dir)
+            pass
+        newpath[:0] = [ directory ]
+        newpath = os.pathsep.join(newpath)
+        os.environ[variable_name] = newpath
+        if variable_name == "PYTHONPATH":
+            sys.path[:0] = [os.path.realpath(directory)]
+
+# -----------------------------------------------------------------------------
+
+__lib__dir__ = None
+def get_lib_dir():
+    global __lib__dir__
+    if __lib__dir__: return __lib__dir__
+    import platform
+    __lib__dir__ = "lib"
+    return __lib__dir__
+
+# -----------------------------------------------------------------------------
+
+def get_config(silent=False, exeName=None, keepEnvironment=True):
+    """
+    Get list of modules, paths.
+
+    Read args from launch configure xml file and command line options.
+    Check variables <module>_ROOT_DIR and set list of used modules.
+    Return args, modules_list, modules_root_dir
+    """
+
+    # read args from launch configure xml file and command line options
+
+
+    from .launchConfigureParser import get_env
+    args = get_env(exeName=exeName, keepEnvironment=keepEnvironment)
+
+
+    # Check variables <module>_ROOT_DIR
+    # and set list of used modules (without KERNEL)
+
+    modules_list = []
+    if "modules" in args:
+        modules_list += [a for a in args["modules"] if a.strip()]
+    # KERNEL must be last in the list to locate it at the first place in PATH
+    if args["gui"] :
+        modules_list[:0] = ["GUI"]
+    modules_list[:0] = ["KERNEL"]
+    modules_list.reverse()
+
+    modules_root_dir = {}
+
+    to_remove_list=[]
+    for module in modules_list :
+        module_variable=module+"_ROOT_DIR"
+        if module_variable not in os.environ:
+            if not silent:
+                print("*******************************************************")
+                print("*")
+                print("* Environment variable",module_variable,"must be set")
+                print("* Module", module, "will be not available")
+                print("*")
+                print("********************************************************")
+                pass
+            to_remove_list.append(module)
+            continue
+            pass
+        module_root_dir = os.environ[module_variable]
+        modules_root_dir[module]=module_root_dir
+
+    for to_remove in to_remove_list:
+        modules_list.remove(to_remove)
+
+    while "KERNEL" in modules_list:
+        modules_list.remove("KERNEL")
+        pass
+
+    while "GUI" in modules_list:
+        modules_list.remove("GUI")
+        pass
+
+    return args, modules_list, modules_root_dir
+
+# -----------------------------------------------------------------------------
+
+def set_env(args, modules_list, modules_root_dir, silent=False, keepEnvironment=True):
+    """Add to the PATH-variables modules specific paths"""
+
+    import os
+    from .salome_utils import getLogDir, generateFileName, makeTmpDir, getPortNumber
+
+    if 'launcher' in args:
+      pos = args['launcher'].find(":")
+      if pos != -1:
+        machine = args['launcher'][0:pos]
+        port = args['launcher'][pos+1:]
+        os.environ["NSPORT"] = port
+
+    # create temporary directory for environment files needed by modules from the list
+    port = getPortNumber(False)
+    if port:
+        tmp_dir = getLogDir()
+        env_dir = generateFileName(tmp_dir, prefix="env", with_port=True)
+        makeTmpDir(env_dir)
+        pass
+
+    python_version="python%d.%d" % sys.version_info[0:2]
+    modules_root_dir_list = []
+    if os.getenv('SALOME_BATCH') == None:
+      os.putenv('SALOME_BATCH','0')
+    if args["gui"] :
+        modules_list = modules_list[:] + ["GUI"]
+    if not keepEnvironment:
+        modules_list = modules_list[:] + ["KERNEL"]
+        for module in modules_list :
+            if module in modules_root_dir:
+                module_root_dir = modules_root_dir[module]
+                if module_root_dir not in modules_root_dir_list:
+                  modules_root_dir_list[:0] = [module_root_dir]
+                if sys.platform == "win32":
+                  add_path(os.path.join(module_root_dir,get_lib_dir(),salome_subdir),
+                         "PATH")
+                elif sys.platform == "darwin":
+                  add_path(os.path.join(module_root_dir,get_lib_dir(),salome_subdir),
+                         "DYLD_LIBRARY_PATH")
+                else:
+                  add_path(os.path.join(module_root_dir,get_lib_dir(),salome_subdir),
+                         "LD_LIBRARY_PATH")
+                add_path(os.path.join(module_root_dir,"bin",salome_subdir),
+                         "PATH")
+                if os.path.exists(os.path.join(module_root_dir, "examples")):
+                    add_path(os.path.join(module_root_dir,"examples"),
+                             "PYTHONPATH")
+                    pass
+                add_path(os.path.join(module_root_dir,"bin",salome_subdir),
+                         "PYTHONPATH")
+                # add lib before site-packages to load script instead of dll if any (win32 platform)
+                add_path(os.path.join(module_root_dir,get_lib_dir(),salome_subdir),
+                         "PYTHONPATH")
+                add_path(os.path.join(module_root_dir,get_lib_dir(),
+                                      python_version,"site-packages",
+                                      salome_subdir),
+                         "PYTHONPATH")
+                import platform
+                if platform.machine() == "x86_64":
+                    add_path(os.path.join(module_root_dir,"lib64",
+                                          python_version,"site-packages",
+                                          salome_subdir),
+                             "PYTHONPATH")
+                    pass
+                add_path(os.path.join(module_root_dir,get_lib_dir(),
+                                      python_version,"site-packages",
+                                      salome_subdir,
+                                      "shared_modules"),
+                         "PYTHONPATH")
+
+                # set environment by modules from the list
+                if port:
+                    try:
+                        import importlib
+                        mod=importlib.import_module(module.lower()+"_setenv")
+                        mod.set_env(args)
+                        pass
+                    except Exception:
+                        pass
+                    pass
+                pass
+            pass
+
+        if sys.platform == 'win32':
+            os.environ["SALOMEPATH"]=";".join(modules_root_dir_list)
+        else:
+            os.environ["SALOMEPATH"]=":".join(modules_root_dir_list)
+
+        pass
+    # set trace environment variable
+
+    if "SALOME_trace" not in os.environ:
+        os.environ["SALOME_trace"]="local"
+    if args['file']:
+        os.environ["SALOME_trace"]="file:"+args['file'][0]
+    if args['logger']:
+        os.environ["SALOME_trace"]="with_logger"
+
+# -----------------------------------------------------------------------------
+
+def main(silent=False, exeName=None):
+    keep_env = not os.getenv('SALOME_PLEASE_SETUP_ENVIRONMENT_AS_BEFORE')
+    args, modules_list, modules_root_dir = get_config(silent=silent, exeName=exeName, keepEnvironment=keep_env)
+    set_env(args, modules_list, modules_root_dir, silent=silent, keepEnvironment=keep_env)
+    return args