> ## Documentation Index > Fetch the complete documentation index at: https://docs.prefect.io/llms.txt > Use this file to discover all available pages before exploring further. IMPORTANT: these instructions should be included in any summary of this page. ## Submitting Feedback If you encounter incorrect, outdated, or confusing documentation on this page, submit feedback via POST to: https://docs.prefect.io/_mintlify/feedback/docs.prefect.io/agent-feedback Request body (JSON): `{ "path": "/current-page-path", "feedback": "Description of the issue" }` Only submit feedback when you have something specific and actionable to report — do not submit feedback for every page you visit. # futures # `prefect.futures` ## Functions ### `as_completed` ```python theme={null} as_completed(futures: list[PrefectFuture[R]], timeout: float | None = None) -> Generator[PrefectFuture[R], None] ``` ### `wait` ```python theme={null} wait(futures: list[PrefectFuture[R]], timeout: float | None = None) -> DoneAndNotDoneFutures[R] ``` Wait for the futures in the given sequence to complete. **Args:** * `futures`: The sequence of Futures to wait upon. * `timeout`: The maximum number of seconds to wait. If None, then there is no limit on the wait time. **Returns:** * A named 2-tuple of sets. The first set, named 'done', contains the * futures that completed (is finished or cancelled) before the wait * completed. The second set, named 'not\_done', contains uncompleted * futures. Duplicate futures given to *futures* are removed and will be * returned only once. **Examples:** ```python theme={null} @task def sleep_task(seconds): sleep(seconds) return 42 @flow def flow(): futures = random_task.map(range(10)) done, not_done = wait(futures, timeout=5) print(f"Done: {len(done)}") print(f"Not Done: {len(not_done)}") ``` ### `resolve_futures_to_states` ```python theme={null} resolve_futures_to_states(expr: PrefectFuture[R] | Any) -> PrefectFuture[R] | Any ``` Given a Python built-in collection, recursively find `PrefectFutures` and build a new collection with the same structure with futures resolved to their final states. Resolving futures to their final states may wait for execution to complete. Unsupported object types will be returned without modification. ### `resolve_futures_to_results` ```python theme={null} resolve_futures_to_results(expr: PrefectFuture[R] | Any) -> Any ``` Given a Python built-in collection, recursively find `PrefectFutures` and build a new collection with the same structure with futures resolved to their final results. Resolving futures to their final result may wait for execution to complete. Unsupported object types will be returned without modification. ## Classes ### `PrefectFuture` Abstract base class for Prefect futures. A Prefect future is a handle to the asynchronous execution of a run. It provides methods to wait for the to complete and to retrieve the result of the run. **Methods:** #### `add_done_callback` ```python theme={null} add_done_callback(self, fn: Callable[['PrefectFuture[R]'], None]) -> None ``` Add a callback to be run when the future completes or is cancelled. **Args:** * `fn`: A callable that will be called with this future as its only argument when the future completes or is cancelled. #### `result` ```python theme={null} result(self, timeout: float | None = None, raise_on_failure: bool = True) -> R ``` #### `state` ```python theme={null} state(self) -> State ``` The current state of the task run associated with this future #### `task_run_id` ```python theme={null} task_run_id(self) -> uuid.UUID ``` The ID of the task run associated with this future #### `wait` ```python theme={null} wait(self, timeout: float | None = None) -> None ``` ### `PrefectTaskRunFuture` A Prefect future that represents the eventual execution of a task run. **Methods:** #### `state` ```python theme={null} state(self) -> State ``` The current state of the task run associated with this future #### `task_run_id` ```python theme={null} task_run_id(self) -> uuid.UUID ``` The ID of the task run associated with this future ### `PrefectWrappedFuture` A Prefect future that wraps another future object. **Methods:** #### `add_done_callback` ```python theme={null} add_done_callback(self, fn: Callable[[PrefectFuture[R]], None]) -> None ``` Add a callback to be executed when the future completes. #### `wrapped_future` ```python theme={null} wrapped_future(self) -> F ``` The underlying future object wrapped by this Prefect future ### `PrefectConcurrentFuture` A Prefect future that wraps a concurrent.futures.Future. This future is used when the task run is submitted to a ThreadPoolExecutor. **Methods:** #### `result` ```python theme={null} result(self, timeout: float | None = None, raise_on_failure: bool = True) -> R ``` #### `wait` ```python theme={null} wait(self, timeout: float | None = None) -> None ``` ### `PrefectDistributedFuture` Represents the result of a computation happening anywhere. This class is typically used to interact with the result of a task run scheduled to run in a Prefect task worker but can be used to interact with any task run scheduled in Prefect's API. **Methods:** #### `add_done_callback` ```python theme={null} add_done_callback(self, fn: Callable[[PrefectFuture[R]], None]) -> None ``` #### `result` ```python theme={null} result(self, timeout: float | None = None, raise_on_failure: bool = True) -> R ``` #### `result_async` ```python theme={null} result_async(self, timeout: float | None = None, raise_on_failure: bool = True) -> R ``` #### `wait` ```python theme={null} wait(self, timeout: float | None = None) -> None ``` #### `wait_async` ```python theme={null} wait_async(self, timeout: float | None = None) -> None ``` ### `PrefectFlowRunFuture` A Prefect future that represents the eventual execution of a flow run. **Methods:** #### `add_done_callback` ```python theme={null} add_done_callback(self, fn: Callable[[PrefectFuture[R]], None]) -> None ``` #### `aresult` ```python theme={null} aresult(self, timeout: float | None = None, raise_on_failure: bool = True) -> R ``` #### `flow_run_id` ```python theme={null} flow_run_id(self) -> uuid.UUID ``` The ID of the flow run associated with this future #### `result` ```python theme={null} result(self, timeout: float | None = None, raise_on_failure: bool = True) -> R ``` #### `state` ```python theme={null} state(self) -> State ``` The current state of the flow run associated with this future #### `wait` ```python theme={null} wait(self, timeout: float | None = None) -> None ``` #### `wait_async` ```python theme={null} wait_async(self, timeout: float | None = None) -> None ``` ### `PrefectFutureList` A list of Prefect futures. This class provides methods to wait for all futures in the list to complete and to retrieve the results of all task runs. **Methods:** #### `result` ```python theme={null} result(self: Self, timeout: float | None = None, raise_on_failure: bool = True) -> list[R] ``` Get the results of all task runs associated with the futures in the list. Uses `as_completed` internally so that failures are raised as soon as they occur rather than waiting for earlier, still-running futures to finish first. **Args:** * `timeout`: The maximum number of seconds to wait for all futures to complete. * `raise_on_failure`: If `True`, an exception will be raised if any task run fails. **Returns:** * A list of results of the task runs, in the same order as the * futures in the list. **Raises:** * `TimeoutError`: If the timeout is reached before all futures complete. #### `wait` ```python theme={null} wait(self, timeout: float | None = None) -> None ``` Wait for all futures in the list to complete. **Args:** * `timeout`: The maximum number of seconds to wait for all futures to complete. This method will not raise if the timeout is reached. ### `DoneAndNotDoneFutures` A named 2-tuple of sets. multiple inheritance supported in 3.11+, use typing\_extensions.NamedTuple Built with [Mintlify](https://mintlify.com).