​
prefect.states

​
Functions

​
to_state_create 

to_state_create(state: State) -> 'StateCreate'
Convert the state to a StateCreate type which can be used to set the state of a run in the API. This method will drop this state’s data if it is not a result type. Only results should be sent to the API. Other data is only available locally.

​
get_state_result 

get_state_result(state: 'State[R]', raise_on_failure: bool = True, retry_result_failure: bool = True) -> 'R'
Get the result from a state. See State.result()

​
format_exception 

format_exception(exc: BaseException, tb: TracebackType = None) -> str

​
exception_to_crashed_state 

exception_to_crashed_state(exc: BaseException, result_store: Optional['ResultStore'] = None) -> State
Takes an exception that occurs outside of user code and converts it to a ‘Crash’ exception with a ‘Crashed’ state.

​
exception_to_failed_state 

exception_to_failed_state(exc: Optional[BaseException] = None, result_store: Optional['ResultStore'] = None, write_result: bool = False, **kwargs: Any) -> State[BaseException]
Convenience function for creating Failed states from exceptions

​
return_value_to_state 

return_value_to_state(retval: 'R', result_store: 'ResultStore', key: Optional[str] = None, expiration: Optional[datetime.datetime] = None, write_result: bool = False) -> 'State[R]'
Given a return value from a user’s function, create a State the run should be placed in.
  • If data is returned, we create a ‘COMPLETED’ state with the data
  • If a single, manually created state is returned, we use that state as given (manual creation is determined by the lack of ids)
  • If an upstream state or iterable of upstream states is returned, we apply the aggregate rule
The aggregate rule says that given multiple states we will determine the final state such that:
  • If any states are not COMPLETED the final state is FAILED
  • If all of the states are COMPLETED the final state is COMPLETED
  • The states will be placed in the final state data attribute
Callers should resolve all futures into states before passing return values to this function.

​
get_state_exception 

get_state_exception(state: State) -> BaseException
If not given a FAILED or CRASHED state, this raise a value error. If the state result is a state, its exception will be returned. If the state result is an iterable of states, the exception of the first failure will be returned. If the state result is a string, a wrapper exception will be returned with the string as the message. If the state result is null, a wrapper exception will be returned with the state message attached. If the state result is not of a known type, a TypeError will be returned. When a wrapper exception is returned, the type will be:
  • FailedRun if the state type is FAILED.
  • CrashedRun if the state type is CRASHED.
  • CancelledRun if the state type is CANCELLED.

​
raise_state_exception 

raise_state_exception(state: State) -> None
Given a FAILED or CRASHED state, raise the contained exception.

​
is_state_iterable 

is_state_iterable(obj: Any) -> TypeGuard[Iterable[State]]
Check if a the given object is an iterable of states types Supported iterables are:
  • set
  • list
  • tuple
Other iterables will return False even if they contain states.

​
Scheduled 

Scheduled(cls: Type['State[R]'] = State, scheduled_time: Optional[datetime.datetime] = None, **kwargs: Any) -> 'State[R]'
Convenience function for creating Scheduled states. Returns:
  • a Scheduled state

​
Completed 

Completed(cls: Type['State[R]'] = State, **kwargs: Any) -> 'State[R]'
Convenience function for creating Completed states. Returns:
  • a Completed state

​
Running 

Running(cls: Type['State[R]'] = State, **kwargs: Any) -> 'State[R]'
Convenience function for creating Running states. Returns:
  • a Running state

​
Failed 

Failed(cls: Type['State[R]'] = State, **kwargs: Any) -> 'State[R]'
Convenience function for creating Failed states. Returns:
  • a Failed state

​
Crashed 

Crashed(cls: Type['State[R]'] = State, **kwargs: Any) -> 'State[R]'
Convenience function for creating Crashed states. Returns:
  • a Crashed state

​
Cancelling 

Cancelling(cls: Type['State[R]'] = State, **kwargs: Any) -> 'State[R]'
Convenience function for creating Cancelling states. Returns:
  • a Cancelling state

​
Cancelled 

Cancelled(cls: Type['State[R]'] = State, **kwargs: Any) -> 'State[R]'
Convenience function for creating Cancelled states. Returns:
  • a Cancelled state

​
Pending 

Pending(cls: Type['State[R]'] = State, **kwargs: Any) -> 'State[R]'
Convenience function for creating Pending states. Returns:
  • a Pending state

​
Paused 

Paused(cls: Type['State[R]'] = State, timeout_seconds: Optional[int] = None, pause_expiration_time: Optional[datetime.datetime] = None, reschedule: bool = False, pause_key: Optional[str] = None, **kwargs: Any) -> 'State[R]'
Convenience function for creating Paused states. Returns:
  • a Paused state

​
Suspended 

Suspended(cls: Type['State[R]'] = State, timeout_seconds: Optional[int] = None, pause_expiration_time: Optional[datetime.datetime] = None, pause_key: Optional[str] = None, **kwargs: Any) -> 'State[R]'
Convenience function for creating Suspended states. Returns:
  • a Suspended state

​
AwaitingRetry 

AwaitingRetry(cls: Type['State[R]'] = State, scheduled_time: Optional[datetime.datetime] = None, **kwargs: Any) -> 'State[R]'
Convenience function for creating AwaitingRetry states. Returns:
  • an AwaitingRetry state

​
AwaitingConcurrencySlot 

AwaitingConcurrencySlot(cls: Type['State[R]'] = State, scheduled_time: Optional[datetime.datetime] = None, **kwargs: Any) -> 'State[R]'
Convenience function for creating AwaitingConcurrencySlot states. Returns:
  • an AwaitingConcurrencySlot state

​
Retrying 

Retrying(cls: Type['State[R]'] = State, **kwargs: Any) -> 'State[R]'
Convenience function for creating Retrying states. Returns:
  • a Retrying state

​
Late 

Late(cls: Type['State[R]'] = State, scheduled_time: Optional[datetime.datetime] = None, **kwargs: Any) -> 'State[R]'
Convenience function for creating Late states. Returns:
  • a Late state

​
Classes

​
StateGroup

Methods:

​
all_completed 

all_completed(self) -> bool

​
all_final 

all_final(self) -> bool

​
any_cancelled 

any_cancelled(self) -> bool

​
any_failed 

any_failed(self) -> bool

​
any_paused 

any_paused(self) -> bool

​
counts_message 

counts_message(self) -> str

​
fail_count 

fail_count(self) -> int