utils.py

Go to the documentation of this file.

import os
import sys
import warnings
import subprocess
import platform
import SCons.Script



class Log:

    def __init__(self):
        self.traceback = False
        self.verbose = True

    def info(self, message):
        if self.verbose:
            print(message)

    def warn(self, message):
        if self.traceback:
            warnings.warn(message, stacklevel=2)
        else:
            print(message, file=sys.stderr)

    def fail(self, message):
        if self.traceback:
            raise RuntimeError(message)
        else:
            if message:
                print(message, file=sys.stderr)
            SCons.Script.Exit(1)

    def flush(self):
        sys.stderr.flush()



def _has_OSX_SIP():
    hasSIP = False
    os_platform = SCons.Platform.platform_default()
    # SIP is enabled on OS X >=10.11 equivalent to darwin >= 15
    if os_platform == 'darwin':
        release_str = platform.release()
        release_major = int(release_str.split('.')[0])
        if release_major >= 15:
            hasSIP = True
    return hasSIP



def libraryPathPassThrough():
    if _has_OSX_SIP():
        return "DYLD_LIBRARY_PATH"
    return None


# Cache variable for whichPython() function
_pythonPath = None



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



def needShebangRewrite():
    return _has_OSX_SIP()



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



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()



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