MockStorageClass

class lsst.pipe.base.tests.mocks.MockStorageClass(original: StorageClass, factory: StorageClassFactory | None = None)

Bases: StorageClass

A reimplementation of lsst.daf.butler.StorageClass for mock datasets.

Each MockStorageClass instance corresponds to a real “original” storage class, with components and conversions that are mocks of the original’s components and conversions. The pytype for all MockStorageClass instances is MockDataset.

Attributes Summary

components	Return the components associated with this StorageClass.
converters	Return the type converters supported by this StorageClass.
defaultDelegateName
delegateClass	Class to use to delegate type-specific actions.
derivedComponents	Return derived components associated with StorageClass.
parameters	Return set of names of supported parameters.
pytype	Return Python type associated with this StorageClass.

Methods Summary

allComponents()	Return all defined components.
can_convert(other)	Return True if this storage class can convert python types in the other storage class.
coerce_type(incorrect)	Coerce the supplied incorrect instance to the python type associated with this StorageClass.
delegate()	Return an instance of a storage class delegate.
filterParameters(parameters[, subset])	Filter out parameters that are not known to this StorageClass.
get_or_register_mock(original[, factory])	Return a mock storage class for the given original storage class, creating and registering it if necessary.
isComposite()	Return Boolean indicating whether this is a composite or not.
is_type(other[, compare_types])	Return Boolean indicating whether the supplied type matches the type in this StorageClass.
knownParameters()	Return set of all parameters known to this StorageClass.
mock_dataset_refs(original_refs)	Replace dataset references with versions that uses a mock storage class and dataset type name.
mock_dataset_type(original_type)	Replace a dataset type with a version that uses a mock storage class and name.
unmock_dataset_refs(mock_refs)	Replace dataset references with versions that do not use a mock storage class and dataset type name.
unmock_dataset_type(mock_type)	Replace a mock dataset type with the original one it was created from.
validateInstance(instance)	Check that the supplied Python object has the expected Python type.
validateParameters([parameters])	Check that the parameters are known to this StorageClass.

Attributes Documentation

components

converters

Return the type converters supported by this StorageClass.

defaultDelegateName: str = 'lsst.daf.butler.core.storageClassDelegate.StorageClassDelegate'

delegateClass

Class to use to delegate type-specific actions.

derivedComponents

parameters

Return set of names of supported parameters.

pytype

Return Python type associated with this StorageClass.

Methods Documentation

allComponents() → Mapping[str, MockStorageClass]

Return all defined components.

This mapping includes all the derived and read/write components for the corresponding storage class.

Returns:

compdict of [str, StorageClass]

The component name to storage class mapping.

can_convert(other: StorageClass) → bool

Return True if this storage class can convert python types in the other storage class.

Parameters:

otherStorageClass

The storage class to check.

Returns:

canbool

True if this storage class has a registered converter for the python type associated with the other storage class. That converter will convert the other python type to the one associated with this storage class.

coerce_type(incorrect: Any) → Any

Coerce the supplied incorrect instance to the python type associated with this StorageClass.

Parameters:

incorrectobject

An object that might be the incorrect type.

Returns:

correctobject

An object that matches the python type of this StorageClass. Can be the same object as given. If None, None will be returned.

Raises:

TypeError

Raised if no conversion can be found.

delegate() → StorageClassDelegate

Return an instance of a storage class delegate.

Returns:

delegateStorageClassDelegate

Instance of the delegate associated with this StorageClass. The delegate is constructed with this StorageClass.

Raises:

TypeError

This StorageClass has no associated delegate.

filterParameters(parameters: Mapping[str, Any] | None, subset: Collection | None = None) → Mapping[str, Any]

Filter out parameters that are not known to this StorageClass.

Parameters:

parametersMapping, optional

Candidate parameters. Can be None if no parameters have been provided.

subsetCollection, optional

Subset of supported parameters that the caller is interested in using. The subset must be known to the StorageClass if specified. If None the supplied parameters will all be checked, else only the keys in this set will be checked.

Returns:

filteredMapping

Valid parameters. Empty dict if none are suitable.

Raises:

ValueError

Raised if the provided subset is not a subset of the supported parameters or if it is an empty set.

classmethod get_or_register_mock(original: str, factory: StorageClassFactory | None = None) → MockStorageClass

Return a mock storage class for the given original storage class, creating and registering it if necessary.

Parameters:

originalstr

Name of the original storage class to be mocked.

factoryStorageClassFactory, optional

Storage class factory singleton instance.

Returns:

mockMockStorageClass

New storage class that mocks original.

isComposite() → bool

Return Boolean indicating whether this is a composite or not.

Returns:

isCompositebool

True if this StorageClass is a composite, False otherwise.

is_type(other: type, compare_types: bool = False) → bool

Return Boolean indicating whether the supplied type matches the type in this StorageClass.

Parameters:

othertype

The type to be checked.

compare_typesbool, optional

If True the python type will be used in the comparison if the type names do not match. This may trigger an import of code and so can be slower.

Returns:

matchbool

True if the types are equal.

Notes

If this StorageClass has not yet imported the Python type the check is done against the full type name, this prevents an attempt to import the type when it will likely not match.

knownParameters() → set[str]

Return set of all parameters known to this StorageClass.

The set includes parameters understood by components of a composite.

Returns:

knownset

All parameter keys of this StorageClass and the component storage classes.

static mock_dataset_refs(original_refs: Iterable[DatasetRef]) → list[lsst.daf.butler.core.datasets.ref.DatasetRef]

Replace dataset references with versions that uses a mock storage class and dataset type name.

Parameters:

original_refsIterable [ lsst.daf.butler.DatasetRef ]

Original dataset references to be mocked.

Returns:

mock_refslist [ lsst.daf.butler.DatasetRef ]

Mocked version of the dataset references, with dataset type name and storage class changed and everything else unchanged.

static mock_dataset_type(original_type: DatasetType) → DatasetType

Replace a dataset type with a version that uses a mock storage class and name.

Parameters:

original_typelsst.daf.butler.DatasetType

Original dataset type to be mocked.

Returns:

mock_typelsst.daf.butler.DatasetType

A mock version of the dataset type, with name and storage class changed and everything else unchanged.

static unmock_dataset_refs(mock_refs: Iterable[DatasetRef]) → list[lsst.daf.butler.core.datasets.ref.DatasetRef]

Replace dataset references with versions that do not use a mock storage class and dataset type name.

Parameters:

mock_refsIterable [ lsst.daf.butler.DatasetRef ]

Dataset references that use a mocked dataset type name and storage class.

Returns:

original_refslist [ lsst.daf.butler.DatasetRef ]

The original dataset references.

static unmock_dataset_type(mock_type: DatasetType) → DatasetType

Replace a mock dataset type with the original one it was created from.

Parameters:

mock_typelsst.daf.butler.DatasetType

A dataset type with a mocked name and storage class.

Returns:

original_typelsst.daf.butler.DatasetType

The original dataset type.

validateInstance(instance: Any) → bool

Check that the supplied Python object has the expected Python type.

Parameters:

instanceobject

Object to check.

Returns:

isOkbool

True if the supplied instance object can be handled by this StorageClass, False otherwise.

validateParameters(parameters: Collection | None = None) → None

Check that the parameters are known to this StorageClass.

Does not check the values.

Parameters:

parametersCollection, optional

Collection containing the parameters. Can be dict-like or set-like. The parameter values are not checked. If no parameters are supplied, always returns without error.

Raises:

KeyError

Some parameters are not understood by this StorageClass.