lsst.pipe.tasks.ingestCalibs.IngestCalibsTask Class Reference

Inheritance diagram for lsst.pipe.tasks.ingestCalibs.IngestCalibsTask:

Public Member Functions
def	run (self, args)
def	parseAndRun (cls)
def	prepareTask (cls, root=None, dryrun=False, mode="move", create=False, ignoreIngested=False)
def	ingest (self, infile, outfile, mode="move", dryrun=False)
def	isBadFile (self, filename, badFileList)
def	isBadId (self, info, badIdList)
def	expandFiles (self, fileNameList)
	Expand a set of filenames and globs, returning a list of filenames. More...
def	runFile (self, infile, registry, args, pos)
	Examine and ingest a single file. More...
def	ingestFiles (self, fileList)
def	emptyMetadata (self)
def	getSchemaCatalogs (self)
def	getAllSchemaCatalogs (self)
def	getFullMetadata (self)
def	getFullName (self)
def	getName (self)
def	getTaskDict (self)
def	makeSubtask (self, name, **keyArgs)
def	timer (self, name, logLevel=Log.DEBUG)
def	makeField (cls, doc)
def	__reduce__ (self)

Public Attributes
	metadata
	log
	config

Static Public Attributes
	ConfigClass = IngestCalibsConfig
	ArgumentParser = IngestCalibsArgumentParser

Detailed Description

Task that generates registry for calibration images

Definition at line 231 of file ingestCalibs.py.

Member Function Documentation

__reduce__()

def lsst.pipe.base.task.Task.__reduce__ (   self )

inherited

Pickler.

Reimplemented in lsst.pipe.drivers.multiBandDriver.MultiBandDriverTask, and lsst.pipe.drivers.coaddDriver.CoaddDriverTask.

Definition at line 432 of file task.py.

    def __reduce__(self):
        """Pickler.
        """
        return self._unpickle_via_factory, (self.__class__, [], self._reduce_kwargs())

emptyMetadata()

def lsst.pipe.base.task.Task.emptyMetadata (   self )

inherited

Empty (clear) the metadata for this Task and all sub-Tasks.

Definition at line 166 of file task.py.

    def emptyMetadata(self):
        """Empty (clear) the metadata for this Task and all sub-Tasks.
        """
        for subtask in self._taskDict.values():
            subtask.metadata = dafBase.PropertyList()
 

expandFiles()

def lsst.pipe.tasks.ingest.IngestTask.expandFiles (   self,   fileNameList  )

inherited

Expand a set of filenames and globs, returning a list of filenames.

    @param fileNameList A list of files and glob patterns

    N.b. globs obey Posix semantics, so a pattern that matches nothing is returned unchanged

Definition at line 557 of file ingest.py.

    def expandFiles(self, fileNameList):
        """!Expand a set of filenames and globs, returning a list of filenames
 
        @param fileNameList A list of files and glob patterns
 
        N.b. globs obey Posix semantics, so a pattern that matches nothing is returned unchanged
        """
        filenameList = []
        for globPattern in fileNameList:
            files = glob(globPattern)
 
            if not files:               # posix behaviour is to return pattern unchanged
                self.log.warn("%s doesn't match any file" % globPattern)
                continue
 
            filenameList.extend(files)
 
        return filenameList
 

getAllSchemaCatalogs()

def lsst.pipe.base.task.Task.getAllSchemaCatalogs (   self )

inherited

Get schema catalogs for all tasks in the hierarchy, combining the
results into a single dict.

Returns
-------
schemacatalogs : `dict`
    Keys are butler dataset type, values are a empty catalog (an
    instance of the appropriate `lsst.afw.table` Catalog type) for all
    tasks in the hierarchy, from the top-level task down
    through all subtasks.

Notes
-----
This method may be called on any task in the hierarchy; it will return
the same answer, regardless.

The default implementation should always suffice. If your subtask uses
schemas the override `Task.getSchemaCatalogs`, not this method.

Definition at line 204 of file task.py.

    def getAllSchemaCatalogs(self):
        """Get schema catalogs for all tasks in the hierarchy, combining the
        results into a single dict.
 
        Returns
        -------
        schemacatalogs : `dict`
            Keys are butler dataset type, values are a empty catalog (an
            instance of the appropriate `lsst.afw.table` Catalog type) for all
            tasks in the hierarchy, from the top-level task down
            through all subtasks.
 
        Notes
        -----
        This method may be called on any task in the hierarchy; it will return
        the same answer, regardless.
 
        The default implementation should always suffice. If your subtask uses
        schemas the override `Task.getSchemaCatalogs`, not this method.
        """
        schemaDict = self.getSchemaCatalogs()
        for subtask in self._taskDict.values():
            schemaDict.update(subtask.getSchemaCatalogs())
        return schemaDict
 

getFullMetadata()

def lsst.pipe.base.task.Task.getFullMetadata (   self )

inherited

Get metadata for all tasks.

Returns
-------
metadata : `lsst.daf.base.PropertySet`
    The `~lsst.daf.base.PropertySet` keys are the full task name.
    Values are metadata for the top-level task and all subtasks,
    sub-subtasks, etc.

Notes
-----
The returned metadata includes timing information (if
``@timer.timeMethod`` is used) and any metadata set by the task. The
name of each item consists of the full task name with ``.`` replaced
by ``:``, followed by ``.`` and the name of the item, e.g.::

    topLevelTaskName:subtaskName:subsubtaskName.itemName

using ``:`` in the full task name disambiguates the rare situation
that a task has a subtask and a metadata item with the same name.

Definition at line 229 of file task.py.

    def getFullMetadata(self):
        """Get metadata for all tasks.
 
        Returns
        -------
        metadata : `lsst.daf.base.PropertySet`
            The `~lsst.daf.base.PropertySet` keys are the full task name.
            Values are metadata for the top-level task and all subtasks,
            sub-subtasks, etc.
 
        Notes
        -----
        The returned metadata includes timing information (if
        ``@timer.timeMethod`` is used) and any metadata set by the task. The
        name of each item consists of the full task name with ``.`` replaced
        by ``:``, followed by ``.`` and the name of the item, e.g.::
 
            topLevelTaskName:subtaskName:subsubtaskName.itemName
 
        using ``:`` in the full task name disambiguates the rare situation
        that a task has a subtask and a metadata item with the same name.
        """
        fullMetadata = dafBase.PropertySet()
        for fullName, task in self.getTaskDict().items():
            fullMetadata.set(fullName.replace(".", ":"), task.metadata)
        return fullMetadata
 

getFullName()

def lsst.pipe.base.task.Task.getFullName (   self )

inherited

Get the task name as a hierarchical name including parent task
names.

Returns
-------
fullName : `str`
    The full name consists of the name of the parent task and each
    subtask separated by periods. For example:

    - The full name of top-level task "top" is simply "top".
    - The full name of subtask "sub" of top-level task "top" is
      "top.sub".
    - The full name of subtask "sub2" of subtask "sub" of top-level
      task "top" is "top.sub.sub2".

Definition at line 256 of file task.py.

    def getFullName(self):
        """Get the task name as a hierarchical name including parent task
        names.
 
        Returns
        -------
        fullName : `str`
            The full name consists of the name of the parent task and each
            subtask separated by periods. For example:
 
            - The full name of top-level task "top" is simply "top".
            - The full name of subtask "sub" of top-level task "top" is
              "top.sub".
            - The full name of subtask "sub2" of subtask "sub" of top-level
              task "top" is "top.sub.sub2".
        """
        return self._fullName
 

getName()

def lsst.pipe.base.task.Task.getName (   self )

inherited

Get the name of the task.

Returns
-------
taskName : `str`
    Name of the task.

See also
--------
getFullName

Definition at line 274 of file task.py.

    def getName(self):
        """Get the name of the task.
 
        Returns
        -------
        taskName : `str`
            Name of the task.
 
        See also
        --------
        getFullName
        """
        return self._name
 

getSchemaCatalogs()

def lsst.pipe.base.task.Task.getSchemaCatalogs (   self )

inherited

Get the schemas generated by this task.

Returns
-------
schemaCatalogs : `dict`
    Keys are butler dataset type, values are an empty catalog (an
    instance of the appropriate `lsst.afw.table` Catalog type) for
    this task.

Notes
-----

.. warning::

   Subclasses that use schemas must override this method. The default
   implementation returns an empty dict.

This method may be called at any time after the Task is constructed,
which means that all task schemas should be computed at construction
time, *not* when data is actually processed. This reflects the
philosophy that the schema should not depend on the data.

Returning catalogs rather than just schemas allows us to save e.g.
slots for SourceCatalog as well.

See also
--------
Task.getAllSchemaCatalogs

Definition at line 172 of file task.py.

    def getSchemaCatalogs(self):
        """Get the schemas generated by this task.
 
        Returns
        -------
        schemaCatalogs : `dict`
            Keys are butler dataset type, values are an empty catalog (an
            instance of the appropriate `lsst.afw.table` Catalog type) for
            this task.
 
        Notes
        -----
 
        .. warning::
 
           Subclasses that use schemas must override this method. The default
           implementation returns an empty dict.
 
        This method may be called at any time after the Task is constructed,
        which means that all task schemas should be computed at construction
        time, *not* when data is actually processed. This reflects the
        philosophy that the schema should not depend on the data.
 
        Returning catalogs rather than just schemas allows us to save e.g.
        slots for SourceCatalog as well.
 
        See also
        --------
        Task.getAllSchemaCatalogs
        """
        return {}
 

getTaskDict()

def lsst.pipe.base.task.Task.getTaskDict (   self )

inherited

Get a dictionary of all tasks as a shallow copy.

Returns
-------
taskDict : `dict`
    Dictionary containing full task name: task object for the top-level
    task and all subtasks, sub-subtasks, etc.

Definition at line 288 of file task.py.

    def getTaskDict(self):
        """Get a dictionary of all tasks as a shallow copy.
 
        Returns
        -------
        taskDict : `dict`
            Dictionary containing full task name: task object for the top-level
            task and all subtasks, sub-subtasks, etc.
        """
        return self._taskDict.copy()
 

ingest()

def lsst.pipe.tasks.ingest.IngestTask.ingest (   self,   infile,   outfile,   mode = "move",   dryrun = False  )

inherited

Ingest a file into the image repository.

@param infile  Name of input file
@param outfile Name of output file (file in repository)
@param mode    Mode of ingest (copy/link/move/skip)
@param dryrun  Only report what would occur?
@param Success boolean

Definition at line 478 of file ingest.py.

    def ingest(self, infile, outfile, mode="move", dryrun=False):
        """Ingest a file into the image repository.
 
        @param infile  Name of input file
        @param outfile Name of output file (file in repository)
        @param mode    Mode of ingest (copy/link/move/skip)
        @param dryrun  Only report what would occur?
        @param Success boolean
        """
        if mode == "skip":
            return True
        if dryrun:
            self.log.info("Would %s from %s to %s" % (mode, infile, outfile))
            return True
        try:
            outdir = os.path.dirname(outfile)
            if not os.path.isdir(outdir):
                try:
                    os.makedirs(outdir)
                except OSError as exc:
                    # Silently ignore mkdir failures due to race conditions
                    if not os.path.isdir(outdir):
                        raise RuntimeError(f"Failed to create directory {outdir}") from exc
            if os.path.lexists(outfile):
                if self.config.clobber:
                    os.unlink(outfile)
                else:
                    raise RuntimeError("File %s already exists; consider --config clobber=True" % outfile)
 
            if mode == "copy":
                assertCanCopy(infile, outfile)
                shutil.copyfile(infile, outfile)
            elif mode == "link":
                if os.path.exists(outfile):
                    if os.path.samefile(infile, outfile):
                        self.log.debug("Already linked %s to %s: ignoring" % (infile, outfile))
                    else:
                        self.log.warn("%s already has a file at the target location (%s): ignoring "
                                      "(set clobber=True to overwrite)" % (infile, outfile))
                    return False
                os.symlink(os.path.abspath(infile), outfile)
            elif mode == "move":
                assertCanCopy(infile, outfile)
                shutil.move(infile, outfile)
            else:
                raise AssertionError("Unknown mode: %s" % mode)
            self.log.info("%s --<%s>--> %s" % (infile, mode, outfile))
        except Exception as e:
            self.log.warn("Failed to %s %s to %s: %s" % (mode, infile, outfile, e))
            if not self.config.allowError:
                raise RuntimeError(f"Failed to {mode} {infile} to {outfile}") from e
            return False
        return True
 

ingestFiles()

def lsst.pipe.tasks.ingest.IngestTask.ingestFiles (   self,   fileList  )

inherited

Ingest specified file or list of files and add them to the registry.

This method can only be called if `prepareTask` was used.

Parameters
----------
fileList : `str` or `list` [`str`]
    Pathname or list of pathnames of files to ingest.

Definition at line 632 of file ingest.py.

    def ingestFiles(self, fileList):
        """Ingest specified file or list of files and add them to the registry.
 
        This method can only be called if `prepareTask` was used.
 
        Parameters
        ----------
        fileList : `str` or `list` [`str`]
            Pathname or list of pathnames of files to ingest.
        """
        if not hasattr(self, "_args"):
            raise RuntimeError("Task not created with prepareTask")
        if isinstance(fileList, str):
            fileList = [fileList]
        self._args.files = fileList
        self.run(self._args)
 
 

isBadFile()

def lsst.pipe.tasks.ingest.IngestTask.isBadFile (   self,   filename,   badFileList  )

inherited

Return whether the file qualifies as bad

We match against the list of bad file patterns.

Definition at line 532 of file ingest.py.

    def isBadFile(self, filename, badFileList):
        """Return whether the file qualifies as bad
 
        We match against the list of bad file patterns.
        """
        filename = os.path.basename(filename)
        if not badFileList:
            return False
        for badFile in badFileList:
            if fnmatch(filename, badFile):
                return True
        return False
 

isBadId()

def lsst.pipe.tasks.ingest.IngestTask.isBadId (   self,   info,   badIdList  )

inherited

Return whether the file information qualifies as bad

We match against the list of bad data identifiers.

Definition at line 545 of file ingest.py.

    def isBadId(self, info, badIdList):
        """Return whether the file information qualifies as bad
 
        We match against the list of bad data identifiers.
        """
        if not badIdList:
            return False
        for badId in badIdList:
            if all(info[key] == value for key, value in badId.items()):
                return True
        return False
 

makeField()

def lsst.pipe.base.task.Task.makeField (   cls,   doc  )

inherited

Make a `lsst.pex.config.ConfigurableField` for this task.

Parameters
----------
doc : `str`
    Help text for the field.

Returns
-------
configurableField : `lsst.pex.config.ConfigurableField`
    A `~ConfigurableField` for this task.

Examples
--------
Provides a convenient way to specify this task is a subtask of another
task.

Here is an example of use:

.. code-block:: python

    class OtherTaskConfig(lsst.pex.config.Config):
        aSubtask = ATaskClass.makeField("brief description of task")

Definition at line 359 of file task.py.

    def makeField(cls, doc):
        """Make a `lsst.pex.config.ConfigurableField` for this task.
 
        Parameters
        ----------
        doc : `str`
            Help text for the field.
 
        Returns
        -------
        configurableField : `lsst.pex.config.ConfigurableField`
            A `~ConfigurableField` for this task.
 
        Examples
        --------
        Provides a convenient way to specify this task is a subtask of another
        task.
 
        Here is an example of use:
 
        .. code-block:: python
 
            class OtherTaskConfig(lsst.pex.config.Config):
                aSubtask = ATaskClass.makeField("brief description of task")
        """
        return ConfigurableField(doc=doc, target=cls)
 

makeSubtask()

def lsst.pipe.base.task.Task.makeSubtask (   self,   name, **  keyArgs  )

inherited

Create a subtask as a new instance as the ``name`` attribute of this
task.

Parameters
----------
name : `str`
    Brief name of the subtask.
keyArgs
    Extra keyword arguments used to construct the task. The following
    arguments are automatically provided and cannot be overridden:

    - "config".
    - "parentTask".

Notes
-----
The subtask must be defined by ``Task.config.name``, an instance of
`~lsst.pex.config.ConfigurableField` or
`~lsst.pex.config.RegistryField`.

Definition at line 299 of file task.py.

    def makeSubtask(self, name, **keyArgs):
        """Create a subtask as a new instance as the ``name`` attribute of this
        task.
 
        Parameters
        ----------
        name : `str`
            Brief name of the subtask.
        keyArgs
            Extra keyword arguments used to construct the task. The following
            arguments are automatically provided and cannot be overridden:
 
            - "config".
            - "parentTask".
 
        Notes
        -----
        The subtask must be defined by ``Task.config.name``, an instance of
        `~lsst.pex.config.ConfigurableField` or
        `~lsst.pex.config.RegistryField`.
        """
        taskField = getattr(self.config, name, None)
        if taskField is None:
            raise KeyError(f"{self.getFullName()}'s config does not have field {name!r}")
        subtask = taskField.apply(name=name, parentTask=self, **keyArgs)
        setattr(self, name, subtask)
 

parseAndRun()

def lsst.pipe.tasks.ingest.IngestTask.parseAndRun (   cls )

inherited

Parse the command-line arguments and run the Task.

Definition at line 428 of file ingest.py.

    def parseAndRun(cls):
        """Parse the command-line arguments and run the Task."""
        task, args = cls._parse()
        task.run(args)
 

prepareTask()

def lsst.pipe.tasks.ingest.IngestTask.prepareTask (   cls,   root = None,   dryrun = False,   mode = "move",   create = False,   ignoreIngested = False  )

inherited

Prepare for running the task repeatedly with `ingestFiles`.

Saves the parsed arguments, including the Butler and log, as a
private instance variable.

Parameters
----------
root : `str`, optional
    Repository root pathname.  If None, run the Task using the
    command line arguments, ignoring all other arguments below.
dryrun : `bool`, optional
    If True, don't perform any action; log what would have happened.
mode : `str`, optional
    How files are delivered to their destination.  Default is "move",
    unlike the command-line default of "link".
create : `bool`, optional
    If True, create a new registry, clobbering any old one present.
ignoreIngested : `bool`, optional
    If True, do not complain if the file is already present in the
    registry (and do nothing else).

Returns
-------
task : `IngestTask`
    If `root` was provided, the IngestTask instance

Definition at line 434 of file ingest.py.

                    ignoreIngested=False):
        """Prepare for running the task repeatedly with `ingestFiles`.
 
        Saves the parsed arguments, including the Butler and log, as a
        private instance variable.
 
        Parameters
        ----------
        root : `str`, optional
            Repository root pathname.  If None, run the Task using the
            command line arguments, ignoring all other arguments below.
        dryrun : `bool`, optional
            If True, don't perform any action; log what would have happened.
        mode : `str`, optional
            How files are delivered to their destination.  Default is "move",
            unlike the command-line default of "link".
        create : `bool`, optional
            If True, create a new registry, clobbering any old one present.
        ignoreIngested : `bool`, optional
            If True, do not complain if the file is already present in the
            registry (and do nothing else).
 
        Returns
        -------
        task : `IngestTask`
            If `root` was provided, the IngestTask instance
        """
        sys.argv = ["IngestTask"]
        sys.argv.append(root)
        if dryrun:
            sys.argv.append("--dry-run")
        sys.argv.append("--mode")
        sys.argv.append(mode)
        if create:
            sys.argv.append("--create")
        if ignoreIngested:
            sys.argv.append("--ignore-ingested")
        sys.argv.append("__fakefile__")    # needed for parsing, not used
 
        task, args = cls._parse()
        task._args = args
        return task
 

run()

def lsst.pipe.tasks.ingestCalibs.IngestCalibsTask.run	(		self,
			args
	)

Ingest all specified files and add them to the registry

Reimplemented from lsst.pipe.tasks.ingest.IngestTask.

Reimplemented in lsst.pipe.tasks.ingestCuratedCalibs.IngestCuratedCalibsTask.

Definition at line 237 of file ingestCalibs.py.

    def run(self, args):
        """Ingest all specified files and add them to the registry"""
        calibRoot = args.calib if args.calib is not None else args.output
        filenameList = self.expandFiles(args.files)
        with self.register.openRegistry(calibRoot, create=args.create, dryrun=args.dryrun) as registry:
            calibTypes = set()
            for infile in filenameList:
                fileInfo, hduInfoList = self.parse.getInfo(infile)
                calibType = self.parse.getCalibType(infile)
                if calibType not in self.register.config.tables:
                    self.log.warn(str("Skipped adding %s of observation type '%s' to registry "
                                      "(must be one of %s)" %
                                      (infile, calibType, ", ".join(self.register.config.tables))))
                    continue
                calibTypes.add(calibType)
                if args.mode != 'skip':
                    outfile = self.parse.getDestination(args.butler, fileInfo, infile)
                    ingested = self.ingest(infile, outfile, mode=args.mode, dryrun=args.dryrun)
                    if not ingested:
                        self.log.warn(str("Failed to ingest %s of observation type '%s'" %
                                          (infile, calibType)))
                        continue
                if self.register.check(registry, fileInfo, table=calibType):
                    if args.ignoreIngested:
                        continue
 
                    self.log.warn("%s: already ingested: %s" % (infile, fileInfo))
                for info in hduInfoList:
                    self.register.addRow(registry, info, dryrun=args.dryrun,
                                         create=args.create, table=calibType)
            if not args.dryrun:
                self.register.updateValidityRanges(registry, args.validity, tables=calibTypes)
            else:
                self.log.info("Would update validity ranges here, but dryrun")

runFile()

def lsst.pipe.tasks.ingest.IngestTask.runFile (   self,   infile,   registry,   args,   pos  )

inherited

Examine and ingest a single file.

    @param infile: File to process
    @param registry: Registry into which to insert Butler metadata, or None
    @param args: Parsed command-line arguments
    @param pos: Position number of this file in the input list
    @return parsed information from FITS HDUs if registry is None; or None

Definition at line 576 of file ingest.py.

    def runFile(self, infile, registry, args, pos):
        """!Examine and ingest a single file
 
        @param infile: File to process
        @param registry: Registry into which to insert Butler metadata, or None
        @param args: Parsed command-line arguments
        @param pos: Position number of this file in the input list
        @return parsed information from FITS HDUs if registry is None; or None
        """
        if self.isBadFile(infile, args.badFile):
            self.log.info("Skipping declared bad file %s" % infile)
            return None
        try:
            fileInfo, hduInfoList = self.parse.getInfo(infile)
        except Exception as e:
            if not self.config.allowError:
                raise RuntimeError(f"Error parsing {infile}") from e
            self.log.warn("Error parsing %s (%s); skipping" % (infile, e))
            return None
        if self.isBadId(fileInfo, args.badId.idList):
            self.log.info("Skipping declared bad file %s: %s" % (infile, fileInfo))
            return None
        if registry is not None and self.register.check(registry, fileInfo):
            if args.ignoreIngested:
                return None
            self.log.warn("%s: already ingested: %s" % (infile, fileInfo))
        outfile = self.parse.getDestination(args.butler, fileInfo, infile)
        if not self.ingest(infile, outfile, mode=args.mode, dryrun=args.dryrun):
            return None
        if hduInfoList is None:
            return None
        if registry is None:
            return hduInfoList
        for info in hduInfoList:
            try:
                self.register.addRow(registry, info, dryrun=args.dryrun, create=args.create)
            except Exception as exc:
                raise IngestError(f"Failed to register file {infile}", infile, pos) from exc
        return None  # No further registration should be performed
 

timer()

def lsst.pipe.base.task.Task.timer (   self,   name,   logLevel = Log.DEBUG  )

inherited

Context manager to log performance data for an arbitrary block of
code.

Parameters
----------
name : `str`
    Name of code being timed; data will be logged using item name:
    ``Start`` and ``End``.
logLevel
    A `lsst.log` level constant.

Examples
--------
Creating a timer context:

.. code-block:: python

    with self.timer("someCodeToTime"):
        pass  # code to time

See also
--------
timer.logInfo

Definition at line 327 of file task.py.

    def timer(self, name, logLevel=Log.DEBUG):
        """Context manager to log performance data for an arbitrary block of
        code.
 
        Parameters
        ----------
        name : `str`
            Name of code being timed; data will be logged using item name:
            ``Start`` and ``End``.
        logLevel
            A `lsst.log` level constant.
 
        Examples
        --------
        Creating a timer context:
 
        .. code-block:: python
 
            with self.timer("someCodeToTime"):
                pass  # code to time
 
        See also
        --------
        timer.logInfo
        """
        logInfo(obj=self, prefix=name + "Start", logLevel=logLevel)
        try:
            yield
        finally:
            logInfo(obj=self, prefix=name + "End", logLevel=logLevel)
 

Member Data Documentation

ArgumentParser

lsst.pipe.tasks.ingestCalibs.IngestCalibsTask.ArgumentParser = IngestCalibsArgumentParser

static

Definition at line 234 of file ingestCalibs.py.

config

lsst.pipe.base.task.Task.config

inherited

Definition at line 162 of file task.py.

ConfigClass

lsst.pipe.tasks.ingestCalibs.IngestCalibsTask.ConfigClass = IngestCalibsConfig

static

Definition at line 233 of file ingestCalibs.py.

log

lsst.pipe.base.task.Task.log

inherited

Definition at line 161 of file task.py.

metadata

lsst.pipe.base.task.Task.metadata

inherited

Definition at line 134 of file task.py.

---

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

• /j/snowflake/release/lsstsw/stack/0.4.3/Linux64/pipe_tasks/21.0.0-64-g1122c245+4fb2b8f86e/python/lsst/pipe/tasks/ingestCalibs.py