lsst.pipe.base  20.0.0-20-g67d4e31+36c51c22b3
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 47 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 133 of file task.py.

Member Function Documentation

◆ __reduce__()

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

Definition at line 432 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 166 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 204 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 229 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 256 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 274 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
   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.

◆ 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 288 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:

.. code-block:: python

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

Definition at line 359 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
`~lsst.pex.config.ConfigurableField` or
`~lsst.pex.config.RegistryField`.

Definition at line 299 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:

.. code-block:: python

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

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

Definition at line 327 of file task.py.

Member Data Documentation

◆ config

lsst.pipe.base.task.Task.config

Definition at line 162 of file task.py.

◆ log

lsst.pipe.base.task.Task.log

Definition at line 161 of file task.py.

◆ metadata

lsst.pipe.base.task.Task.metadata

Definition at line 134 of file task.py.


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