Inheritance diagram for lsst.ip.isr.calibType.IsrProvenance:

Public Member Functions
def	__init__ (self, calibType="unknown", **kwargs)

def	__str__ (self)

def	__eq__ (self, other)

def	updateMetadata (self, setDate=False, **kwargs)

def	fromDataIds (self, dataIdList)

def	fromTable (cls, tableList)

def	fromDict (cls, dictionary)

def	toDict (self)

def	toTable (self)

def	requiredAttributes (self)

def	requiredAttributes (self, value)

def	getMetadata (self)

def	setMetadata (self, metadata)

def	updateMetadata (self, camera=None, detector=None, filterName=None, setCalibId=False, setCalibInfo=False, setDate=False, **kwargs)

def	calibInfoFromDict (self, dictionary)

def	readText (cls, filename, **kwargs)

def	writeText (self, filename, format='auto')

def	readFits (cls, filename, **kwargs)

def	writeFits (self, filename)

def	fromDetector (self, detector)

def	fromDict (cls, dictionary, **kwargs)

def	fromTable (cls, tableList, **kwargs)

def	validate (self, other=None)

def	apply (self, target)

Public Attributes
	calibType

	dimensions

	dataIdList

	requiredAttributes

	log

Detailed Description

Class for the provenance of data used to construct calibration.

Provenance is not really a calibration, but we would like to
record this when constructing the calibration, and it provides an
example of the base calibration class.

Parameters
----------
instrument : `str`, optional
    Name of the instrument the data was taken with.
calibType : `str`, optional
    Type of calibration this provenance was generated for.
detectorName : `str`, optional
    Name of the detector this calibration is for.
detectorSerial : `str`, optional
    Identifier for the detector.

Definition at line 570 of file calibType.py.

Constructor & Destructor Documentation

◆ init()

def lsst.ip.isr.calibType.IsrProvenance.__init__	(		self,
			calibType = `"unknown"`,
		**	kwargs
	)

Definition at line 591 of file calibType.py.

                  **kwargs):
         self.calibType = calibType
         self.dimensions = set()
         self.dataIdList = list()
  
         super().__init__(**kwargs)
  
         self.requiredAttributes.update(['calibType', 'dimensions', 'dataIdList'])
  

Member Function Documentation

◆ eq()

def lsst.ip.isr.calibType.IsrProvenance.__eq__	(	self,
		other
	)

Calibration equivalence.

Subclasses will need to check specific sub-properties.  The
default is only to check common entries.

Reimplemented from lsst.ip.isr.calibType.IsrCalib.

Definition at line 604 of file calibType.py.

     def __eq__(self, other):
         return super().__eq__(other)
  

◆ str()

def lsst.ip.isr.calibType.IsrProvenance.__str__ ( self )

Reimplemented from lsst.ip.isr.calibType.IsrCalib.

Definition at line 601 of file calibType.py.

     def __str__(self):
         return f"{self.__class__.__name__}(obstype={self._OBSTYPE}, calibType={self.calibType}, )"
  

◆ apply()

def lsst.ip.isr.calibType.IsrCalib.apply	(	self,
		target
	)

inherited

Method to apply the calibration to the target object.

Parameters
----------
target : `object`
    Thing to validate against.

Returns
-------
valid : `bool`
    Returns true if the calibration was applied correctly.

Raises
------
NotImplementedError :
    Raised if not implemented.

Definition at line 549 of file calibType.py.

     def apply(self, target):
         """Method to apply the calibration to the target object.
  
         Parameters
         ----------
         target : `object`
             Thing to validate against.
  
         Returns
         -------
         valid : `bool`
             Returns true if the calibration was applied correctly.
  
         Raises
         ------
         NotImplementedError :
             Raised if not implemented.
         """
         raise NotImplementedError("Must be implemented by subclass.")
  
  

◆ calibInfoFromDict()

def lsst.ip.isr.calibType.IsrCalib.calibInfoFromDict	(	self,
		dictionary
	)

inherited

Handle common keywords.

This isn't an ideal solution, but until all calibrations
expect to find everything in the metadata, they still need to
search through dictionaries.

Parameters
----------
dictionary : `dict` or `lsst.daf.base.PropertyList`
    Source for the common keywords.

Raises
------
RuntimeError :
    Raised if the dictionary does not match the expected OBSTYPE.

Definition at line 229 of file calibType.py.

     def calibInfoFromDict(self, dictionary):
         """Handle common keywords.
  
         This isn't an ideal solution, but until all calibrations
         expect to find everything in the metadata, they still need to
         search through dictionaries.
  
         Parameters
         ----------
         dictionary : `dict` or `lsst.daf.base.PropertyList`
             Source for the common keywords.
  
         Raises
         ------
         RuntimeError :
             Raised if the dictionary does not match the expected OBSTYPE.
  
         """
  
         def search(haystack, needles):
             """Search dictionary 'haystack' for an entry in 'needles'
             """
             test = [haystack.get(x) for x in needles]
             test = set([x for x in test if x is not None])
             if len(test) == 0:
                 if 'metadata' in haystack:
                     return search(haystack['metadata'], needles)
                 else:
                     return None
             elif len(test) == 1:
                 value = list(test)[0]
                 if value == '':
                     return None
                 else:
                     return value
             else:
                 raise ValueError(f"Too many values found: {len(test)} {test} {needles}")
  
         if 'metadata' in dictionary:
             metadata = dictionary['metadata']
  
             if self._OBSTYPE != metadata['OBSTYPE']:
                 raise RuntimeError(f"Incorrect calibration supplied.  Expected {self._OBSTYPE}, "
                                    f"found {metadata['OBSTYPE']}")
  
         self._instrument = search(dictionary, ['INSTRUME', 'instrument'])
         self._raftName = search(dictionary, ['RAFTNAME'])
         self._slotName = search(dictionary, ['SLOTNAME'])
         self._detectorId = search(dictionary, ['DETECTOR', 'detectorId'])
         self._detectorName = search(dictionary, ['DET_NAME', 'DETECTOR_NAME', 'detectorName'])
         self._detectorSerial = search(dictionary, ['DET_SER', 'DETECTOR_SERIAL', 'detectorSerial'])
         self._filter = search(dictionary, ['FILTER', 'filterName'])
         self._calibId = search(dictionary, ['CALIB_ID'])
  

◆ fromDataIds()

def lsst.ip.isr.calibType.IsrProvenance.fromDataIds	(	self,
		dataIdList
	)

Update provenance from dataId List.

Parameters
----------
dataIdList : `list` [`lsst.daf.butler.DataId`]
    List of dataIds used in generating this calibration.

Definition at line 621 of file calibType.py.

     def fromDataIds(self, dataIdList):
         """Update provenance from dataId List.
  
         Parameters
         ----------
         dataIdList : `list` [`lsst.daf.butler.DataId`]
             List of dataIds used in generating this calibration.
         """
         for dataId in dataIdList:
             for key in dataId:
                 if key not in self.dimensions:
                     self.dimensions.add(key)
             self.dataIdList.append(dataId)
  

◆ fromDetector()

def lsst.ip.isr.calibType.IsrCalib.fromDetector	(	self,
		detector
	)

inherited

Modify the calibration parameters to match the supplied detector.

Parameters
----------
detector : `lsst.afw.cameraGeom.Detector`
    Detector to use to set parameters from.

Raises
------
NotImplementedError
    This needs to be implemented by subclasses for each
    calibration type.

Reimplemented in lsst.ip.isr.linearize.Linearizer.

Definition at line 432 of file calibType.py.

     def fromDetector(self, detector):
         """Modify the calibration parameters to match the supplied detector.
  
         Parameters
         ----------
         detector : `lsst.afw.cameraGeom.Detector`
             Detector to use to set parameters from.
  
         Raises
         ------
         NotImplementedError
             This needs to be implemented by subclasses for each
             calibration type.
         """
         raise NotImplementedError("Must be implemented by subclass.")
  

◆ fromDict() [1/2]

def lsst.ip.isr.calibType.IsrProvenance.fromDict	(	cls,
		dictionary
	)

Construct provenance from a dictionary.

Parameters
----------
dictionary : `dict`
    Dictionary of provenance parameters.

Returns
-------
provenance : `lsst.ip.isr.IsrProvenance`
    The provenance defined in the tables.

Definition at line 672 of file calibType.py.

     def fromDict(cls, dictionary):
         """Construct provenance from a dictionary.
  
         Parameters
         ----------
         dictionary : `dict`
             Dictionary of provenance parameters.
  
         Returns
         -------
         provenance : `lsst.ip.isr.IsrProvenance`
             The provenance defined in the tables.
         """
         calib = cls()
         if calib._OBSTYPE != dictionary['metadata']['OBSTYPE']:
             raise RuntimeError(f"Incorrect calibration supplied.  Expected {calib._OBSTYPE}, "
                                f"found {dictionary['metadata']['OBSTYPE']}")
         calib.updateMetadata(setDate=False, setCalibInfo=True, **dictionary['metadata'])
  
         # These properties should be in the metadata, but occasionally
         # are found in the dictionary itself.  Check both places,
         # ending with `None` if neither contains the information.
         calib.calibType = dictionary['calibType']
         calib.dimensions = set(dictionary['dimensions'])
         calib.dataIdList = dictionary['dataIdList']
  
         calib.updateMetadata()
         return calib
  

◆ fromDict() [2/2]

def lsst.ip.isr.calibType.IsrCalib.fromDict	(		cls,
			dictionary,
		**	kwargs
	)

inherited

Construct a calibration from a dictionary of properties.

Must be implemented by the specific calibration subclasses.

Parameters
----------
dictionary : `dict`
    Dictionary of properties.
kwargs : `dict` or collections.abc.Mapping`, optional
    Set of key=value options.

Returns
------
calib : `lsst.ip.isr.CalibType`
    Constructed calibration.

Raises
------
NotImplementedError :
    Raised if not implemented.

Definition at line 449 of file calibType.py.

     def fromDict(cls, dictionary, **kwargs):
         """Construct a calibration from a dictionary of properties.
  
         Must be implemented by the specific calibration subclasses.
  
         Parameters
         ----------
         dictionary : `dict`
             Dictionary of properties.
         kwargs : `dict` or collections.abc.Mapping`, optional
             Set of key=value options.
  
         Returns
         ------
         calib : `lsst.ip.isr.CalibType`
             Constructed calibration.
  
         Raises
         ------
         NotImplementedError :
             Raised if not implemented.
         """
         raise NotImplementedError("Must be implemented by subclass.")
  

◆ fromTable() [1/2]

def lsst.ip.isr.calibType.IsrProvenance.fromTable	(	cls,
		tableList
	)

Construct provenance from table list.

Parameters
----------
tableList : `list` [`lsst.afw.table.Table`]
    List of tables to construct the provenance from.

Returns
-------
provenance : `lsst.ip.isr.IsrProvenance`
    The provenance defined in the tables.

Definition at line 636 of file calibType.py.

     def fromTable(cls, tableList):
         """Construct provenance from table list.
  
         Parameters
         ----------
         tableList : `list` [`lsst.afw.table.Table`]
             List of tables to construct the provenance from.
  
         Returns
         -------
         provenance : `lsst.ip.isr.IsrProvenance`
             The provenance defined in the tables.
         """
         table = tableList[0]
         metadata = table.meta
         inDict = dict()
         inDict['metadata'] = metadata
         inDict['calibType'] = metadata['calibType']
         inDict['dimensions'] = set()
         inDict['dataIdList'] = list()
  
         schema = dict()
         for colName in table.columns:
             schema[colName.lower()] = colName
             inDict['dimensions'].add(colName.lower())
         inDict['dimensions'] = sorted(inDict['dimensions'])
  
         for row in table:
             entry = dict()
             for dim in sorted(inDict['dimensions']):
                 entry[dim] = row[schema[dim]]
             inDict['dataIdList'].append(entry)
  
         return cls.fromDict(inDict)
  

◆ fromTable() [2/2]

def lsst.ip.isr.calibType.IsrCalib.fromTable	(		cls,
			tableList,
		**	kwargs
	)

inherited

Construct a calibration from a dictionary of properties.

Must be implemented by the specific calibration subclasses.

Parameters
----------
tableList : `list` [`lsst.afw.table.Table`]
    List of tables of properties.
kwargs : `dict` or collections.abc.Mapping`, optional
    Set of key=value options.

Returns
------
calib : `lsst.ip.isr.CalibType`
    Constructed calibration.

Raises
------
NotImplementedError :
    Raised if not implemented.

Definition at line 492 of file calibType.py.

     def fromTable(cls, tableList, **kwargs):
         """Construct a calibration from a dictionary of properties.
  
         Must be implemented by the specific calibration subclasses.
  
         Parameters
         ----------
         tableList : `list` [`lsst.afw.table.Table`]
             List of tables of properties.
         kwargs : `dict` or collections.abc.Mapping`, optional
             Set of key=value options.
  
         Returns
         ------
         calib : `lsst.ip.isr.CalibType`
             Constructed calibration.
  
         Raises
         ------
         NotImplementedError :
             Raised if not implemented.
         """
         raise NotImplementedError("Must be implemented by subclass.")
  

◆ getMetadata()

def lsst.ip.isr.calibType.IsrCalib.getMetadata ( self )

inherited

Retrieve metadata associated with this calibration.

Returns
-------
meta : `lsst.daf.base.PropertyList`
    Metadata. The returned `~lsst.daf.base.PropertyList` can be
    modified by the caller and the changes will be written to
    external files.

Definition at line 114 of file calibType.py.

     def getMetadata(self):
         """Retrieve metadata associated with this calibration.
  
         Returns
         -------
         meta : `lsst.daf.base.PropertyList`
             Metadata. The returned `~lsst.daf.base.PropertyList` can be
             modified by the caller and the changes will be written to
             external files.
         """
         return self._metadata
  

◆ readFits()

def lsst.ip.isr.calibType.IsrCalib.readFits	(		cls,
			filename,
		**	kwargs
	)

inherited

Read calibration data from a FITS file.

Parameters
----------
filename : `str`
    Filename to read data from.
kwargs : `dict` or collections.abc.Mapping`, optional
    Set of key=value pairs to pass to the ``fromTable``
    method.

Returns
-------
calib : `lsst.ip.isr.IsrCalib`
    Calibration contained within the file.

Definition at line 370 of file calibType.py.

     def readFits(cls, filename, **kwargs):
         """Read calibration data from a FITS file.
  
         Parameters
         ----------
         filename : `str`
             Filename to read data from.
         kwargs : `dict` or collections.abc.Mapping`, optional
             Set of key=value pairs to pass to the ``fromTable``
             method.
  
         Returns
         -------
         calib : `lsst.ip.isr.IsrCalib`
             Calibration contained within the file.
         """
         tableList = []
         tableList.append(Table.read(filename, hdu=1))
         extNum = 2  # Fits indices start at 1, we've read one already.
         keepTrying = True
  
         while keepTrying:
             with warnings.catch_warnings():
                 warnings.simplefilter("error")
                 try:
                     newTable = Table.read(filename, hdu=extNum)
                     tableList.append(newTable)
                     extNum += 1
                 except Exception:
                     keepTrying = False
  
         for table in tableList:
             for k, v in table.meta.items():
                 if isinstance(v, fits.card.Undefined):
                     table.meta[k] = None
  
         return cls.fromTable(tableList, **kwargs)
  

◆ readText()

def lsst.ip.isr.calibType.IsrCalib.readText	(		cls,
			filename,
		**	kwargs
	)

inherited

Read calibration representation from a yaml/ecsv file.

Parameters
----------
filename : `str`
    Name of the file containing the calibration definition.
kwargs : `dict` or collections.abc.Mapping`, optional
    Set of key=value pairs to pass to the ``fromDict`` or
    ``fromTable`` methods.

Returns
-------
calib : `~lsst.ip.isr.IsrCalibType`
    Calibration class.

Raises
------
RuntimeError :
    Raised if the filename does not end in ".ecsv" or ".yaml".

Definition at line 284 of file calibType.py.

     def readText(cls, filename, **kwargs):
         """Read calibration representation from a yaml/ecsv file.
  
         Parameters
         ----------
         filename : `str`
             Name of the file containing the calibration definition.
         kwargs : `dict` or collections.abc.Mapping`, optional
             Set of key=value pairs to pass to the ``fromDict`` or
             ``fromTable`` methods.
  
         Returns
         -------
         calib : `~lsst.ip.isr.IsrCalibType`
             Calibration class.
  
         Raises
         ------
         RuntimeError :
             Raised if the filename does not end in ".ecsv" or ".yaml".
         """
         if filename.endswith((".ecsv", ".ECSV")):
             data = Table.read(filename, format='ascii.ecsv')
             return cls.fromTable([data], **kwargs)
  
         elif filename.endswith((".yaml", ".YAML")):
             with open(filename, 'r') as f:
                 data = yaml.load(f, Loader=yaml.CLoader)
             return cls.fromDict(data, **kwargs)
         else:
             raise RuntimeError(f"Unknown filename extension: {filename}")
  

◆ requiredAttributes() [1/2]

def lsst.ip.isr.calibType.IsrCalib.requiredAttributes ( self )

inherited

Definition at line 107 of file calibType.py.

     def requiredAttributes(self):
         return self._requiredAttributes
  

◆ requiredAttributes() [2/2]

def lsst.ip.isr.calibType.IsrCalib.requiredAttributes	(	self,
		value
	)

inherited

Definition at line 111 of file calibType.py.

     def requiredAttributes(self, value):
         self._requiredAttributes = value
  

◆ setMetadata()

def lsst.ip.isr.calibType.IsrCalib.setMetadata	(	self,
		metadata
	)

inherited

Store a copy of the supplied metadata with this calibration.

Parameters
----------
metadata : `lsst.daf.base.PropertyList`
    Metadata to associate with the calibration.  Will be copied and
    overwrite existing metadata.

Definition at line 126 of file calibType.py.

     def setMetadata(self, metadata):
         """Store a copy of the supplied metadata with this calibration.
  
         Parameters
         ----------
         metadata : `lsst.daf.base.PropertyList`
             Metadata to associate with the calibration.  Will be copied and
             overwrite existing metadata.
         """
         if metadata is not None:
             self._metadata.update(metadata)
  
         # Ensure that we have the obs type required by calibration ingest
         self._metadata["OBSTYPE"] = self._OBSTYPE
         self._metadata[self._OBSTYPE + "_SCHEMA"] = self._SCHEMA
         self._metadata[self._OBSTYPE + "_VERSION"] = self._VERSION
  
         if isinstance(metadata, dict):
             self.calibInfoFromDict(metadata)
         elif isinstance(metadata, PropertyList):
             self.calibInfoFromDict(metadata.toDict())
  

◆ toDict()

def lsst.ip.isr.calibType.IsrProvenance.toDict ( self )

Return a dictionary containing the provenance information.

Returns
-------
dictionary : `dict`
    Dictionary of provenance.

Reimplemented from lsst.ip.isr.calibType.IsrCalib.

Definition at line 701 of file calibType.py.

     def toDict(self):
         """Return a dictionary containing the provenance information.
  
         Returns
         -------
         dictionary : `dict`
             Dictionary of provenance.
         """
         self.updateMetadata()
  
         outDict = {}
  
         metadata = self.getMetadata()
         outDict['metadata'] = metadata
         outDict['detectorName'] = self._detectorName
         outDict['detectorSerial'] = self._detectorSerial
         outDict['detectorId'] = self._detectorId
         outDict['instrument'] = self._instrument
         outDict['calibType'] = self.calibType
         outDict['dimensions'] = list(self.dimensions)
         outDict['dataIdList'] = self.dataIdList
  
         return outDict
  

◆ toTable()

def lsst.ip.isr.calibType.IsrProvenance.toTable ( self )

Return a list of tables containing the provenance.

This seems inefficient and slow, so this may not be the best
way to store the data.

Returns
-------
tableList : `list` [`lsst.afw.table.Table`]
    List of tables containing the provenance information

Reimplemented from lsst.ip.isr.calibType.IsrCalib.

Definition at line 725 of file calibType.py.

     def toTable(self):
         """Return a list of tables containing the provenance.
  
         This seems inefficient and slow, so this may not be the best
         way to store the data.
  
         Returns
         -------
         tableList : `list` [`lsst.afw.table.Table`]
             List of tables containing the provenance information
  
         """
         tableList = []
         self.updateMetadata(setDate=True, setCalibInfo=True)
  
         catalog = Table(rows=self.dataIdList,
                         names=self.dimensions)
         filteredMetadata = {k: v for k, v in self.getMetadata().toDict().items() if v is not None}
         catalog.meta = filteredMetadata
         tableList.append(catalog)
         return tableList

◆ updateMetadata() [1/2]

def lsst.ip.isr.calibType.IsrCalib.updateMetadata	(		self,
			camera = `None`,
			detector = `None`,
			filterName = `None`,
			setCalibId = `False`,
			setCalibInfo = `False`,
			setDate = `False`,
		**	kwargs
	)

inherited

Update metadata keywords with new values.

Parameters
----------
camera : `lsst.afw.cameraGeom.Camera`, optional
    Reference camera to use to set _instrument field.
detector : `lsst.afw.cameraGeom.Detector`, optional
    Reference detector to use to set _detector* fields.
filterName : `str`, optional
    Filter name to assign to this calibration.
setCalibId : `bool`, optional
    Construct the _calibId field from other fields.
setCalibInfo : `bool`, optional
    Set calibration parameters from metadata.
setDate : `bool`, optional
    Ensure the metadata CALIBDATE fields are set to the current datetime.
kwargs : `dict` or `collections.abc.Mapping`, optional
    Set of key=value pairs to assign to the metadata.

Definition at line 148 of file calibType.py.

                        **kwargs):
         """Update metadata keywords with new values.
  
         Parameters
         ----------
         camera : `lsst.afw.cameraGeom.Camera`, optional
             Reference camera to use to set _instrument field.
         detector : `lsst.afw.cameraGeom.Detector`, optional
             Reference detector to use to set _detector* fields.
         filterName : `str`, optional
             Filter name to assign to this calibration.
         setCalibId : `bool`, optional
             Construct the _calibId field from other fields.
         setCalibInfo : `bool`, optional
             Set calibration parameters from metadata.
         setDate : `bool`, optional
             Ensure the metadata CALIBDATE fields are set to the current datetime.
         kwargs : `dict` or `collections.abc.Mapping`, optional
             Set of key=value pairs to assign to the metadata.
         """
         mdOriginal = self.getMetadata()
         mdSupplemental = dict()
  
         for k, v in kwargs.items():
             if isinstance(v, fits.card.Undefined):
                 kwargs[k] = None
  
         if setCalibInfo:
             self.calibInfoFromDict(kwargs)
  
         if camera:
             self._instrument = camera.getName()
  
         if detector:
             self._detectorName = detector.getName()
             self._detectorSerial = detector.getSerial()
             self._detectorId = detector.getId()
             if "_" in self._detectorName:
                 (self._raftName, self._slotName) = self._detectorName.split("_")
  
         if filterName:
             # TOD0 DM-28093: I think this whole comment can go away, if we
             # always use physicalLabel everywhere in ip_isr.
             # If set via:
             # exposure.getInfo().getFilter().getName()
             # then this will hold the abstract filter.
             self._filter = filterName
  
         if setDate:
             date = datetime.datetime.now()
             mdSupplemental['CALIBDATE'] = date.isoformat()
             mdSupplemental['CALIB_CREATION_DATE'] = date.date().isoformat()
             mdSupplemental['CALIB_CREATION_TIME'] = date.time().isoformat()
  
         if setCalibId:
             values = []
             values.append(f"instrument={self._instrument}") if self._instrument else None
             values.append(f"raftName={self._raftName}") if self._raftName else None
             values.append(f"detectorName={self._detectorName}") if self._detectorName else None
             values.append(f"detector={self._detectorId}") if self._detectorId else None
             values.append(f"filter={self._filter}") if self._filter else None
  
             calibDate = mdOriginal.get('CALIBDATE', mdSupplemental.get('CALIBDATE', None))
             values.append(f"calibDate={calibDate}") if calibDate else None
  
             self._calibId = " ".join(values)
  
         self._metadata["INSTRUME"] = self._instrument if self._instrument else None
         self._metadata["RAFTNAME"] = self._raftName if self._raftName else None
         self._metadata["SLOTNAME"] = self._slotName if self._slotName else None
         self._metadata["DETECTOR"] = self._detectorId
         self._metadata["DET_NAME"] = self._detectorName if self._detectorName else None
         self._metadata["DET_SER"] = self._detectorSerial if self._detectorSerial else None
         self._metadata["FILTER"] = self._filter if self._filter else None
         self._metadata["CALIB_ID"] = self._calibId if self._calibId else None
  
         mdSupplemental.update(kwargs)
         mdOriginal.update(mdSupplemental)
  

◆ updateMetadata() [2/2]

def lsst.ip.isr.calibType.IsrProvenance.updateMetadata	(		self,
			setDate = `False`,
		**	kwargs
	)

Update calibration metadata.

Parameters
----------
setDate : `bool, optional
    Update the CALIBDATE fields in the metadata to the current
    time. Defaults to False.
kwargs : `dict` or `collections.abc.Mapping`, optional
    Other keyword parameters to set in the metadata.

Definition at line 607 of file calibType.py.

     def updateMetadata(self, setDate=False, **kwargs):
         """Update calibration metadata.
  
         Parameters
         ----------
         setDate : `bool, optional
             Update the CALIBDATE fields in the metadata to the current
             time. Defaults to False.
         kwargs : `dict` or `collections.abc.Mapping`, optional
             Other keyword parameters to set in the metadata.
         """
         kwargs['calibType'] = self.calibType
         super().updateMetadata(setDate=setDate, **kwargs)
  

◆ validate()

def lsst.ip.isr.calibType.IsrCalib.validate	(	self,
		other = `None`
	)

inherited

Validate that this calibration is defined and can be used.

Parameters
----------
other : `object`, optional
    Thing to validate against.

Returns
-------
valid : `bool`
    Returns true if the calibration is valid and appropriate.

Definition at line 534 of file calibType.py.

     def validate(self, other=None):
         """Validate that this calibration is defined and can be used.
  
         Parameters
         ----------
         other : `object`, optional
             Thing to validate against.
  
         Returns
         -------
         valid : `bool`
             Returns true if the calibration is valid and appropriate.
         """
         return False
  

◆ writeFits()

def lsst.ip.isr.calibType.IsrCalib.writeFits	(	self,
		filename
	)

inherited

Write calibration data to a FITS file.

Parameters
----------
filename : `str`
    Filename to write data to.

Returns
-------
used : `str`
    The name of the file used to write the data.

Definition at line 408 of file calibType.py.

     def writeFits(self, filename):
         """Write calibration data to a FITS file.
  
         Parameters
         ----------
         filename : `str`
             Filename to write data to.
  
         Returns
         -------
         used : `str`
             The name of the file used to write the data.
  
         """
         tableList = self.toTable()
         with warnings.catch_warnings():
             warnings.filterwarnings("ignore", category=Warning, module="astropy.io")
             astropyList = [fits.table_to_hdu(table) for table in tableList]
             astropyList.insert(0, fits.PrimaryHDU())
  
             writer = fits.HDUList(astropyList)
             writer.writeto(filename, overwrite=True)
         return filename
  

◆ writeText()

def lsst.ip.isr.calibType.IsrCalib.writeText	(	self,
		filename,
		format = `'auto'`
	)

inherited

Write the calibration data to a text file.

Parameters
----------
filename : `str`
    Name of the file to write.
format : `str`
    Format to write the file as.  Supported values are:
        ``"auto"`` : Determine filetype from filename.
        ``"yaml"`` : Write as yaml.
        ``"ecsv"`` : Write as ecsv.
Returns
-------
used : `str`
    The name of the file used to write the data.  This may
    differ from the input if the format is explicitly chosen.

Raises
------
RuntimeError :
    Raised if filename does not end in a known extension, or
    if all information cannot be written.

Notes
-----
The file is written to YAML/ECSV format and will include any
associated metadata.

Definition at line 316 of file calibType.py.

     def writeText(self, filename, format='auto'):
         """Write the calibration data to a text file.
  
         Parameters
         ----------
         filename : `str`
             Name of the file to write.
         format : `str`
             Format to write the file as.  Supported values are:
                 ``"auto"`` : Determine filetype from filename.
                 ``"yaml"`` : Write as yaml.
                 ``"ecsv"`` : Write as ecsv.
         Returns
         -------
         used : `str`
             The name of the file used to write the data.  This may
             differ from the input if the format is explicitly chosen.
  
         Raises
         ------
         RuntimeError :
             Raised if filename does not end in a known extension, or
             if all information cannot be written.
  
         Notes
         -----
         The file is written to YAML/ECSV format and will include any
         associated metadata.
  
         """
         if format == 'yaml' or (format == 'auto' and filename.lower().endswith((".yaml", ".YAML"))):
             outDict = self.toDict()
             path, ext = os.path.splitext(filename)
             filename = path + ".yaml"
             with open(filename, 'w') as f:
                 yaml.dump(outDict, f)
         elif format == 'ecsv' or (format == 'auto' and filename.lower().endswith((".ecsv", ".ECSV"))):
             tableList = self.toTable()
             if len(tableList) > 1:
                 # ECSV doesn't support multiple tables per file, so we
                 # can only write the first table.
                 raise RuntimeError(f"Unable to persist {len(tableList)}tables in ECSV format.")
  
             table = tableList[0]
             path, ext = os.path.splitext(filename)
             filename = path + ".ecsv"
             table.write(filename, format="ascii.ecsv")
         else:
             raise RuntimeError(f"Attempt to write to a file {filename} "
                                "that does not end in '.yaml' or '.ecsv'")
  
         return filename
  

Member Data Documentation

◆ calibType

lsst.ip.isr.calibType.IsrProvenance.calibType

Definition at line 593 of file calibType.py.

◆ dataIdList

lsst.ip.isr.calibType.IsrProvenance.dataIdList

Definition at line 595 of file calibType.py.

◆ dimensions

lsst.ip.isr.calibType.IsrProvenance.dimensions

Definition at line 594 of file calibType.py.

◆ log

lsst.ip.isr.calibType.IsrCalib.log

inherited

Definition at line 82 of file calibType.py.

◆ requiredAttributes

lsst.ip.isr.calibType.IsrCalib.requiredAttributes

inherited

Definition at line 77 of file calibType.py.

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

/j/snowflake/release/lsstsw/stack/0.4.3/Linux64/ip_isr/21.0.0-11-g2b59f77+a9c1acf22d/python/lsst/ip/isr/calibType.py

Public Member Functions

Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ __eq__()

◆ __str__()

◆ apply()

◆ calibInfoFromDict()

◆ fromDataIds()

◆ fromDetector()

◆ fromDict() [1/2]

◆ fromDict() [2/2]

◆ fromTable() [1/2]

◆ fromTable() [2/2]

◆ getMetadata()

◆ readFits()

◆ readText()

◆ requiredAttributes() [1/2]

◆ requiredAttributes() [2/2]

◆ setMetadata()

◆ toDict()

◆ toTable()

◆ updateMetadata() [1/2]

◆ updateMetadata() [2/2]

◆ validate()

◆ writeFits()

◆ writeText()

Member Data Documentation

◆ calibType

◆ dataIdList

◆ dimensions

◆ log

◆ requiredAttributes

◆ init()

◆ eq()

◆ str()