Public Member Functions
def	__init__ (self, packages)

def	fromSystem (cls)

def	read (cls, filename)

def	write (self, filename)

def	__len__ (self)

def	__str__ (self)

def	__repr__ (self)

def	__contains__ (self, pkg)

def	__iter__ (self)

def	update (self, other)

def	extra (self, other)

def	missing (self, other)

def	difference (self, other)

Detailed Description

A table of packages and their versions.

There are a few different types of packages, and their versions are collected
in different ways:

1. Run-time libraries (e.g., cfitsio, fftw): we get their version from
   interrogating the dynamic library
2. Python modules (e.g., afw, numpy; galsim is also in this group even though
   we only use it through the library, because no version information is
   currently provided through the library): we get their version from the
   ``__version__`` module variable. Note that this means that we're only aware
   of modules that have already been imported.
3. Other packages provide no run-time accessible version information (e.g.,
   astrometry_net): we get their version from interrogating the environment.
   Currently, that means EUPS; if EUPS is replaced or dropped then we'll need
   to consider an alternative means of getting this version information.
4. Local versions of packages (a non-installed EUPS package, selected with
   ``setup -r /path/to/package``): we identify these through the environment
   (EUPS again) and use as a version the path supplemented with the ``git``
   SHA and, if the git repo isn't clean, an MD5 of the diff.

These package versions are collected and stored in a Packages object, which
provides useful comparison and persistence features.

Example usage:

.. code-block:: python

    from lsst.base import Packages
    pkgs = Packages.fromSystem()
    print("Current packages:", pkgs)
    old = Packages.read("/path/to/packages.pickle")
    print("Old packages:", old)
    print("Missing packages compared to before:", pkgs.missing(old))
    print("Extra packages compared to before:", pkgs.extra(old))
    print("Different packages: ", pkgs.difference(old))
    old.update(pkgs)  # Include any new packages in the old
    old.write("/path/to/packages.pickle")

Parameters
----------
packages : `dict`
    A mapping {package: version} where both keys and values are type `str`.

Notes
-----
This is essentially a wrapper around a dict with some conveniences.

Definition at line 209 of file packages.py.

Constructor & Destructor Documentation

◆ init()

def base.packages.Packages.__init__	(	self,
		packages
	)

Definition at line 259 of file packages.py.

     def __init__(self, packages):
         assert isinstance(packages, Mapping)
         self._packages = packages
         self._names = set(packages.keys())
 

Member Function Documentation

◆ contains()

def base.packages.Packages.__contains__	(	self,
		pkg
	)

Definition at line 322 of file packages.py.

     def __contains__(self, pkg):
         return pkg in self._packages
 

◆ iter()

def base.packages.Packages.__iter__ ( self )

Definition at line 325 of file packages.py.

     def __iter__(self):
         return iter(self._packages)
 

◆ len()

def base.packages.Packages.__len__ ( self )

Definition at line 308 of file packages.py.

     def __len__(self):
         return len(self._packages)
 

◆ repr()

def base.packages.Packages.__repr__ ( self )

Definition at line 319 of file packages.py.

     def __repr__(self):
         return "%s(%s)" % (self.__class__.__name__, repr(self._packages))
 

◆ str()

def base.packages.Packages.__str__ ( self )

Definition at line 311 of file packages.py.

     def __str__(self):
         ss = "%s({\n" % self.__class__.__name__
         # Sort alphabetically by module name, for convenience in reading
         ss += ",\n".join("%s: %s" % (repr(prod), repr(self._packages[prod])) for
                          prod in sorted(self._names))
         ss += ",\n})"
         return ss
 

◆ difference()

def base.packages.Packages.difference	(	self,
		other
	)

Get packages in symmetric difference of self and another `Packages`
object.

Parameters
----------
other : `Packages`
    Other packages to compare against.

Returns
-------
difference : `dict`
    Packages in symmetric difference.  Keys (type `str`) are package
    names; values (type `str`) are their versions.

Definition at line 375 of file packages.py.

     def difference(self, other):
         """Get packages in symmetric difference of self and another `Packages`
         object.
 
         Parameters
         ----------
         other : `Packages`
             Other packages to compare against.
 
         Returns
         -------
         difference : `dict`
             Packages in symmetric difference.  Keys (type `str`) are package
             names; values (type `str`) are their versions.
         """
         return {pkg: (self._packages[pkg], other._packages[pkg]) for
                 pkg in self._names & other._names if self._packages[pkg] != other._packages[pkg]}
 

◆ extra()

def base.packages.Packages.extra	(	self,
		other
	)

Get packages in self but not in another `Packages` object.

Parameters
----------
other : `Packages`
    Other packages to compare against.

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

Definition at line 343 of file packages.py.

     def extra(self, other):
         """Get packages in self but not in another `Packages` object.
 
         Parameters
         ----------
         other : `Packages`
             Other packages to compare against.
 
         Returns
         -------
         extra : `dict`
             Extra packages. Keys (type `str`) are package names; values
             (type `str`) are their versions.
         """
         return {pkg: self._packages[pkg] for pkg in self._names - other._names}
 

◆ fromSystem()

def base.packages.Packages.fromSystem ( cls )

Construct a `Packages` by examining the system.

Determine packages by examining python's `sys.modules`, runtime
libraries and EUPS.

Returns
-------
packages : `Packages`

Definition at line 265 of file packages.py.

     def fromSystem(cls):
         """Construct a `Packages` by examining the system.
 
         Determine packages by examining python's `sys.modules`, runtime
         libraries and EUPS.
 
         Returns
         -------
         packages : `Packages`
         """
         packages = {}
         packages.update(getPythonPackages())
         packages.update(getRuntimeVersions())
         packages.update(getEnvironmentPackages())  # Should be last, to override products with LOCAL versions
         return cls(packages)
 

◆ missing()

def base.packages.Packages.missing	(	self,
		other
	)

Get packages in another `Packages` object but missing from self.

Parameters
----------
other : `Packages`
    Other packages to compare against.

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

Definition at line 359 of file packages.py.

     def missing(self, other):
         """Get packages in another `Packages` object but missing from self.
 
         Parameters
         ----------
         other : `Packages`
             Other packages to compare against.
 
         Returns
         -------
         missing : `dict`
             Missing packages. Keys (type `str`) are package names; values
             (type `str`) are their versions.
         """
         return {pkg: other._packages[pkg] for pkg in other._names - self._names}
 

◆ read()

def base.packages.Packages.read	(	cls,
		filename
	)

Read packages from filename.

Parameters
----------
filename : `str`
    Filename from which to read.

Returns
-------
packages : `Packages`

Definition at line 282 of file packages.py.

     def read(cls, filename):
         """Read packages from filename.
 
         Parameters
         ----------
         filename : `str`
             Filename from which to read.
 
         Returns
         -------
         packages : `Packages`
         """
         with open(filename, "rb") as ff:
             return pickle.load(ff)
 

◆ update()

def base.packages.Packages.update	(	self,
		other
	)

Update packages with contents of another set of packages.

Parameters
----------
other : `Packages`
    Other packages to merge with self.

Notes
-----
No check is made to see if we're clobbering anything.

Definition at line 328 of file packages.py.

     def update(self, other):
         """Update packages with contents of another set of packages.
 
         Parameters
         ----------
         other : `Packages`
             Other packages to merge with self.
 
         Notes
         -----
         No check is made to see if we're clobbering anything.
         """
         self._packages.update(other._packages)
         self._names.update(other._names)
 

◆ write()

def base.packages.Packages.write	(	self,
		filename
	)

Write to file.

Parameters
----------
filename : `str`
    Filename to which to write.

Definition at line 297 of file packages.py.

     def write(self, filename):
         """Write to file.
 
         Parameters
         ----------
         filename : `str`
             Filename to which to write.
         """
         with open(filename, "wb") as ff:
             pickle.dump(self, ff)
 

The documentation for this class was generated from the following file:

/j/snowflake/release/lsstsw/stack/Linux64/base/19.0.0-1-g425ff20/python/lsst/base/packages.py

Public Member Functions