Inheritance diagram for lsst.obs.base._instrument.Instrument:

Public Member Functions
def	filterDefinitions (self)

def	__init__ (self)

def	getName (cls)

Set[str]	getCuratedCalibrationNames (cls)

def	getCamera (self)

def	register (self, registry)

def	getObsDataPackageDir (cls)

def	getRawFormatter (self, dataId)

def	applyConfigOverrides (self, name, config)

None	writeCuratedCalibrations (self, Butler butler, Optional[str] collection=None, Sequence[str] labels=())

None	writeAdditionalCuratedCalibrations (self, Butler butler, Optional[str] collection=None, Sequence[str] labels=())

None	writeCameraGeom (self, Butler butler, Optional[str] collection=None, Sequence[str] labels=())

None	writeStandardTextCuratedCalibrations (self, Butler butler, Optional[str] collection=None, Sequence[str] labels=())

TranslatorFactory	makeDataIdTranslatorFactory (self)

str	makeDefaultRawIngestRunName (cls)

str	makeUnboundedCalibrationRunName (cls, *str labels)

str	makeCuratedCalibrationRunName (cls, str calibDate, *str labels)

str	makeCalibrationCollectionName (cls, *str labels)

str	makeUmbrellaCollectionName (cls)

str	makeCollectionName (cls, *str labels)

Static Public Member Functions
Instrument	fromName (str name, Registry registry)

None	importAll (Registry registry)

str	formatCollectionTimestamp (Union[str, datetime.datetime] timestamp)

str	makeCollectionTimestamp ()

str	makeRefCatCollectionName (*str labels)

Detailed Description

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

Concrete instrument subclasses should be directly constructable with no
arguments.

Definition at line 59 of file _instrument.py.

Constructor & Destructor Documentation

◆ init()

def lsst.obs.base._instrument.Instrument.__init__ ( self )

Definition at line 109 of file _instrument.py.

     def __init__(self):
         self.filterDefinitions.reset()
         self.filterDefinitions.defineFilters()
  

Member Function Documentation

◆ applyConfigOverrides()

def lsst.obs.base._instrument.Instrument.applyConfigOverrides	(	self,
		name,
		config
	)

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.

Definition at line 312 of file _instrument.py.

     def applyConfigOverrides(self, name, config):
         """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.
         """
         for root in self.configPaths:
             path = os.path.join(root, f"{name}.py")
             if os.path.exists(path):
                 config.load(path)
  

◆ filterDefinitions()

def lsst.obs.base._instrument.Instrument.filterDefinitions ( self )

`~lsst.obs.base.FilterDefinitionCollection`, defining the filters
for this instrument.

Definition at line 103 of file _instrument.py.

     def filterDefinitions(self):
         """`~lsst.obs.base.FilterDefinitionCollection`, defining the filters
         for this instrument.
         """
         return None
  

◆ formatCollectionTimestamp()

str lsst.obs.base._instrument.Instrument.formatCollectionTimestamp ( Union[str, datetime.datetime] timestamp )

static

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.

Definition at line 626 of file _instrument.py.

     def 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.
         """
         if isinstance(timestamp, str):
             if "-" in timestamp:
                 # extended ISO format, with - and : delimiters
                 timestamp = datetime.datetime.fromisoformat(timestamp)
             else:
                 # basic ISO format, with no delimiters (what this method
                 # returns)
                 timestamp = datetime.datetime.strptime(timestamp, "%Y%m%dT%H%M%S%z")
         if not isinstance(timestamp, datetime.datetime):
             raise TypeError(f"Unexpected date/time object: {timestamp!r}.")
         if timestamp.tzinfo is not None:
             timestamp = timestamp.astimezone(datetime.timezone.utc)
         return f"{timestamp:%Y%m%dT%H%M%S}Z"
  

◆ fromName()

Instrument lsst.obs.base._instrument.Instrument.fromName	(	str	name,
		Registry	registry
	)

static

Given an instrument name and a butler, 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.

Returns
-------
instrument : `Instrument`
    An instance of the relevant `Instrument`.

Notes
-----
The instrument must be registered in the corresponding butler.

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.

Definition at line 206 of file _instrument.py.

     def fromName(name: str, registry: Registry) -> Instrument:
         """Given an instrument name and a butler, 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.
  
         Returns
         -------
         instrument : `Instrument`
             An instance of the relevant `Instrument`.
  
         Notes
         -----
         The instrument must be registered in the corresponding butler.
  
         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.
         """
         records = list(registry.queryDimensionRecords("instrument", instrument=name))
         if not records:
             raise LookupError(f"No registered instrument with name '{name}'.")
         cls = records[0].class_name
         if not isinstance(cls, str):
             raise TypeError(f"Unexpected class name retrieved from {name} instrument dimension (got {cls})")
         instrument = doImport(cls)
         return instrument()
  

◆ getCamera()

def lsst.obs.base._instrument.Instrument.getCamera ( self )

Retrieve the cameraGeom representation of this instrument.

This is a temporary API that should go away once ``obs`` packages have
a standardized approach to writing versioned cameras to a Gen3 repo.

Reimplemented in lsst.obs.decam._instrument.DarkEnergyCamera.

Definition at line 158 of file _instrument.py.

     def getCamera(self):
         """Retrieve the cameraGeom representation of this instrument.
  
         This is a temporary API that should go away once ``obs`` packages have
         a standardized approach to writing versioned cameras to a Gen3 repo.
         """
         raise NotImplementedError()
  

◆ getCuratedCalibrationNames()

Set[str] lsst.obs.base._instrument.Instrument.getCuratedCalibrationNames ( cls )

Return the names of all the curated calibration dataset types.

Returns
-------
names : `set` of `str`
    The dataset type names of all curated calibrations. This will
    include the standard curated calibrations even if the particular
    instrument does not support them.

Notes
-----
The returned list does not indicate whether a particular dataset
is present in the Butler repository, simply that these are the
dataset types that are handled by ``writeCuratedCalibrations``.

Definition at line 126 of file _instrument.py.

     def getCuratedCalibrationNames(cls) -> Set[str]:
         """Return the names of all the curated calibration dataset types.
  
         Returns
         -------
         names : `set` of `str`
             The dataset type names of all curated calibrations. This will
             include the standard curated calibrations even if the particular
             instrument does not support them.
  
         Notes
         -----
         The returned list does not indicate whether a particular dataset
         is present in the Butler repository, simply that these are the
         dataset types that are handled by ``writeCuratedCalibrations``.
         """
  
         # Camera is a special dataset type that is also handled as a
         # curated calibration.
         curated = {"camera"}
  
         # Make a cursory attempt to filter out curated dataset types
         # that are not present for this instrument
         for datasetTypeName in cls.standardCuratedDatasetTypes:
             calibPath = cls._getSpecificCuratedCalibrationPath(datasetTypeName)
             if calibPath is not None:
                 curated.add(datasetTypeName)
  
         curated.update(cls.additionalCuratedDatasetTypes)
         return frozenset(curated)
  

◆ getName()

def lsst.obs.base._instrument.Instrument.getName ( cls )

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.

Reimplemented in lsst.obs.decam._instrument.DarkEnergyCamera.

Definition at line 115 of file _instrument.py.

     def getName(cls):
         """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.
         """
         raise NotImplementedError()
  

◆ getObsDataPackageDir()

def lsst.obs.base._instrument.Instrument.getObsDataPackageDir ( cls )

The root of the obs data package that provides specializations for
this instrument.

returns
-------
dir : `str`
    The root of the relevat obs data package.

Definition at line 192 of file _instrument.py.

     def getObsDataPackageDir(cls):
         """The root of the obs data package that provides specializations for
         this instrument.
  
         returns
         -------
         dir : `str`
             The root of the relevat obs data package.
         """
         if cls.obsDataPackage is None:
             return None
         return getPackageDir(cls.obsDataPackage)
  

◆ getRawFormatter()

def lsst.obs.base._instrument.Instrument.getRawFormatter	(	self,
		dataId
	)

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

Parameters
----------
dataId : `DataCoordinate`
    Dimension-based ID for the raw file or files being ingested.

Returns
-------
formatter : `Formatter` class
    Class to be used that reads the file into an
    `lsst.afw.image.Exposure` instance.

Reimplemented in lsst.obs.decam._instrument.DarkEnergyCamera.

Definition at line 295 of file _instrument.py.

     def getRawFormatter(self, dataId):
         """Return the Formatter class that should be used to read a particular
         raw file.
  
         Parameters
         ----------
         dataId : `DataCoordinate`
             Dimension-based ID for the raw file or files being ingested.
  
         Returns
         -------
         formatter : `Formatter` class
             Class to be used that reads the file into an
             `lsst.afw.image.Exposure` instance.
         """
         raise NotImplementedError()
  

◆ importAll()

None lsst.obs.base._instrument.Instrument.importAll ( Registry registry )

static

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.

Definition at line 246 of file _instrument.py.

     def 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.
         """
         records = list(registry.queryDimensionRecords("instrument"))
         for record in records:
             cls = record.class_name
             try:
                 doImport(cls)
             except Exception:
                 pass
  

◆ makeCalibrationCollectionName()

str lsst.obs.base._instrument.Instrument.makeCalibrationCollectionName	(		cls,
		*str	labels
	)

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.

Definition at line 727 of file _instrument.py.

     def makeCalibrationCollectionName(cls, *labels: str) -> 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.
         """
         return cls.makeCollectionName("calib", *labels)
  

◆ makeCollectionName()

str lsst.obs.base._instrument.Instrument.makeCollectionName	(		cls,
		*str	labels
	)

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 name.

Definition at line 788 of file _instrument.py.

     def makeCollectionName(cls, *labels: str) -> 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 name.
         """
         return "/".join((cls.getName(),) + labels)
  
  

◆ makeCollectionTimestamp()

str lsst.obs.base._instrument.Instrument.makeCollectionTimestamp ( )

static

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

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

Definition at line 661 of file _instrument.py.

     def 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.
         """
         return Instrument.formatCollectionTimestamp(datetime.datetime.now(tz=datetime.timezone.utc))
  

◆ makeCuratedCalibrationRunName()

str lsst.obs.base._instrument.Instrument.makeCuratedCalibrationRunName	(		cls,
		str	calibDate,
		*str	labels
	)

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.

Definition at line 705 of file _instrument.py.

     def makeCuratedCalibrationRunName(cls, calibDate: str, *labels: str) -> 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.
         """
         return cls.makeCollectionName("calib", *labels, "curated", cls.formatCollectionTimestamp(calibDate))
  

◆ makeDataIdTranslatorFactory()

TranslatorFactory lsst.obs.base._instrument.Instrument.makeDataIdTranslatorFactory ( self )

Return a factory for creating Gen2->Gen3 data ID translators,
specialized for this instrument.

Derived class implementations should generally call
`TranslatorFactory.addGenericInstrumentRules` with appropriate
arguments, but are not required to (and may not be able to if their
Gen2 raw data IDs are sufficiently different from the HSC/DECam/CFHT
norm).

Returns
-------
factory : `TranslatorFactory`.
    Factory for `Translator` objects.

Reimplemented in lsst.obs.decam._instrument.DarkEnergyCamera.

Definition at line 608 of file _instrument.py.

     def makeDataIdTranslatorFactory(self) -> TranslatorFactory:
         """Return a factory for creating Gen2->Gen3 data ID translators,
         specialized for this instrument.
  
         Derived class implementations should generally call
         `TranslatorFactory.addGenericInstrumentRules` with appropriate
         arguments, but are not required to (and may not be able to if their
         Gen2 raw data IDs are sufficiently different from the HSC/DECam/CFHT
         norm).
  
         Returns
         -------
         factory : `TranslatorFactory`.
             Factory for `Translator` objects.
         """
         raise NotImplementedError("Must be implemented by derived classes.")
  

◆ makeDefaultRawIngestRunName()

str lsst.obs.base._instrument.Instrument.makeDefaultRawIngestRunName ( cls )

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.

Definition at line 673 of file _instrument.py.

     def makeDefaultRawIngestRunName(cls) -> 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.
         """
         return cls.makeCollectionName("raw", "all")
  

◆ makeRefCatCollectionName()

str lsst.obs.base._instrument.Instrument.makeRefCatCollectionName ( *str labels )

static

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.

Definition at line 746 of file _instrument.py.

     def makeRefCatCollectionName(*labels: str) -> 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.
         """
         return "/".join(("refcats",) + labels)
  

◆ makeUmbrellaCollectionName()

str lsst.obs.base._instrument.Instrument.makeUmbrellaCollectionName ( cls )

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.

Definition at line 774 of file _instrument.py.

     def makeUmbrellaCollectionName(cls) -> 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.
         """
         return cls.makeCollectionName("defaults")
  

◆ makeUnboundedCalibrationRunName()

str lsst.obs.base._instrument.Instrument.makeUnboundedCalibrationRunName	(		cls,
		*str	labels
	)

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.

Definition at line 686 of file _instrument.py.

     def makeUnboundedCalibrationRunName(cls, *labels: str) -> 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.
         """
         return cls.makeCollectionName("calib", *labels, "unbounded")
  

◆ register()

def lsst.obs.base._instrument.Instrument.register	(	self,
		registry
	)

Insert instrument, physical_filter, and detector entries into a
`Registry`.

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)

Raises
------
lsst.daf.butler.registry.ConflictingDefinitionError
    Raised if any existing record has the same key but a different
    definition as one being registered.

Reimplemented in lsst.obs.decam._instrument.DarkEnergyCamera.

Definition at line 167 of file _instrument.py.

     def register(self, registry):
         """Insert instrument, physical_filter, and detector entries into a
         `Registry`.
  
         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)
  
         Raises
         ------
         lsst.daf.butler.registry.ConflictingDefinitionError
             Raised if any existing record has the same key but a different
             definition as one being registered.
         """
         raise NotImplementedError()
  

◆ writeAdditionalCuratedCalibrations()

None lsst.obs.base._instrument.Instrument.writeAdditionalCuratedCalibrations	(		self,
		Butler	butler,
		Optional[str]	collection = `None`,
		Sequence[str]	labels = `()`
	)

Write additional curated calibrations that might be instrument
specific and are not part of the standard set.

Default implementation does nothing.

Parameters
----------
butler : `lsst.daf.butler.Butler`
    Butler to use to store these calibrations.
collection : `str`, optional
    Name to use for the calibration collection that associates all
    datasets with a validity range.  If this collection already exists,
    it must be a `~CollectionType.CALIBRATION` collection, and it must
    not have any datasets that would conflict with those inserted by
    this method.  If `None`, a collection name is worked out
    automatically from the instrument name and other metadata by
    calling ``makeCalibrationCollectionName``, but this
    default name may not work well for long-lived repositories unless
    ``labels`` is also provided (and changed every time curated
    calibrations are ingested).
labels : `Sequence` [ `str` ], optional
    Extra strings to include in collection names, after concatenating
    them with the standard collection name delimeter.  If provided,
    these are inserted into the names of the `~CollectionType.RUN`
    collections that datasets are inserted directly into, as well the
    `~CollectionType.CALIBRATION` collection if it is generated
    automatically (i.e. if ``collection is None``).  Usually this is
    just the name of the ticket on which the calibration collection is
    being created.

Definition at line 374 of file _instrument.py.

                                            labels: Sequence[str] = ()) -> None:
         """Write additional curated calibrations that might be instrument
         specific and are not part of the standard set.
  
         Default implementation does nothing.
  
         Parameters
         ----------
         butler : `lsst.daf.butler.Butler`
             Butler to use to store these calibrations.
         collection : `str`, optional
             Name to use for the calibration collection that associates all
             datasets with a validity range.  If this collection already exists,
             it must be a `~CollectionType.CALIBRATION` collection, and it must
             not have any datasets that would conflict with those inserted by
             this method.  If `None`, a collection name is worked out
             automatically from the instrument name and other metadata by
             calling ``makeCalibrationCollectionName``, but this
             default name may not work well for long-lived repositories unless
             ``labels`` is also provided (and changed every time curated
             calibrations are ingested).
         labels : `Sequence` [ `str` ], optional
             Extra strings to include in collection names, after concatenating
             them with the standard collection name delimeter.  If provided,
             these are inserted into the names of the `~CollectionType.RUN`
             collections that datasets are inserted directly into, as well the
             `~CollectionType.CALIBRATION` collection if it is generated
             automatically (i.e. if ``collection is None``).  Usually this is
             just the name of the ticket on which the calibration collection is
             being created.
         """
         return
  

◆ writeCameraGeom()

None lsst.obs.base._instrument.Instrument.writeCameraGeom	(		self,
		Butler	butler,
		Optional[str]	collection = `None`,
		Sequence[str]	labels = `()`
	)

Write the default camera geometry to the butler repository and
associate it with the appropriate validity range in a calibration
collection.

Parameters
----------
butler : `lsst.daf.butler.Butler`
    Butler to use to store these calibrations.
collection : `str`, optional
    Name to use for the calibration collection that associates all
    datasets with a validity range.  If this collection already exists,
    it must be a `~CollectionType.CALIBRATION` collection, and it must
    not have any datasets that would conflict with those inserted by
    this method.  If `None`, a collection name is worked out
    automatically from the instrument name and other metadata by
    calling ``makeCalibrationCollectionName``, but this
    default name may not work well for long-lived repositories unless
    ``labels`` is also provided (and changed every time curated
    calibrations are ingested).
labels : `Sequence` [ `str` ], optional
    Extra strings to include in collection names, after concatenating
    them with the standard collection name delimeter.  If provided,
    these are inserted into the names of the `~CollectionType.RUN`
    collections that datasets are inserted directly into, as well the
    `~CollectionType.CALIBRATION` collection if it is generated
    automatically (i.e. if ``collection is None``).  Usually this is
    just the name of the ticket on which the calibration collection is
    being created.

Definition at line 408 of file _instrument.py.

                         labels: Sequence[str] = ()) -> None:
         """Write the default camera geometry to the butler repository and
         associate it with the appropriate validity range in a calibration
         collection.
  
         Parameters
         ----------
         butler : `lsst.daf.butler.Butler`
             Butler to use to store these calibrations.
         collection : `str`, optional
             Name to use for the calibration collection that associates all
             datasets with a validity range.  If this collection already exists,
             it must be a `~CollectionType.CALIBRATION` collection, and it must
             not have any datasets that would conflict with those inserted by
             this method.  If `None`, a collection name is worked out
             automatically from the instrument name and other metadata by
             calling ``makeCalibrationCollectionName``, but this
             default name may not work well for long-lived repositories unless
             ``labels`` is also provided (and changed every time curated
             calibrations are ingested).
         labels : `Sequence` [ `str` ], optional
             Extra strings to include in collection names, after concatenating
             them with the standard collection name delimeter.  If provided,
             these are inserted into the names of the `~CollectionType.RUN`
             collections that datasets are inserted directly into, as well the
             `~CollectionType.CALIBRATION` collection if it is generated
             automatically (i.e. if ``collection is None``).  Usually this is
             just the name of the ticket on which the calibration collection is
             being created.
         """
         if collection is None:
             collection = self.makeCalibrationCollectionName(*labels)
         butler.registry.registerCollection(collection, type=CollectionType.CALIBRATION)
         run = self.makeUnboundedCalibrationRunName(*labels)
         butler.registry.registerRun(run)
         datasetType = DatasetType("camera", ("instrument",), "Camera", isCalibration=True,
                                   universe=butler.registry.dimensions)
         butler.registry.registerDatasetType(datasetType)
         camera = self.getCamera()
         ref = butler.put(camera, datasetType, {"instrument": self.getName()}, run=run)
         butler.registry.certify(collection, [ref], Timespan(begin=None, end=None))
  

◆ writeCuratedCalibrations()

None lsst.obs.base._instrument.Instrument.writeCuratedCalibrations	(		self,
		Butler	butler,
		Optional[str]	collection = `None`,
		Sequence[str]	labels = `()`
	)

Write human-curated calibration Datasets to the given Butler with
the appropriate validity ranges.

Parameters
----------
butler : `lsst.daf.butler.Butler`
    Butler to use to store these calibrations.
collection : `str`, optional
    Name to use for the calibration collection that associates all
    datasets with a validity range.  If this collection already exists,
    it must be a `~CollectionType.CALIBRATION` collection, and it must
    not have any datasets that would conflict with those inserted by
    this method.  If `None`, a collection name is worked out
    automatically from the instrument name and other metadata by
    calling ``makeCalibrationCollectionName``, but this
    default name may not work well for long-lived repositories unless
    ``labels`` is also provided (and changed every time curated
    calibrations are ingested).
labels : `Sequence` [ `str` ], optional
    Extra strings to include in collection names, after concatenating
    them with the standard collection name delimeter.  If provided,
    these are inserted into the names of the `~CollectionType.RUN`
    collections that datasets are inserted directly into, as well the
    `~CollectionType.CALIBRATION` collection if it is generated
    automatically (i.e. if ``collection is None``).  Usually this is
    just the name of the ticket on which the calibration collection is
    being created.

Notes
-----
Expected to be called from subclasses.  The base method calls
``writeCameraGeom``, ``writeStandardTextCuratedCalibrations``,
and ``writeAdditionalCuratdCalibrations``.

Definition at line 328 of file _instrument.py.

                                  labels: Sequence[str] = ()) -> None:
         """Write human-curated calibration Datasets to the given Butler with
         the appropriate validity ranges.
  
         Parameters
         ----------
         butler : `lsst.daf.butler.Butler`
             Butler to use to store these calibrations.
         collection : `str`, optional
             Name to use for the calibration collection that associates all
             datasets with a validity range.  If this collection already exists,
             it must be a `~CollectionType.CALIBRATION` collection, and it must
             not have any datasets that would conflict with those inserted by
             this method.  If `None`, a collection name is worked out
             automatically from the instrument name and other metadata by
             calling ``makeCalibrationCollectionName``, but this
             default name may not work well for long-lived repositories unless
             ``labels`` is also provided (and changed every time curated
             calibrations are ingested).
         labels : `Sequence` [ `str` ], optional
             Extra strings to include in collection names, after concatenating
             them with the standard collection name delimeter.  If provided,
             these are inserted into the names of the `~CollectionType.RUN`
             collections that datasets are inserted directly into, as well the
             `~CollectionType.CALIBRATION` collection if it is generated
             automatically (i.e. if ``collection is None``).  Usually this is
             just the name of the ticket on which the calibration collection is
             being created.
  
         Notes
         -----
         Expected to be called from subclasses.  The base method calls
         ``writeCameraGeom``, ``writeStandardTextCuratedCalibrations``,
         and ``writeAdditionalCuratdCalibrations``.
         """
         # Delegate registration of collections (and creating names for them)
         # to other methods so they can be called independently with the same
         # preconditions.  Collection registration is idempotent, so this is
         # safe, and while it adds a bit of overhead, as long as it's one
         # registration attempt per method (not per dataset or dataset type),
         # that's negligible.
         self.writeCameraGeom(butler, collection, labels=labels)
         self.writeStandardTextCuratedCalibrations(butler, collection, labels=labels)
         self.writeAdditionalCuratedCalibrations(butler, collection, labels=labels)
  

◆ writeStandardTextCuratedCalibrations()

None lsst.obs.base._instrument.Instrument.writeStandardTextCuratedCalibrations	(		self,
		Butler	butler,
		Optional[str]	collection = `None`,
		Sequence[str]	labels = `()`
	)

Write the set of standardized curated text calibrations to
the repository.

Parameters
----------
butler : `lsst.daf.butler.Butler`
    Butler to receive these calibration datasets.
collection : `str`, optional
    Name to use for the calibration collection that associates all
    datasets with a validity range.  If this collection already exists,
    it must be a `~CollectionType.CALIBRATION` collection, and it must
    not have any datasets that would conflict with those inserted by
    this method.  If `None`, a collection name is worked out
    automatically from the instrument name and other metadata by
    calling ``makeCalibrationCollectionName``, but this
    default name may not work well for long-lived repositories unless
    ``labels`` is also provided (and changed every time curated
    calibrations are ingested).
labels : `Sequence` [ `str` ], optional
    Extra strings to include in collection names, after concatenating
    them with the standard collection name delimeter.  If provided,
    these are inserted into the names of the `~CollectionType.RUN`
    collections that datasets are inserted directly into, as well the
    `~CollectionType.CALIBRATION` collection if it is generated
    automatically (i.e. if ``collection is None``).  Usually this is
    just the name of the ticket on which the calibration collection is
    being created.

Definition at line 451 of file _instrument.py.

                                              labels: Sequence[str] = ()) -> None:
         """Write the set of standardized curated text calibrations to
         the repository.
  
         Parameters
         ----------
         butler : `lsst.daf.butler.Butler`
             Butler to receive these calibration datasets.
         collection : `str`, optional
             Name to use for the calibration collection that associates all
             datasets with a validity range.  If this collection already exists,
             it must be a `~CollectionType.CALIBRATION` collection, and it must
             not have any datasets that would conflict with those inserted by
             this method.  If `None`, a collection name is worked out
             automatically from the instrument name and other metadata by
             calling ``makeCalibrationCollectionName``, but this
             default name may not work well for long-lived repositories unless
             ``labels`` is also provided (and changed every time curated
             calibrations are ingested).
         labels : `Sequence` [ `str` ], optional
             Extra strings to include in collection names, after concatenating
             them with the standard collection name delimeter.  If provided,
             these are inserted into the names of the `~CollectionType.RUN`
             collections that datasets are inserted directly into, as well the
             `~CollectionType.CALIBRATION` collection if it is generated
             automatically (i.e. if ``collection is None``).  Usually this is
             just the name of the ticket on which the calibration collection is
             being created.
         """
         if collection is None:
             collection = self.makeCalibrationCollectionName(*labels)
         butler.registry.registerCollection(collection, type=CollectionType.CALIBRATION)
         runs = set()
         for datasetTypeName in self.standardCuratedDatasetTypes:
             # We need to define the dataset types.
             if datasetTypeName not in StandardCuratedCalibrationDatasetTypes:
                 raise ValueError(f"DatasetType {datasetTypeName} not in understood list"
                                  f" [{'.'.join(StandardCuratedCalibrationDatasetTypes)}]")
             definition = StandardCuratedCalibrationDatasetTypes[datasetTypeName]
             datasetType = DatasetType(datasetTypeName,
                                       universe=butler.registry.dimensions,
                                       isCalibration=True,
                                       **definition)
             self._writeSpecificCuratedCalibrationDatasets(butler, datasetType, collection, runs=runs,
                                                           labels=labels)
  

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

/j/snowflake/release/lsstsw/stack/0.2.1/Linux64/obs_base/21.0.0-27-gbbd0d29+ae871e0f33/python/lsst/obs/base/_instrument.py

Public Member Functions

Static Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ applyConfigOverrides()

◆ filterDefinitions()

◆ formatCollectionTimestamp()

◆ fromName()

◆ getCamera()

◆ getCuratedCalibrationNames()

◆ getName()

◆ getObsDataPackageDir()

◆ getRawFormatter()

◆ importAll()

◆ makeCalibrationCollectionName()

◆ makeCollectionName()

◆ makeCollectionTimestamp()

◆ makeCuratedCalibrationRunName()

◆ makeDataIdTranslatorFactory()

◆ makeDefaultRawIngestRunName()

◆ makeRefCatCollectionName()

◆ makeUmbrellaCollectionName()

◆ makeUnboundedCalibrationRunName()

◆ register()

◆ writeAdditionalCuratedCalibrations()

◆ writeCameraGeom()

◆ writeCuratedCalibrations()

◆ writeStandardTextCuratedCalibrations()

◆ init()