Coverage for python/lsst/daf/butler/core/datasets.py : 40%

Hot-keys on this page
r m x p toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
# This file is part of daf_butler. # # Developed for the LSST Data Management System. # This product includes software developed by the LSST Project # (http://www.lsst.org). # See the COPYRIGHT file at the top-level directory of this distribution # for details of code ownership. # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>.
if data is None: data = {} return MappingProxyType(data)
r"""A named category of Datasets that defines how they are organized, related, and stored.
A concrete, final class whose instances represent `DatasetType`\ s. `DatasetType` instances may be constructed without a `Registry`, but they must be registered via `Registry.registerDatasetType()` before corresponding Datasets may be added. `DatasetType` instances are immutable.
Parameters ---------- name : `str` A string name for the Dataset; must correspond to the same `DatasetType` across all Registries. dataUnits : `iterable` of `str` `DataUnit` names that defines the `DatasetRef`\ s corresponding to this `DatasetType`. The input iterable is copied into a `frozenset`. storageClass : `StorageClass` Instance of a `StorageClass` that defines how this `DatasetType` is persisted. """
return "DatasetType({}, {}, {})".format(self.name, self.storageClass.name, self.dataUnits)
def nameWithComponent(datasetTypeName, componentName): """Form a valid DatasetTypeName from a parent and component.
No validation is performed.
Parameters ---------- datasetTypeName : `str` Base type name. componentName : `str` Name of component.
Returns ------- compTypeName : `str` Name to use for component DatasetType. """ return "{}.{}".format(datasetTypeName, componentName)
def name(self): """A string name for the Dataset; must correspond to the same `DatasetType` across all Registries. """ return self._name
def dataUnits(self): r"""A `frozenset` of `DataUnit` names that defines the `DatasetRef`\ s corresponding to this `DatasetType`. """ return self._dataUnits
def storageClass(self): """`StorageClass` instance that defines how this `DatasetType` is persisted. """ return self._storageClass
self._name = name self._dataUnits = frozenset(dataUnits) assert isinstance(storageClass, StorageClass) self._storageClass = storageClass
"""Component name (if defined)
Returns ------- comp : `str` Name of component part of DatasetType name. `None` if this `DatasetType` is not associated with a component. """ comp = None if "." in self.name: _, comp = self.name.split(".", maxsplit=1) return comp
"""Given a component name, derive the datasetTypeName of that component
Parameters ---------- component : `str` Name of component
Returns ------- derived : `str` Compound name of this `DatasetType` and the component.
Raises ------ KeyError Requested component is not supported by this `DatasetType`. """ if component in self.storageClass.components: return self.nameWithComponent(self.name, component) raise KeyError("Requested component ({}) not understood by this DatasetType".format(component))
"""Boolean indicating whether this `DatasetType` is a composite type.
Returns ------- isComposite : `bool` `True` if this `DatasetType` is a composite type, `False` otherwise. """ return self.storageClass.isComposite()
"""Names to use when looking up this datasetType in a configuration.
The names are returned in order of priority.
Returns ------- names : `tuple` of `str` Tuple of the `DatasetType` name and the `StorageClass` name. """ return (self.name, *self.storageClass._lookupNames())
"""Support for pickling.
StorageClass instances can not normally be pickled, so we need special code to pickle those. We pickle StorageClass name instead of instance and retrieve the instance using that name when un-pickling.
Returns ------- state : `dict` Instance state to pickle. """ return dict(name=self.name, storageClassName=self.storageClass.name, dataUnits=self.dataUnits)
"""Support for un-pickling.
Uses state dictionary produced by `__getstate__`.
This method retrieves StorageClass instance from StorageClassFactory which has to be properly initialized.
Parameters ---------- state : `dict` Pickled instance state. """ storageClass = StorageClassFactory().getStorageClass(state["storageClassName"]) self.__init__(name=state["name"], dataUnits=state["dataUnits"], storageClass=storageClass)
"""Support for deep copy method.
If ``__getstate__`` and ``__setstate__`` methods are defined ``deepcopy`` will use those methods. We want to avoid that because it would need initialized StorageClassFactory, instead re-implement ``__deepcopy__`` method. """ return DatasetType(name=deepcopy(self.name, memo), dataUnits=deepcopy(self.dataUnits, memo), storageClass=deepcopy(self.storageClass, memo))
"""Reference to a Dataset in a `Registry`.
A `DatasetRef` may point to a Dataset that currently does not yet exist (e.g., because it is a predicted input for provenance).
Parameters ---------- datasetType : `DatasetType` The `DatasetType` for this Dataset. dataId : `dict` A `dict` of `DataUnit` link name, value pairs that label the `DatasetRef` within a Collection. id : `int`, optional A unique identifier. Normally set to `None` and assigned by `Registry` """
"_predictedConsumers", "_actualConsumers", "_components")
assert isinstance(datasetType, DatasetType) self._id = id self._datasetType = datasetType self._dataId = dataId self._producer = None self._predictedConsumers = dict() self._actualConsumers = dict() self._components = dict() self._run = run
def id(self): """Primary key of the dataset (`int`)
Typically assigned by `Registry`. """ return self._id
def datasetType(self): """The `DatasetType` associated with the Dataset the `DatasetRef` points to. """ return self._datasetType
def dataId(self): """A `dict` of `DataUnit` link name, value pairs that label the `DatasetRef` within a Collection. """ return self._dataId
def producer(self): """The `Quantum` instance that produced (or will produce) the Dataset.
Read-only; update via `Registry.addDataset()`, `QuantumGraph.addDataset()`, or `Butler.put()`. May be `None` if no provenance information is available. """ return self._producer
def run(self): """The `Run` instance that produced (or will produce) the Dataset.
Read-only; update via `Registry.addDataset()` or `Butler.put()`. """ return self._run
def predictedConsumers(self): """A sequence of `Quantum` instances that list this Dataset in their `predictedInputs` attributes.
Read-only; update via `Quantum.addPredictedInput()`. May be an empty list if no provenance information is available. """ return _safeMakeMappingProxyType(self._predictedConsumers)
def actualConsumers(self): """A sequence of `Quantum` instances that list this Dataset in their `actualInputs` attributes.
Read-only; update via `Registry.markInputUsed()`. May be an empty list if no provenance information is available. """ return _safeMakeMappingProxyType(self._actualConsumers)
def components(self): """Named `DatasetRef` components.
Read-only; update via `Registry.attachComponent()`. """ return _safeMakeMappingProxyType(self._components)
components = "" if self.components: components = ", components=[" + ", ".join(self.components) + "]" return "DatasetRef({}, id={}, dataId={} {})".format(self.datasetType.name, self.id, self.dataId, components)
"""Obtain a new DatasetRef that is detached from the registry.
Its ``id`` property will be `None`. This can be used for transfers and similar operations. """ ref = deepcopy(self) ref._id = None return ref
"""Boolean indicating whether this `DatasetRef` is a composite type.
Returns ------- isComposite : `bool` `True` if this `DatasetRef` is a composite type, `False` otherwise. """ return self.datasetType.isComposite()
"""Names to use when looking up this DatasetRef in a configuration.
The names are returned in order of priority.
Returns ------- names : `tuple` of `str` Tuple of the `DatasetType` name and the `StorageClass` name. """ return self.datasetType._lookupNames() |