lsst.pipe.base  20.0.0-9-gabd0d4c+f2156a2bf2
Public Member Functions | Public Attributes | List of all members
lsst.pipe.base.task.Task Class Reference
Inheritance diagram for lsst.pipe.base.task.Task:
lsst.pipe.base.cmdLineTask.CmdLineTask lsst.pipe.base.pipelineTask.PipelineTask

Public Member Functions

def __init__ (self, config=None, name=None, parentTask=None, log=None)
 
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
 

Detailed Description

Base class for data processing tasks.

See :ref:`task-framework-overview` to learn what tasks are, and :ref:`creating-a-task` for more
information about writing tasks.

Parameters
----------
config : `Task.ConfigClass` instance, optional
    Configuration for this task (an instance of Task.ConfigClass, which is a task-specific subclass of
    `lsst.pex.config.Config`, or `None`. If `None`:

    - If parentTask specified then defaults to parentTask.config.\<name>
    - If parentTask is None then defaults to self.ConfigClass()

name : `str`, optional
    Brief name of task, or `None`; if `None` then defaults to `Task._DefaultName`
parentTask : `Task`-type, optional
    The parent task of this subtask, if any.

    - If `None` (a top-level task) then you must specify config and name is ignored.
    - If not `None` (a subtask) then you must specify name.
log : `lsst.log.Log`, optional
    Log whose name is used as a log name prefix, or `None` for no prefix. Ignored if is parentTask
    specified, in which case ``parentTask.log``\ 's name is used as a prefix. The task's log name is
    ``prefix + "." + name`` if a prefix exists, else ``name``. The task's log is then a child logger of
    ``parentTask.log`` (if ``parentTask`` specified), or a child logger of the log from the argument
    (if ``log`` is not `None`).

Raises
------
RuntimeError
    Raised under these circumstances:

    - If ``parentTask`` is `None` and ``config`` is `None`.
    - If ``parentTask`` is not `None` and ``name`` is `None`.
    - If ``name`` is `None` and ``_DefaultName`` does not exist.

Notes
-----
Useful attributes include:

- ``log``: an lsst.log.Log
- ``config``: task-specific configuration; an instance of ``ConfigClass`` (see below).
- ``metadata``: an `lsst.daf.base.PropertyList` for collecting task-specific metadata,
    e.g. data quality and performance metrics. This is data that is only meant to be
    persisted, never to be used by the task.

Subclasses typically have a method named ``runDataRef`` to perform the main data processing. Details:

- ``runDataRef`` should process the minimum reasonable amount of data, typically a single CCD.
  Iteration, if desired, is performed by a caller of the method. This is good design and allows
  multiprocessing without the run method having to support it directly.
- If ``runDataRef`` can persist or unpersist data:

  - ``runDataRef`` should accept a butler data reference (or a collection of data references,
    if appropriate, e.g. coaddition).
  - There should be a way to run the task without persisting data. Typically the run method returns all
    data, even if it is persisted, and the task's config method offers a flag to disable persistence.

**Deprecated:** Tasks other than cmdLineTask.CmdLineTask%s should *not* accept a blob such as a butler
data reference.  How we will handle data references is still TBD, so don't make changes yet!
RHL 2014-06-27

Subclasses must also have an attribute ``ConfigClass`` that is a subclass of `lsst.pex.config.Config`
which configures the task. Subclasses should also have an attribute ``_DefaultName``:
the default name if there is no parent task. ``_DefaultName`` is required for subclasses of
`~lsst.pipe.base.CmdLineTask` and recommended for subclasses of Task because it simplifies construction
(e.g. for unit tests).

Tasks intended to be run from the command line should be subclasses of `~lsst.pipe.base.CmdLineTask`
not Task.

Definition at line 46 of file task.py.

Constructor & Destructor Documentation

◆ __init__()

def lsst.pipe.base.task.Task.__init__ (   self,
  config = None,
  name = None,
  parentTask = None,
  log = None 
)

Definition at line 120 of file task.py.

Member Function Documentation

◆ __reduce__()

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

Definition at line 373 of file task.py.

◆ emptyMetadata()

def lsst.pipe.base.task.Task.emptyMetadata (   self)
Empty (clear) the metadata for this Task and all sub-Tasks.

Definition at line 153 of file task.py.

◆ getAllSchemaCatalogs()

def lsst.pipe.base.task.Task.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.

Definition at line 188 of file task.py.

◆ getFullMetadata()

def lsst.pipe.base.task.Task.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.

Definition at line 210 of file task.py.

◆ getFullName()

def lsst.pipe.base.task.Task.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".

Definition at line 235 of file task.py.

◆ getName()

def lsst.pipe.base.task.Task.getName (   self)
Get the name of the task.

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

See also
--------
getFullName

Definition at line 250 of file task.py.

◆ getSchemaCatalogs()

def lsst.pipe.base.task.Task.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 implemenation 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 159 of file task.py.

◆ getTaskDict()

def lsst.pipe.base.task.Task.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..

Definition at line 264 of file task.py.

◆ makeField()

def lsst.pipe.base.task.Task.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::

    class OtherTaskConfig(lsst.pex.config.Config)
aSubtask = ATaskClass.makeField("a brief description of what this task does")

Definition at line 329 of file task.py.

◆ makeSubtask()

def lsst.pipe.base.task.Task.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 pex_config ConfigurableField
or RegistryField.

Definition at line 275 of file task.py.

◆ timer()

def lsst.pipe.base.task.Task.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::

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

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

Definition at line 301 of file task.py.

Member Data Documentation

◆ config

lsst.pipe.base.task.Task.config

Definition at line 149 of file task.py.

◆ log

lsst.pipe.base.task.Task.log

Definition at line 148 of file task.py.

◆ metadata

lsst.pipe.base.task.Task.metadata

Definition at line 121 of file task.py.


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