lsst.pipe.base  19.0.0-23-gdc29a50+2
Public Member Functions | Static Public Member Functions | Public Attributes | Static Public Attributes | List of all members
lsst.pipe.base.cmdLineTask.LegacyTaskRunner Class Reference
Inheritance diagram for lsst.pipe.base.cmdLineTask.LegacyTaskRunner:
lsst.pipe.base.cmdLineTask.TaskRunner

Public Member Functions

def runTask (self, task, dataRef, kwargs)
 
def prepareForMultiProcessing (self)
 
def run (self, parsedCmd)
 
def makeTask (self, parsedCmd=None, args=None)
 
def precall (self, parsedCmd)
 
def __call__ (self, args)
 

Static Public Member Functions

def getTargetList (parsedCmd, **kwargs)
 

Public Attributes

 TaskClass
 
 doReturnResults
 
 config
 
 log
 
 doRaise
 
 clobberConfig
 
 doBackup
 
 numProcesses
 
 timeout
 

Static Public Attributes

int TIMEOUT = 3600*24*30
 

Detailed Description

A `TaskRunner` for `CmdLineTask`\ s which calls the `Task`\ 's `run` method on a `dataRef` rather
than the `runDataRef` method.

Definition at line 450 of file cmdLineTask.py.

Member Function Documentation

◆ __call__()

def lsst.pipe.base.cmdLineTask.TaskRunner.__call__ (   self,
  args 
)
inherited
Run the Task on a single target.

Parameters
----------
args
    Arguments for Task.runDataRef()

Returns
-------
struct : `lsst.pipe.base.Struct`
    Contains these fields if ``doReturnResults`` is `True`:

    - ``dataRef``: the provided data reference.
    - ``metadata``: task metadata after execution of run.
    - ``result``: result returned by task run, or `None` if the task fails.
    - ``exitStatus``: 0 if the task completed successfully, 1 otherwise.

    If ``doReturnResults`` is `False` the struct contains:

    - ``exitStatus``: 0 if the task completed successfully, 1 otherwise.

Notes
-----
This default implementation assumes that the ``args`` is a tuple containing a data reference and a
dict of keyword arguments.

.. warning::

   If you override this method and wish to return something when ``doReturnResults`` is `False`,
   then it must be picklable to support multiprocessing and it should be small enough that pickling
   and unpickling do not add excessive overhead.

Definition at line 341 of file cmdLineTask.py.

◆ getTargetList()

def lsst.pipe.base.cmdLineTask.TaskRunner.getTargetList (   parsedCmd,
**  kwargs 
)
staticinherited
Get a list of (dataRef, kwargs) for `TaskRunner.__call__`.

Parameters
----------
parsedCmd : `argparse.Namespace`
    The parsed command object returned by `lsst.pipe.base.argumentParser.ArgumentParser.parse_args`.
kwargs
    Any additional keyword arguments. In the default `TaskRunner` this is an empty dict, but having
    it simplifies overriding `TaskRunner` for tasks whose runDataRef method takes additional arguments
    (see case (1) below).

Notes
-----
The default implementation of `TaskRunner.getTargetList` and `TaskRunner.__call__` works for any
command-line task whose runDataRef method takes exactly one argument: a data reference. Otherwise you
must provide a variant of TaskRunner that overrides `TaskRunner.getTargetList` and possibly
`TaskRunner.__call__`. There are two cases.

**Case 1**

If your command-line task has a ``runDataRef`` method that takes one data reference followed by
additional arguments, then you need only override `TaskRunner.getTargetList` to return the additional
arguments as an argument dict. To make this easier, your overridden version of
`~TaskRunner.getTargetList` may call `TaskRunner.getTargetList` with the extra arguments as keyword
arguments. For example, the following adds an argument dict containing a single key: "calExpList",
whose value is the list of data IDs for the calexp ID argument::

    def getTargetList(parsedCmd):
return TaskRunner.getTargetList(
    parsedCmd,
    calExpList=parsedCmd.calexp.idList
)

It is equivalent to this slightly longer version::

    @staticmethod
    def getTargetList(parsedCmd):
argDict = dict(calExpList=parsedCmd.calexp.idList)
return [(dataId, argDict) for dataId in parsedCmd.id.idList]

**Case 2**

If your task does not meet condition (1) then you must override both TaskRunner.getTargetList and
`TaskRunner.__call__`. You may do this however you see fit, so long as `TaskRunner.getTargetList`
returns a list, each of whose elements is sent to `TaskRunner.__call__`, which runs your task.

Definition at line 233 of file cmdLineTask.py.

◆ makeTask()

def lsst.pipe.base.cmdLineTask.TaskRunner.makeTask (   self,
  parsedCmd = None,
  args = None 
)
inherited
Create a Task instance.

Parameters
----------
parsedCmd
    Parsed command-line options (used for extra task args by some task runners).
args
    Args tuple passed to `TaskRunner.__call__` (used for extra task arguments by some task runners).

Notes
-----
``makeTask`` can be called with either the ``parsedCmd`` argument or ``args`` argument set to None,
but it must construct identical Task instances in either case.

Subclasses may ignore this method entirely if they reimplement both `TaskRunner.precall` and
`TaskRunner.__call__`.

Reimplemented in lsst.pipe.base.cmdLineTask.ButlerInitializedTaskRunner.

Definition at line 282 of file cmdLineTask.py.

◆ precall()

def lsst.pipe.base.cmdLineTask.TaskRunner.precall (   self,
  parsedCmd 
)
inherited
Hook for code that should run exactly once, before multiprocessing.

Notes
-----
Must return True if `TaskRunner.__call__` should subsequently be called.

.. warning::

   Implementations must take care to ensure that no unpicklable attributes are added to the
   TaskRunner itself, for compatibility with multiprocessing.

The default implementation writes package versions, schemas and configs, or compares them to existing
files on disk if present.

Definition at line 312 of file cmdLineTask.py.

◆ prepareForMultiProcessing()

def lsst.pipe.base.cmdLineTask.TaskRunner.prepareForMultiProcessing (   self)
inherited
Prepare this instance for multiprocessing

Optional non-picklable elements are removed.

This is only called if the task is run under multiprocessing.

Definition at line 174 of file cmdLineTask.py.

◆ run()

def lsst.pipe.base.cmdLineTask.TaskRunner.run (   self,
  parsedCmd 
)
inherited
Run the task on all targets.

Parameters
----------
parsedCmd : `argparse.Namespace`
    Parsed command `argparse.Namespace`.

Returns
-------
resultList : `list`
    A list of results returned by `TaskRunner.__call__`, or an empty list if `TaskRunner.__call__`
    is not called (e.g. if `TaskRunner.precall` returns `False`). See `TaskRunner.__call__`
    for details.

Notes
-----
The task is run under multiprocessing if `TaskRunner.numProcesses` is more than 1; otherwise
processing is serial.

Definition at line 183 of file cmdLineTask.py.

◆ runTask()

def lsst.pipe.base.cmdLineTask.LegacyTaskRunner.runTask (   self,
  task,
  dataRef,
  kwargs 
)
Call `run` for this task instead of `runDataRef`.  See `TaskRunner.runTask` above for details.

Reimplemented from lsst.pipe.base.cmdLineTask.TaskRunner.

Definition at line 455 of file cmdLineTask.py.

Member Data Documentation

◆ clobberConfig

lsst.pipe.base.cmdLineTask.TaskRunner.clobberConfig
inherited

Definition at line 161 of file cmdLineTask.py.

◆ config

lsst.pipe.base.cmdLineTask.TaskRunner.config
inherited

Definition at line 158 of file cmdLineTask.py.

◆ doBackup

lsst.pipe.base.cmdLineTask.TaskRunner.doBackup
inherited

Definition at line 162 of file cmdLineTask.py.

◆ doRaise

lsst.pipe.base.cmdLineTask.TaskRunner.doRaise
inherited

Definition at line 160 of file cmdLineTask.py.

◆ doReturnResults

lsst.pipe.base.cmdLineTask.TaskRunner.doReturnResults
inherited

Definition at line 157 of file cmdLineTask.py.

◆ log

lsst.pipe.base.cmdLineTask.TaskRunner.log
inherited

Definition at line 159 of file cmdLineTask.py.

◆ numProcesses

lsst.pipe.base.cmdLineTask.TaskRunner.numProcesses
inherited

Definition at line 163 of file cmdLineTask.py.

◆ TaskClass

lsst.pipe.base.cmdLineTask.TaskRunner.TaskClass
inherited

Definition at line 156 of file cmdLineTask.py.

◆ TIMEOUT

int lsst.pipe.base.cmdLineTask.TaskRunner.TIMEOUT = 3600*24*30
staticinherited

Definition at line 152 of file cmdLineTask.py.

◆ timeout

lsst.pipe.base.cmdLineTask.TaskRunner.timeout
inherited

Definition at line 165 of file cmdLineTask.py.


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