# parsl.dataflow.states.States

class parsl.dataflow.states.States(value, names=None, *values, module=None, qualname=None, type=None, start=1, boundary=None)

  Enumerates the states a parsl task may be in.

  These states occur inside the task record for a task inside a `DataFlowKernel` and in the monitoring database.

  In a single successful task execution, tasks will progress in this sequence:

  pending -> launched -> running -> running_ended -> exec_done

  Other states represent deviations from this path, either due to failures, or to deliberate changes to how tasks are executed (for example due to join_app, or memoization).

  All tasks should end up in one of the states listed in `FINAL_STATES`.

  __init__(*args, **kwds)

  Methods

  `__init__`(*args, **kwds) |
  `as_integer_ratio`() | Return a pair of integers, whose ratio is equal to the original int.
  `bit_count`() | Number of ones in the binary representation of the absolute value of self.
  `bit_length`() | Number of bits necessary to represent self in binary.
  `conjugate` | Returns self, the complex conjugate of any int.
  `from_bytes`([byteorder, signed]) | Return the integer represented by the given array of bytes.
  `is_integer`() | Returns True.
  `to_bytes`([length, byteorder, signed]) | Return an array of bytes representing an integer.

  Attributes

  `unsched` |
  `pending` | Task is known to parsl but cannot run yet.
  `running` | Task is running on a resource.
  `exec_done` | Task has been executed successfully.
  `failed` | Task has failed and no more attempts will be made to run it.
  `dep_fail` | Dependencies of this task failed, so it is marked as failed without even an attempt to launch it.
  `launched` | Task has been passed to a `ParslExecutor` for execution.
  `fail_retryable` | Task has failed, but can be retried
  `memo_done` | Task was found in the memoization table, so it is marked as done without even an attempt to launch it.
  `joining` | Task is a join_app, joining on internal tasks.
  `running_ended` | Like States.running, this state is also not observed by the DFK, but instead only by monitoring.
  `denominator` | the denominator of a rational number in lowest terms
  `imag` | the imaginary part of a complex number
  `numerator` | the numerator of a rational number in lowest terms
  `real` | the real part of a complex number

  dep_fail = 5

    Dependencies of this task failed, so it is marked as failed without even an attempt to launch it.

  exec_done = 3

    Task has been executed successfully.

  fail_retryable = 8

    Task has failed, but can be retried

  failed = 4

    Task has failed and no more attempts will be made to run it.

  joining = 10

    Task is a join_app, joining on internal tasks. The task has run its own Python code, and is now waiting on other tasks before it can make further progress (to a done/failed state).

  launched = 7

    Task has been passed to a `ParslExecutor` for execution.

  memo_done = 9

    Task was found in the memoization table, so it is marked as done without even an attempt to launch it.

  pending = 0

    Task is known to parsl but cannot run yet. Usually, a task cannot run because it is waiting for dependency tasks to complete.

  running = 2

    Task is running on a resource. This state is special - a DFK task record never goes to States.running state; but the monitoring database may represent a task in this state based on non-DFK information received from monitor_wrapper.

  running_ended = 11

    Like States.running, this state is also not observed by the DFK, but instead only by monitoring. This state does not record anything about task success or failure, merely that the wrapper ran long enough to record it as finished.

  unsched = -1