`prefect.task_engine`

Functions

`run_task_sync`

run_task_sync(task: 'Task[P, R]', task_run_id: Optional[UUID] = None, task_run: Optional[TaskRun] = None, parameters: Optional[dict[str, Any]] = None, wait_for: Optional['OneOrManyFutureOrResult[Any]'] = None, return_type: Literal['state', 'result'] = 'result', dependencies: Optional[dict[str, set[RunInput]]] = None, context: Optional[dict[str, Any]] = None) -> Union[R, State, None]

`run_task_async`

run_task_async(task: 'Task[P, R]', task_run_id: Optional[UUID] = None, task_run: Optional[TaskRun] = None, parameters: Optional[dict[str, Any]] = None, wait_for: Optional['OneOrManyFutureOrResult[Any]'] = None, return_type: Literal['state', 'result'] = 'result', dependencies: Optional[dict[str, set[RunInput]]] = None, context: Optional[dict[str, Any]] = None) -> Union[R, State, None]

`run_generator_task_sync`

run_generator_task_sync(task: 'Task[P, R]', task_run_id: Optional[UUID] = None, task_run: Optional[TaskRun] = None, parameters: Optional[dict[str, Any]] = None, wait_for: Optional['OneOrManyFutureOrResult[Any]'] = None, return_type: Literal['state', 'result'] = 'result', dependencies: Optional[dict[str, set[RunInput]]] = None, context: Optional[dict[str, Any]] = None) -> Generator[R, None, None]

`run_generator_task_async`

run_generator_task_async(task: 'Task[P, R]', task_run_id: Optional[UUID] = None, task_run: Optional[TaskRun] = None, parameters: Optional[dict[str, Any]] = None, wait_for: Optional['OneOrManyFutureOrResult[Any]'] = None, return_type: Literal['state', 'result'] = 'result', dependencies: Optional[dict[str, set[RunInput]]] = None, context: Optional[dict[str, Any]] = None) -> AsyncGenerator[R, None]

`run_task`

run_task(task: 'Task[P, Union[R, Coroutine[Any, Any, R]]]', task_run_id: Optional[UUID] = None, task_run: Optional[TaskRun] = None, parameters: Optional[dict[str, Any]] = None, wait_for: Optional['OneOrManyFutureOrResult[Any]'] = None, return_type: Literal['state', 'result'] = 'result', dependencies: Optional[dict[str, set[RunInput]]] = None, context: Optional[dict[str, Any]] = None) -> Union[R, State, None, Coroutine[Any, Any, Union[R, State, None]]]

Runs the provided task. Args:

task: The task to run
task_run_id: The ID of the task run; if not provided, a new task run will be created
task_run: The task run object; if not provided, a new task run will be created
parameters: The parameters to pass to the task
wait_for: A list of futures to wait for before running the task
return_type: The return type to return; either “state” or “result”
dependencies: A dictionary of task run inputs to use for dependency tracking
context: A dictionary containing the context to use for the task run; only required if the task is running on in a remote environment

Returns:

The result of the task run

Classes

`TaskRunTimeoutError`

Raised when a task run exceeds its timeout.

`BaseTaskRunEngine`

Methods:

`compute_transaction_key`

compute_transaction_key(self) -> Optional[str]

`handle_rollback`

handle_rollback(self, txn: Transaction) -> None

`is_cancelled`

is_cancelled(self) -> bool

`is_running`

is_running(self) -> bool

Whether or not the engine is currently running a task.

`log_finished_message`

log_finished_message(self) -> None

`record_terminal_state_timing`

record_terminal_state_timing(self, state: State) -> None

`state`

state(self) -> State

`SyncTaskRunEngine`

Methods:

`asset_context`

asset_context(self)

`begin_run`

begin_run(self) -> None

`call_hooks`

call_hooks(self, state: Optional[State] = None) -> None

`call_task_fn`

call_task_fn(self, transaction: Transaction) -> Union[ResultRecord[Any], None, Coroutine[Any, Any, R], R]

Convenience method to call the task function. Returns a coroutine if the task is async.

`can_retry`

can_retry(self, exc_or_state: Exception | State[R]) -> bool

`client`

client(self) -> SyncPrefectClient

`handle_crash`

handle_crash(self, exc: BaseException) -> None

`handle_exception`

handle_exception(self, exc: Exception) -> None

`handle_retry`

handle_retry(self, exc_or_state: Exception | State[R]) -> bool

Handle any task run retries.

If the task has retries left, and the retry condition is met, set the task to retrying and return True.
If the task has a retry delay, place in AwaitingRetry state with a delayed scheduled time.
If the task has no retries left, or the retry condition is not met, return False.

`handle_success`

handle_success(self, result: R, transaction: Transaction) -> Union[ResultRecord[R], None, Coroutine[Any, Any, R], R]

`handle_timeout`

handle_timeout(self, exc: TimeoutError) -> None

`initialize_run`

initialize_run(self, task_run_id: Optional[UUID] = None, dependencies: Optional[dict[str, set[RunInput]]] = None) -> Generator[Self, Any, Any]

Enters a client context and creates a task run if needed.

`result`

result(self, raise_on_failure: bool = True) -> 'Union[R, State, None]'

`run_context`

run_context(self)

`set_state`

set_state(self, state: State[R], force: bool = False) -> State[R]

`setup_run_context`

setup_run_context(self, client: Optional[SyncPrefectClient] = None)

`start`

start(self, task_run_id: Optional[UUID] = None, dependencies: Optional[dict[str, set[RunInput]]] = None) -> Generator[None, None, None]

`transaction_context`

transaction_context(self) -> Generator[Transaction, None, None]

`wait_until_ready`

wait_until_ready(self) -> None

Sync version: Waits until the scheduled time (if its the future), then enters Running.

`AsyncTaskRunEngine`

Methods:

`asset_context`

asset_context(self)

`begin_run`

begin_run(self) -> None

`call_hooks`

call_hooks(self, state: Optional[State] = None) -> None

`call_task_fn`

call_task_fn(self, transaction: AsyncTransaction) -> Union[ResultRecord[Any], None, Coroutine[Any, Any, R], R]

Convenience method to call the task function. Returns a coroutine if the task is async.

`can_retry`

can_retry(self, exc_or_state: Exception | State[R]) -> bool

`client`

client(self) -> PrefectClient

`handle_crash`

handle_crash(self, exc: BaseException) -> None

`handle_exception`

handle_exception(self, exc: Exception) -> None

`handle_retry`

handle_retry(self, exc_or_state: Exception | State[R]) -> bool

Handle any task run retries.

If the task has retries left, and the retry condition is met, set the task to retrying and return True.
If the task has a retry delay, place in AwaitingRetry state with a delayed scheduled time.
If the task has no retries left, or the retry condition is not met, return False.

`handle_success`

handle_success(self, result: R, transaction: AsyncTransaction) -> Union[ResultRecord[R], None, Coroutine[Any, Any, R], R]

`handle_timeout`

handle_timeout(self, exc: TimeoutError) -> None

`initialize_run`

initialize_run(self, task_run_id: Optional[UUID] = None, dependencies: Optional[dict[str, set[RunInput]]] = None) -> AsyncGenerator[Self, Any]

Enters a client context and creates a task run if needed.

`result`

result(self, raise_on_failure: bool = True) -> 'Union[R, State, None]'

`run_context`

run_context(self)

`set_state`

set_state(self, state: State, force: bool = False) -> State

`setup_run_context`

setup_run_context(self, client: Optional[PrefectClient] = None)

`start`

start(self, task_run_id: Optional[UUID] = None, dependencies: Optional[dict[str, set[RunInput]]] = None) -> AsyncGenerator[None, None]

`transaction_context`

transaction_context(self) -> AsyncGenerator[AsyncTransaction, None]

`wait_until_ready`

wait_until_ready(self) -> None

Waits until the scheduled time (if its the future), then enters Running.

​prefect.task_engine

​Functions

​run_task_sync

​run_task_async

​run_generator_task_sync

​run_generator_task_async

​run_task

​Classes

​TaskRunTimeoutError

​BaseTaskRunEngine

​compute_transaction_key

​handle_rollback

​is_cancelled

​is_running

​log_finished_message

​record_terminal_state_timing

​state

​SyncTaskRunEngine

​asset_context

​begin_run

​call_hooks

​call_task_fn

​can_retry

​client

​handle_crash

​handle_exception

​handle_retry

​handle_success

​handle_timeout

​initialize_run

​result

​run_context

​set_state

​setup_run_context

​start

​transaction_context

​wait_until_ready

​AsyncTaskRunEngine

​asset_context

​begin_run

​call_hooks

​call_task_fn

​can_retry

​client

​handle_crash

​handle_exception

​handle_retry

​handle_success

​handle_timeout

​initialize_run

​result

​run_context

​set_state

​setup_run_context

​start

​transaction_context

​wait_until_ready

`prefect.task_engine`

Functions

`run_task_sync`

`run_task_async`

`run_generator_task_sync`

`run_generator_task_async`

`run_task`

Classes

`TaskRunTimeoutError`

`BaseTaskRunEngine`

`compute_transaction_key`

`handle_rollback`

`is_cancelled`

`is_running`

`log_finished_message`

`record_terminal_state_timing`

`state`

`SyncTaskRunEngine`

`asset_context`

`begin_run`

`call_hooks`

`call_task_fn`

`can_retry`

`client`

`handle_crash`

`handle_exception`

`handle_retry`

`handle_success`

`handle_timeout`

`initialize_run`

`result`

`run_context`

`set_state`

`setup_run_context`

`start`

`transaction_context`

`wait_until_ready`

`AsyncTaskRunEngine`

`asset_context`

`begin_run`

`call_hooks`

`call_task_fn`

`can_retry`

`client`

`handle_crash`

`handle_exception`

`handle_retry`

`handle_success`

`handle_timeout`

`initialize_run`

`result`

`run_context`

`set_state`

`setup_run_context`

`start`

`transaction_context`

`wait_until_ready`