Classes
class	Packages

Functions
def	getVersionFromPythonModule (module)

def	getPythonPackages ()

def	getEnvironmentPackages ()

def	getCondaPackages ()

def	pkg_representer (dumper, data)

def	pkg_constructor (loader, node)

Variables
	log = logging.getLogger(__name__)

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

	PYTHON = set(["galsim"])

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

	pkg_constructor

	Loader

Function Documentation

◆ getCondaPackages()

def lsst.base.packages.getCondaPackages ( )

Get products and their versions from the conda environment.

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

Notes
-----
Returns empty result if a conda environment is not in use or can not
be queried.

Definition at line 223 of file packages.py.

 def getCondaPackages():
     """Get products and their versions from the conda environment.
  
     Returns
     -------
     packages : `dict`
         Keys (type `str`) are product names; values (type `str`) are their
         versions.
  
     Notes
     -----
     Returns empty result if a conda environment is not in use or can not
     be queried.
     """
  
     try:
         import json
         from conda.cli.python_api import Commands, run_command
     except ImportError:
         return {}
  
     # Get the installed package list
     versions_json = run_command(Commands.LIST, "--json")
     packages = {pkg["name"]: pkg["version"] for pkg in json.loads(versions_json[0])}
  
     # Try to work out the conda environment name and include it as a fake
     # package. The "obvious" way of running "conda info --json" does give
     # access to the active_prefix but takes about 2 seconds to run.
     # The equivalent to the code above would be:
     #    info_json = run_command(Commands.INFO, "--json")
     # As a comporomise look for the env name in the path to the python
     # executable
     match = re.search(r"/envs/(.*?)/bin/", sys.executable)
     if match:
         packages["conda_env"] = match.group(1)
  
     return packages
  
  

◆ getEnvironmentPackages()

def lsst.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 154 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
  
  
 @lru_cache(maxsize=1)

◆ getPythonPackages()

def lsst.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 92 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 lsst.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 57 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 str(version)
  
  

◆ pkg_constructor()

def lsst.base.packages.pkg_constructor	(	loader,
		node
	)

Definition at line 527 of file packages.py.

 def pkg_constructor(loader, node):
     yield Packages(loader.construct_mapping(node, deep=True))

◆ pkg_representer()

def lsst.base.packages.pkg_representer	(	dumper,
		data
	)

Represent Packages as a simple dict

Definition at line 518 of file packages.py.

 def pkg_representer(dumper, data):
     """Represent Packages as a simple dict"""
     return dumper.represent_mapping("lsst.base.Packages", data._packages,
                                     flow_style=None)
  
 yaml.add_representer(Packages, pkg_representer)

Variable Documentation

◆ BUILDTIME

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

Definition at line 45 of file packages.py.

◆ ENVIRONMENT

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

Definition at line 54 of file packages.py.

◆ Loader

lsst.base.packages.Loader

Definition at line 532 of file packages.py.

◆ log

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

Definition at line 38 of file packages.py.

◆ pkg_constructor

lsst.base.packages.pkg_constructor