Classes
class	Log
	A dead-simple logger for all messages. More...

Functions
def	libraryPathPassThrough ()
	Returns name of library path environment variable to be passed through or else returns None if no pass through is required on this platform. More...

def	whichPython ()
	Returns the full path to the Python executable as determined from the PATH. More...

def	needShebangRewrite ()
	Returns True if the shebang lines of executables should be rewritten. More...

def	libraryLoaderEnvironment ()
	Returns library loader path environment string to be prepended to external commands Will be "" if nothing is required. More...

def	runExternal (cmd, fatal=False, msg=None)
	Safe wrapper for running external programs, reading stdout, and sanitizing error messages. More...

def	memberOf (cls, name=None)
	A Python decorator that injects functions into a class. More...

Function Documentation

◆ libraryLoaderEnvironment()

def lsst.sconsUtils.utils.libraryLoaderEnvironment ( )

Returns library loader path environment string to be prepended to external commands Will be "" if nothing is required.

If we have an OS X with System Integrity Protection enabled or similar we need to pass through both DYLD_LIBRARY_PATH and LSST_LIBRARY_PATH to the external command. DYLD_LIBRARY_PATH for Python code LSST_LIBRARY_PATH for shell scripts

If both are already defined then pass them each through If only one is defined, then set both to the defined env variable If neither is defined then pass through nothing.

Definition at line 116 of file utils.py.

 def libraryLoaderEnvironment():
     libpathstr = ""
     lib_pass_through_var = libraryPathPassThrough()
     aux_pass_through_var = "LSST_LIBRARY_PATH"
     if lib_pass_through_var is not None:
         for varname in (lib_pass_through_var, aux_pass_through_var):
             if varname in os.environ:
                 libpathstr += '{}="{}" '.format(varname, os.environ[varname])
 
         if aux_pass_through_var in os.environ and \
            lib_pass_through_var not in os.environ:
             libpathstr += '{}="{}" '.format(lib_pass_through_var, os.environ[aux_pass_through_var])
 
         if lib_pass_through_var in os.environ and \
            aux_pass_through_var not in os.environ:
             libpathstr += '{}="{}" '.format(aux_pass_through_var, os.environ[lib_pass_through_var])
 
     return libpathstr
 
 

◆ libraryPathPassThrough()

def lsst.sconsUtils.utils.libraryPathPassThrough ( )

Returns name of library path environment variable to be passed through or else returns None if no pass through is required on this platform.

Definition at line 70 of file utils.py.

 def libraryPathPassThrough():
     if _has_OSX_SIP():
         return "DYLD_LIBRARY_PATH"
     return None
 
 
 # Cache variable for whichPython() function

◆ memberOf()

def lsst.sconsUtils.utils.memberOf	(	cls,
		name = `None`
	)

A Python decorator that injects functions into a class.

For example:

class test_class:
    pass
@memberOf(test_class):
def test_method(self):
    print "test_method!"

...will cause test_method to appear as as if it were defined within test_class.

The function or method will still be added to the module scope as well, replacing any existing module-scope function with that name; this appears to be unavoidable.

Definition at line 185 of file utils.py.

 def memberOf(cls, name=None):
     if isinstance(cls, type):
         classes = (cls,)
     else:
         classes = tuple(cls)
     kw = {"name": name}
 
     def nested(member):
         if kw["name"] is None:
             kw["name"] = member.__name__
         for scope in classes:
             setattr(scope, kw["name"], member)
         return member
     return nested

◆ needShebangRewrite()

def lsst.sconsUtils.utils.needShebangRewrite ( )

Returns True if the shebang lines of executables should be rewritten.

Definition at line 98 of file utils.py.

 def needShebangRewrite():
     return _has_OSX_SIP()

◆ runExternal()

def lsst.sconsUtils.utils.runExternal	(	cmd,
		fatal = `False`,
		msg = `None`
	)

Safe wrapper for running external programs, reading stdout, and sanitizing error messages.

Command can be given as a list/tuple of command with separate options.

Note that the entire program output is returned, not just a single line.

Returns: Strings not bytes.

Definition at line 144 of file utils.py.

 def runExternal(cmd, fatal=False, msg=None):
     if msg is None:
         try:
             msg = "Error running %s" % cmd.split()[0]
         except Exception:
             msg = "Error running external command"
 
     # Run with shell unless given a list of options
     shell = True
     if isinstance(cmd, (list, tuple)):
         shell = False
 
     try:
         retval = subprocess.run(cmd, shell=shell, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
                                 check=True)
     except subprocess.CalledProcessError as e:
         if fatal:
             raise RuntimeError(f"{msg}: {e.stderr.decode()}") from e
         else:
             from . import state  # can't import at module scope due to circular dependency
             state.log.warn(f"{msg}: {e.stderr}")
     return retval.stdout.decode().strip()
 
 

◆ whichPython()

def lsst.sconsUtils.utils.whichPython ( )

Returns the full path to the Python executable as determined from the PATH.

Does not return the full path of the Python running SCons. Caches result and assumes the PATH does not change between calls. Runs the "python" command and asks where it is rather than scanning the PATH.

Definition at line 87 of file utils.py.

 def whichPython():
     global _pythonPath
     if _pythonPath is None:
         _pythonPath = runExternal(["python", "-c", "import sys; print(sys.executable)"],
                                   fatal=True, msg="Error getting python path")
     return _pythonPath
 
 

Classes