Go to the latest version of this document.

# ``twisted`.`internet`.`defer`.`DeferredList``

class documentation

`class DeferredList(Deferred[_DeferredListResultListT[Any]]): (source)`

Constructor: `DeferredList(deferredList, fireOnOneCallback, fireOnOneErrback, consumeErrors)`

View In Hierarchy

`DeferredList` is a tool for collecting the results of several Deferreds.

This tracks a list of `Deferred`s for their results, and makes a single callback when they have all completed. By default, the ultimate result is a list of (success, result) tuples, 'success' being a boolean. `DeferredList` exposes the same API that `Deferred` does, so callbacks and errbacks can be added to it in the same way.

`DeferredList` is implemented by adding callbacks and errbacks to each `Deferred` in the list passed to it. This means callbacks and errbacks added to the Deferreds before they are passed to `DeferredList` will change the result that `DeferredList` sees (i.e., `DeferredList` is not special). Callbacks and errbacks can also be added to the Deferreds after they are passed to `DeferredList` and `DeferredList` may change the result that they see.

See the documentation for the `__init__` arguments for more information.

Method | `__init__` | Initialize a DeferredList.
Method | `cancel` | Cancel this `DeferredList`.
Instance Variable | `consumeErrors` | Undocumented
Instance Variable | `finishedCount` | Undocumented
Instance Variable | `fireOnOneCallback` | Undocumented
Instance Variable | `fireOnOneErrback` | Undocumented
Instance Variable | `resultList` | The final result, in progress. Each item in the list corresponds to the `Deferred` at the same position in `_deferredList`. It will be `None` if the `Deferred` did not complete yet, or a `(success, result)` pair if it did.
Method | `_cbDeferred` | (internal) Callback for when one of my deferreds fires.
Instance Variable | `_deferredList` | The `list` of `Deferred`s to track.

Inherited from `Deferred`:

Class Method | `fromCoroutine` | Schedule the execution of a coroutine that awaits on `Deferred`s, wrapping it in a `Deferred` that will fire on success/failure of the coroutine.
Class Method | `fromFuture` | Adapt a `Future` to a `Deferred`.
Method | `__init_subclass__` | Undocumented
Method | `__iter__` | Undocumented
Method | `__str__` | Return a string representation of this `Deferred`.
Method | `addBoth` | Convenience method for adding a single callable as both a callback and an errback.
Method | `addCallback` | Convenience method for adding just a callback.
Method | `addCallbacks` | Add a pair of callbacks (success and error) to this `Deferred`.
Method | `addErrback` | Convenience method for adding just an errback.
Method | `addTimeout` | Time out this `Deferred` by scheduling it to be cancelled after `timeout` seconds.
Method | `asFuture` | Adapt this `Deferred` into a `Future` which is bound to `loop`.
Method | `callback` | Run all success callbacks that have been added to this `Deferred`.
Method | `chainDeferred` | Chain another `Deferred` to this `Deferred`.
Method | `errback` | Run all error callbacks that have been added to this `Deferred`.
Method | `pause` | Stop processing on a `Deferred` until `unpause`() is called.
Method | `unpause` | Process all callbacks made since `pause`() was called.
Class Variable | `debug` | Undocumented
Instance Variable | `called` | A flag which is `False` until either `callback` or `errback` is called and afterwards always `True`.
Instance Variable | `paused` | A counter of how many unmatched `pause` calls have been made on this instance.
Instance Variable | `result` | Undocumented
Property | `callbacks` | Undocumented
Method | `_continuation` | Build a tuple of callback and errback with `_Sentinel._CONTINUE`.
Method | `_runCallbacks` | Run the chain of callbacks once a result is available.
Method | `_startRunCallbacks` | Undocumented
Instance Variable | `_callbacks` | Undocumented
Instance Variable | `_canceller` | Undocumented
Instance Variable | `_chainedTo` | If this `Deferred` is waiting for the result of another `Deferred`, this is a reference to the other Deferred. Otherwise, `None`.
Instance Variable | `_debugInfo` | Undocumented
Instance Variable | `_runningCallbacks` | A flag which is `True` while this instance is executing its callback chain, used to stop recursive execution of `_runCallbacks`
Instance Variable | `_suppressAlreadyCalled` | A flag used by the cancellation mechanism which is `True` if the Deferred has no canceller and has been cancelled, `False` otherwise. If `True`, it can be expected that `callback` or `errback` will eventually be called and the result should be silently discarded.

def __init__(self, deferredList: `Iterable[Deferred[_SelfResultT]]`, fireOnOneCallback: `bool` = False, fireOnOneErrback: `bool` = False, consumeErrors: `bool` = False): (source)
overrides `twisted.internet.defer.Deferred.__init__`

Initialize a DeferredList.

Parameters
deferredList:`Iterable[Deferred[_SelfResultT]]` | The deferreds to track.

fireOnOneCallback:`bool`

(keyword param) a flag indicating that this `DeferredList` will fire when the first `Deferred` in `deferredList` fires with a non-failure result without waiting for any of the other Deferreds. When this flag is set, the DeferredList will fire with a two-tuple: the first element is the result of the Deferred which fired; the second element is the index in `deferredList` of that Deferred.

fireOnOneErrback:`bool` | (keyword param) a flag indicating that this `DeferredList` will fire when the first `Deferred` in `deferredList` fires with a failure result without waiting for any of the other Deferreds. When this flag is set, if a Deferred in the list errbacks, the DeferredList will errback with a `FirstError` failure wrapping the failure of that Deferred.

consumeErrors:`bool`

(keyword param) a flag indicating that failures in any of the included `Deferred`s should not be propagated to errbacks added to the individual `Deferred`s after this `DeferredList` is constructed. After constructing the `DeferredList`, any errors in the individual `Deferred`s will be converted to a callback result of `None`. This is useful to prevent spurious 'Unhandled error in Deferred' messages from being logged. This does not prevent `fireOnOneErrback` from working.

def cancel(self): (source)
overrides `twisted.internet.defer.Deferred.cancel`

Cancel this `DeferredList`.

If the `DeferredList` hasn't fired yet, cancel every `Deferred` in the list.

If the `DeferredList` has fired, including the case where the `fireOnOneCallback`/`fireOnOneErrback` flag is set and the `DeferredList` fires because one `Deferred` in the list fires with a non-failure/failure result, do nothing in the `cancel` method.

consumeErrors = (source)

Undocumented

finishedCount: `int` = (source)

Undocumented

fireOnOneCallback = (source)

Undocumented

fireOnOneErrback = (source)

Undocumented

resultList: `list[_DeferredListResultItemT[Any] | None]` = (source)

The final result, in progress. Each item in the list corresponds to the `Deferred` at the same position in `_deferredList`. It will be `None` if the `Deferred` did not complete yet, or a `(success, result)` pair if it did.

def _cbDeferred(self, result: `_SelfResultT`, index: `int`, succeeded: `bool`) -> `_SelfResultT | None`: (source)

(internal) Callback for when one of my deferreds fires.

_deferredList = (source)

The `list` of `Deferred`s to track.