lsst.daf.butlerUtils.mapping.Mapping Class Reference

Inheritance diagram for lsst.daf.butlerUtils.mapping.Mapping:

Public Member Functions
def	__init__
def	keys
def	map
def	lookup
def	have
def	need

Public Attributes
	datasetType
	registry
	root
	template
	keyDict
	python
	persistable
	storage
	level
	tables
	range
	columns
	obsTimeName

Detailed Description

Mapping is a base class for all mappings.  Mappings are used by
the Mapper to map (determine a path to some data given some
identifiers) and standardize (convert data into some standard
format or type) data, and to query the associated registry to see
what data is available.

Subclasses must specify self.storage or else override self.map().

Public methods: lookup, have, need, getKeys, map

Mappings are specified mainly by policy.  A Mapping policy should
consist of:

template (string): a Python string providing the filename for that
particular dataset type based on some data identifiers.  In the
case of redundancy in the path (e.g., file uniquely specified by
the exposure number, but filter in the path), the
redundant/dependent identifiers can be looked up in the registry.

python (string): the Python type for the retrieved data (e.g.
lsst.afw.image.ExposureF)

persistable (string): the Persistable registration for the on-disk data
(e.g. ImageU)

storage (string, optional): Storage type for this dataset type (e.g.
"BoostStorage")

level (string, optional): the level in the camera hierarchy at which the
data is stored (Amp, Ccd or skyTile), if relevant

tables (string, optional): a whitespace-delimited list of tables in the
registry that can be NATURAL JOIN-ed to look up additional
information.  

Definition at line 31 of file mapping.py.

Constructor & Destructor Documentation

def lsst.daf.butlerUtils.mapping.Mapping.__init__	(		self,
			datasetType,
			policy,
			registry,
			root,
			provided = None
	)

Constructor for Mapping class.
@param datasetType    (string)
@param policy         (lsst.pex.policy.Policy) Mapping policy
@param registry       (lsst.daf.butlerUtils.Registry) Registry for metadata lookups
@param root           (string) Path of root directory
@param provided       (list of strings) Keys provided by the mapper

Definition at line 68 of file mapping.py.

    def __init__(self, datasetType, policy, registry, root, provided=None):
        """Constructor for Mapping class.
        @param datasetType    (string)
        @param policy         (lsst.pex.policy.Policy) Mapping policy
        @param registry       (lsst.daf.butlerUtils.Registry) Registry for metadata lookups
        @param root           (string) Path of root directory
        @param provided       (list of strings) Keys provided by the mapper
        """

        if policy is None:
            raise RuntimeError, "No policy provided for mapping"

        self.datasetType = datasetType
        self.registry = registry
        self.root = root

        self.template = policy.getString("template") # Template path
        self.keyDict = dict([
            (k, _formatMap(v, k, datasetType))
            for k, v in
            re.findall(r'\%\((\w+)\).*?([diouxXeEfFgGcrs])', self.template)
            ])
        if provided is not None:
            for p in provided:
                if p in self.keyDict:
                    del self.keyDict[p]
        self.python = policy.getString("python") # Python type
        self.persistable = policy.getString("persistable") # Persistable type
        self.storage = policy.getString("storage")
        if policy.exists("level"):
            self.level = policy.getString("level") # Level in camera hierarchy
        if policy.exists("tables"):
            self.tables = policy.getStringArray("tables")
        else:
            self.tables = None
        self.range = None
        self.columns = None
        self.obsTimeName = policy.getString("obsTimeName") \
                if policy.exists("obsTimeName") else None