base.packages Namespace Reference

Classes
class	Packages

Functions
def	getVersionFromPythonModule (module)
def	getPythonPackages ()
def	getEnvironmentPackages ()

Variables
	log = logging.getLogger(__name__)
	BUILDTIME = set(["boost", "eigen", "tmv"])
	PYTHON = set(["galsim"])
	ENVIRONMENT = set(["astrometry_net", "astrometry_net_data", "minuit2", "xpa"])

Function Documentation

getEnvironmentPackages()

def base.packages.getEnvironmentPackages

(

)

Get products and their versions from the environment.

Returns
-------
packages : `dict`
    Keys (type `str`) are product names; values (type `str`) are their
    versions.

Notes
-----
We use EUPS to determine the version of certain products (those that don't
provide a means to determine the version any other way) and to check if
uninstalled packages are being used. We only report the product/version
for these packages.

Definition at line 145 of file packages.py.

def getEnvironmentPackages():
    """Get products and their versions from the environment.
 
    Returns
    -------
    packages : `dict`
        Keys (type `str`) are product names; values (type `str`) are their
        versions.
 
    Notes
    -----
    We use EUPS to determine the version of certain products (those that don't
    provide a means to determine the version any other way) and to check if
    uninstalled packages are being used. We only report the product/version
    for these packages.
    """
    try:
        from eups import Eups
        from eups.Product import Product
    except ImportError:
        log.warning("Unable to import eups, so cannot determine package versions from environment")
        return {}
 
    # Cache eups object since creating it can take a while
    global _eups
    if not _eups:
        _eups = Eups()
    products = _eups.findProducts(tags=["setup"])
 
    # Get versions for things we can't determine via runtime mechanisms
    # XXX Should we just grab everything we can, rather than just a predetermined set?
    packages = {prod.name: prod.version for prod in products if prod in ENVIRONMENT}
 
    # The string 'LOCAL:' (the value of Product.LocalVersionPrefix) in the version name indicates uninstalled
    # code, so the version could be different than what's being reported by the runtime environment (because
    # we don't tend to run "scons" every time we update some python file, and even if we did sconsUtils
    # probably doesn't check to see if the repo is clean).
    for prod in products:
        if not prod.version.startswith(Product.LocalVersionPrefix):
            continue
        ver = prod.version
 
        gitDir = os.path.join(prod.dir, ".git")
        if os.path.exists(gitDir):
            # get the git revision and an indication if the working copy is clean
            revCmd = ["git", "--git-dir=" + gitDir, "--work-tree=" + prod.dir, "rev-parse", "HEAD"]
            diffCmd = ["git", "--no-pager", "--git-dir=" + gitDir, "--work-tree=" + prod.dir, "diff",
                       "--patch"]
            try:
                rev = subprocess.check_output(revCmd).decode().strip()
                diff = subprocess.check_output(diffCmd)
            except Exception:
                ver += "@GIT_ERROR"
            else:
                ver += "@" + rev
                if diff:
                    ver += "+" + hashlib.md5(diff).hexdigest()
        else:
            ver += "@NO_GIT"
 
        packages[prod.name] = ver
    return packages
 
 

getPythonPackages()

def base.packages.getPythonPackages

(

)

Get imported python packages and their versions.

Returns
-------
packages : `dict`
    Keys (type `str`) are package names; values (type `str`) are their
    versions.

Notes
-----
We wade through `sys.modules` and attempt to determine the version for each
module.  Note, therefore, that we can only report on modules that have
*already* been imported.

We don't include any module for which we cannot determine a version.

Definition at line 87 of file packages.py.

def getPythonPackages():
    """Get imported python packages and their versions.
 
    Returns
    -------
    packages : `dict`
        Keys (type `str`) are package names; values (type `str`) are their
        versions.
 
    Notes
    -----
    We wade through `sys.modules` and attempt to determine the version for each
    module.  Note, therefore, that we can only report on modules that have
    *already* been imported.
 
    We don't include any module for which we cannot determine a version.
    """
    # Attempt to import libraries that only report their version in python
    for module in PYTHON:
        try:
            importlib.import_module(module)
        except Exception:
            pass  # It's not available, so don't care
 
    packages = {"python": sys.version}
    # Not iterating with sys.modules.iteritems() because it's not atomic and subject to race conditions
    moduleNames = list(sys.modules.keys())
    for name in moduleNames:
        module = sys.modules[name]
        try:
            ver = getVersionFromPythonModule(module)
        except Exception:
            continue  # Can't get a version from it, don't care
 
        # Remove "foo.bar.version" in favor of "foo.bar"
        # This prevents duplication when the __init__.py includes "from .version import *"
        for ending in (".version", "._version"):
            if name.endswith(ending):
                name = name[:-len(ending)]
                if name in packages:
                    assert ver == packages[name]
            elif name in packages:
                assert ver == packages[name]
 
        # Use LSST package names instead of python module names
        # This matches the names we get from the environment (i.e., EUPS) so we can clobber these build-time
        # versions if the environment reveals that we're not using the packages as-built.
        if "lsst" in name:
            name = name.replace("lsst.", "").replace(".", "_")
 
        packages[name] = ver
 
    return packages
 
 

getVersionFromPythonModule()

def base.packages.getVersionFromPythonModule

(

module

)

Determine the version of a python module.

Parameters
----------
module : `module`
    Module for which to get version.

Returns
-------
version : `str`

Raises
------
AttributeError
    Raised if __version__ attribute is not set.

Notes
-----
We supplement the version with information from the
``__dependency_versions__`` (a specific variable set by LSST's
`~lsst.sconsUtils` at build time) only for packages that are typically
used only at build-time.

Definition at line 52 of file packages.py.

def getVersionFromPythonModule(module):
    """Determine the version of a python module.
 
    Parameters
    ----------
    module : `module`
        Module for which to get version.
 
    Returns
    -------
    version : `str`
 
    Raises
    ------
    AttributeError
        Raised if __version__ attribute is not set.
 
    Notes
    -----
    We supplement the version with information from the
    ``__dependency_versions__`` (a specific variable set by LSST's
    `~lsst.sconsUtils` at build time) only for packages that are typically
    used only at build-time.
    """
    version = module.__version__
    if hasattr(module, "__dependency_versions__"):
        # Add build-time dependencies
        deps = module.__dependency_versions__
        buildtime = BUILDTIME & set(deps.keys())
        if buildtime:
            version += " with " + " ".join("%s=%s" % (pkg, deps[pkg])
                                           for pkg in sorted(buildtime))
    return version
 
 

Variable Documentation

BUILDTIME

base.packages.BUILDTIME = set(["boost", "eigen", "tmv"])

Definition at line 41 of file packages.py.

ENVIRONMENT

base.packages.ENVIRONMENT = set(["astrometry_net", "astrometry_net_data", "minuit2", "xpa"])

Definition at line 49 of file packages.py.

log

base.packages.log = logging.getLogger(__name__)

Definition at line 35 of file packages.py.

PYTHON

base.packages.PYTHON = set(["galsim"])

Definition at line 45 of file packages.py.