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_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_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 runtask_run_id: The ID of the task run; if not provided, a new task run
will be createdtask_run: The task run object; if not provided, a new task run
will be createdparameters: The parameters to pass to the taskwait_for: A list of futures to wait for before running the taskreturn_type: The return type to return; either “state” or “result”dependencies: A dictionary of task run inputs to use for dependency trackingcontext: 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:
state ↗
is_cancelled ↗
is_cancelled(self) -> bool
compute_transaction_key ↗
compute_transaction_key(self) -> Optional[str]
record_terminal_state_timing ↗
record_terminal_state_timing(self, state: State) -> None
is_running ↗
Whether or not the engine is currently running a task.
log_finished_message ↗
log_finished_message(self) -> None
handle_rollback ↗
handle_rollback(self, txn: Transaction) -> None
SyncTaskRunEngine ↗
Methods:
client ↗
client(self) -> SyncPrefectClient
can_retry ↗
can_retry(self, exc_or_state: Exception | State[R]) -> bool
call_hooks ↗
call_hooks(self, state: Optional[State] = None) -> None
begin_run ↗
set_state ↗
set_state(self, state: State[R], force: bool = False) -> State[R]
result ↗
result(self, raise_on_failure: bool = True) -> 'Union[R, State, None]'
handle_success ↗
handle_success(self, result: R, transaction: Transaction) -> Union[ResultRecord[R], None, Coroutine[Any, Any, R], R]
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_exception ↗
handle_exception(self, exc: Exception) -> None
handle_timeout ↗
handle_timeout(self, exc: TimeoutError) -> None
handle_crash ↗
handle_crash(self, exc: BaseException) -> None
setup_run_context ↗
setup_run_context(self, client: Optional[SyncPrefectClient] = None)
asset_context ↗
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.
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]
run_context ↗
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.
AsyncTaskRunEngine ↗
Methods:
client ↗
client(self) -> PrefectClient
