Instrument¶

class lsst.pipe.base.Instrument(collection_prefix: Optional[str] = None)¶

Bases: object

Base class for instrument-specific logic for the Gen3 Butler.

Parameters:	collection_prefix : `str`, optional Prefix for collection names to use instead of the intrument’s own name. This is primarily for use in simulated-data repositories, where the instrument name may not be necessary and/or sufficient to distinguish between collections.

Notes

Concrete instrument subclasses must have the same construction signature as the base class.

Attributes Summary

`configPaths`	Paths to config files to read for specific Tasks.
`policyName`	Instrument specific name to use when locating a policy or configuration file in the file system.

Methods Summary

`applyConfigOverrides`(name, config)	Apply instrument-specific overrides for a task config.
`formatCollectionTimestamp`(timestamp, …)	Format a timestamp for use in a collection name.
`fromName`(name, registry, collection_prefix)	Given an instrument name and a butler registry, retrieve a corresponding instantiated instrument object.
`from_string`(name, registry, collection_prefix)	Return an instance from the short name or class name.
`getName`()	Return the short (dimension) name for this instrument.
`getRawFormatter`(dataId, Mapping[str, Any]])	Return the Formatter class that should be used to read a particular raw file.
`importAll`(registry)	Import all the instruments known to this registry.
`makeCalibrationCollectionName`(*labels)	Make a CALIBRATION collection name appropriate for associating calibration datasets with validity ranges.
`makeCollectionName`(*labels)	Get the instrument-specific collection string to use as derived from the supplied labels.
`makeCollectionTimestamp`()	Create a timestamp string for use in a collection name from the current time.
`makeCuratedCalibrationRunName`(calibDate, *labels)	Make a RUN collection name appropriate for inserting curated calibration datasets with the given `CALIBDATE` metadata value.
`makeDefaultRawIngestRunName`()	Make the default instrument-specific run collection string for raw data ingest.
`makeRefCatCollectionName`(*labels)	Return a global (not instrument-specific) name for a collection that holds reference catalogs.
`makeUmbrellaCollectionName`()	Return the name of the umbrella `CHAINED` collection for this instrument that combines all standard recommended input collections.
`makeUnboundedCalibrationRunName`(*labels)	Make a RUN collection name appropriate for inserting calibration datasets whose validity ranges are unbounded.
`register`(registry, *, update)	Insert instrument, and other relevant records into `Registry`.

Attributes Documentation

configPaths = ()¶

Paths to config files to read for specific Tasks.

The paths in this list should contain files of the form task.py, for each of the Tasks that requires special configuration.

policyName = None¶: Instrument specific name to use when locating a policy or configuration file in the file system.

Methods Documentation

applyConfigOverrides(name: str, config: Config) → None¶

Apply instrument-specific overrides for a task config.

Parameters:	name : `str` Name of the object being configured; typically the _DefaultName of a Task. config : `lsst.pex.config.Config` Config instance to which overrides should be applied.

static formatCollectionTimestamp(timestamp: Union[str, datetime.datetime]) → str¶

Format a timestamp for use in a collection name.

Parameters:

timestamp : str or datetime.datetime: Timestamp to format. May be a date or datetime string in extended ISO format (assumed UTC), with or without a timezone specifier, a datetime string in basic ISO format with a timezone specifier, a naive datetime.datetime instance (assumed UTC) or a timezone-aware datetime.datetime instance (converted to UTC). This is intended to cover all forms that string CALIBDATE metadata values have taken in the past, as well as the format this method itself writes out (to enable round-tripping).

Returns:

formatted : str: Standardized string form for the timestamp.

static fromName(name: str, registry: Registry, collection_prefix: Optional[str] = None) → Instrument¶

Given an instrument name and a butler registry, retrieve a corresponding instantiated instrument object.

Parameters:	name : `str` Name of the instrument (must match the return value of `getName`). registry : `lsst.daf.butler.Registry` Butler registry to query to find the information. collection_prefix : `str`, optional Prefix for collection names to use instead of the intrument’s own name. This is primarily for use in simulated-data repositories, where the instrument name may not be necessary and/or sufficient to distinguish between collections.
Returns:	instrument : `Instrument` An instance of the relevant `Instrument`.
Raises:	LookupError Raised if the instrument is not known to the supplied registry. ModuleNotFoundError Raised if the class could not be imported. This could mean that the relevant obs package has not been setup. TypeError Raised if the class name retrieved is not a string or the imported symbol is not an `Instrument` subclass.

Notes

The instrument must be registered in the corresponding butler.

static from_string(name: str, registry: Optional[Registry] = None, collection_prefix: Optional[str] = None) → Instrument¶

Return an instance from the short name or class name.

If the instrument name is not qualified (does not contain a ‘.’) and a butler registry is provided, this will attempt to load the instrument using Instrument.fromName(). Otherwise the instrument will be imported and instantiated.

Parameters:	name : `str` The name or fully-qualified class name of an instrument. registry : `lsst.daf.butler.Registry`, optional Butler registry to query to find information about the instrument, by default `None`. collection_prefix : `str`, optional Prefix for collection names to use instead of the intrument’s own name. This is primarily for use in simulated-data repositories, where the instrument name may not be necessary and/or sufficient to distinguish between collections.
Returns:	instrument : `Instrument` The instantiated instrument.
Raises:	RuntimeError Raised if the instrument can not be imported, instantiated, or obtained from the registry. TypeError Raised if the instrument is not a subclass of `Instrument`.

See also

Instrument.fromName

classmethod getName() → str¶

Return the short (dimension) name for this instrument.

This is not (in general) the same as the class name - it’s what is used as the value of the “instrument” field in data IDs, and is usually an abbreviation of the full name.

getRawFormatter(dataId: Union[lsst.daf.butler.core.dimensions._coordinate.DataCoordinate, Mapping[str, Any]]) → Type[lsst.daf.butler.core.formatter.Formatter]¶

Return the Formatter class that should be used to read a particular raw file.

Parameters:	dataId : `DataId` Dimension-based ID for the raw file or files being ingested.
Returns:	formatter : `lsst.daf.butler.Formatter` class Class to be used that reads the file into the correct Python object for the raw data.

static importAll(registry: Registry) → None¶

Import all the instruments known to this registry.

This will ensure that all metadata translators have been registered.

Parameters:	registry : `lsst.daf.butler.Registry` Butler registry to query to find the information.

Notes

It is allowed for a particular instrument class to fail on import. This might simply indicate that a particular obs package has not been setup.

makeCalibrationCollectionName(*labels) → str¶

Make a CALIBRATION collection name appropriate for associating calibration datasets with validity ranges.

Parameters:	*labels : `str` Strings to be appended to the base name, using the default delimiter for collection names. Usually this is the name of the ticket on which the calibration collection is being created.
Returns:	name : `str` Calibration collection name.

makeCollectionName(*labels) → str¶

Get the instrument-specific collection string to use as derived from the supplied labels.

Parameters:	*labels : `str` Strings to be combined with the instrument name to form a collection name.
Returns:	name : `str` Collection name to use that includes the instrument’s recommended prefix.

static makeCollectionTimestamp() → str¶

Create a timestamp string for use in a collection name from the current time.

Returns:	formatted : `str` Standardized string form of the current time.

makeCuratedCalibrationRunName(calibDate: str, *labels) → str¶

Make a RUN collection name appropriate for inserting curated calibration datasets with the given CALIBDATE metadata value.

Parameters:	calibDate : `str` The `CALIBDATE` metadata value. *labels : `str` Strings to be included in the collection name (before `calibDate`, but after all other terms), using the default delimiter for collection names. Usually this is the name of the ticket on which the calibration collection is being created.
Returns:	name : `str` Run collection name.

makeDefaultRawIngestRunName() → str¶

Make the default instrument-specific run collection string for raw data ingest.

Returns:	coll : `str` Run collection name to be used as the default for ingestion of raws.

static makeRefCatCollectionName(*labels) → str¶

Return a global (not instrument-specific) name for a collection that holds reference catalogs.

With no arguments, this returns the name of the collection that holds all reference catalogs (usually a CHAINED collection, at least in long-lived repos that may contain more than one reference catalog).

Parameters:	*labels : `str` Strings to be added to the global collection name, in order to define a collection name for one or more reference catalogs being ingested at the same time.
Returns:	name : `str` Collection name.

Notes

This is a staticmethod, not a classmethod, because it should be the same for all instruments.

makeUmbrellaCollectionName() → str¶

Return the name of the umbrella CHAINED collection for this instrument that combines all standard recommended input collections.

This method should almost never be overridden by derived classes.

Returns:	name : `str` Name for the umbrella collection.

makeUnboundedCalibrationRunName(*labels) → str¶

Make a RUN collection name appropriate for inserting calibration datasets whose validity ranges are unbounded.

Parameters:	*labels : `str` Extra strings to be included in the base name, using the default delimiter for collection names. Usually this is the name of the ticket on which the calibration collection is being created.
Returns:	name : `str` Run collection name.

register(registry: Registry, *, update: bool = False) → None¶

Insert instrument, and other relevant records into Registry.

Parameters:	registry : `lsst.daf.butler.Registry` Registry client for the data repository to modify. update : `bool`, optional If `True` (`False` is default), update existing records if they differ from the new ones.
Raises:	lsst.daf.butler.registry.ConflictingDefinitionError Raised if any existing record has the same key but a different definition as one being registered.

Notes

New records can always be added by calling this method multiple times, as long as no existing records have changed (if existing records have changed, update=True must be used). Old records can never be removed by this method.

Implementations should guarantee that registration is atomic (the registry should not be modified if any error occurs) and idempotent at the level of individual dimension entries; new detectors and filters should be added, but changes to any existing record should not be. This can generally be achieved via a block like

with registry.transaction():
    registry.syncDimensionData("instrument", ...)
    registry.syncDimensionData("detector", ...)
    self.registerFilters(registry)

Navigation

Instrument¶