​
prefect.results

​
Functions

​
DEFAULT_STORAGE_KEY_FN 

DEFAULT_STORAGE_KEY_FN() -> str

​
aget_default_result_storage 

aget_default_result_storage() -> WritableFileSystem
Generate a default file system for result storage.

​
get_default_result_storage 

get_default_result_storage() -> WritableFileSystem
Generate a default file system for result storage.

​
aresolve_result_storage 

aresolve_result_storage(result_storage: ResultStorage | UUID | Path) -> WritableFileSystem
Resolve one of the valid ResultStorage input types into a saved block document id and an instance of the block.

​
resolve_result_storage 

resolve_result_storage(result_storage: ResultStorage | UUID | Path) -> WritableFileSystem
Resolve one of the valid ResultStorage input types into a saved block document id and an instance of the block.

​
resolve_serializer 

resolve_serializer(serializer: ResultSerializer) -> Serializer
Resolve one of the valid ResultSerializer input types into a serializer instance.

​
get_or_create_default_task_scheduling_storage 

get_or_create_default_task_scheduling_storage() -> ResultStorage
Generate a default file system for background task parameter/result storage.

​
get_default_result_serializer 

get_default_result_serializer() -> Serializer
Generate a default file system for result storage.

​
get_default_persist_setting 

get_default_persist_setting() -> bool
Return the default option for result persistence.

​
get_default_persist_setting_for_tasks 

get_default_persist_setting_for_tasks() -> bool
Return the default option for result persistence for tasks.

​
should_persist_result 

should_persist_result() -> bool
Return the default option for result persistence determined by the current run context. If there is no current run context, the value of results.persist_by_default on the current settings will be returned.

​
default_cache 

default_cache() -> LRUCache[str, 'ResultRecord[Any]']

​
result_storage_discriminator 

result_storage_discriminator(x: Any) -> str

​
get_result_store 

get_result_store() -> ResultStore
Get the current result store.

​
Classes

​
ResultStore

Manages the storage and retrieval of results. Methods:

​
aacquire_lock 

aacquire_lock(self, key: str, holder: str | None = None, timeout: float | None = None) -> bool
Acquire a lock for a result record. Args:
  • key: The key to acquire the lock for.
  • holder: The holder of the lock. If not provided, a default holder based on the current host, process, and thread will be used.
  • timeout: The timeout for the lock.
Returns:
  • True if the lock was successfully acquired; False otherwise.

​
acquire_lock 

acquire_lock(self, key: str, holder: str | None = None, timeout: float | None = None) -> bool
Acquire a lock for a result record. Args:
  • key: The key to acquire the lock for.
  • holder: The holder of the lock. If not provided, a default holder based on the current host, process, and thread will be used.
  • timeout: The timeout for the lock.
Returns:
  • True if the lock was successfully acquired; False otherwise.

​
aexists 

aexists(self, key: str) -> bool
Check if a result record exists in storage. Args:
  • key: The key to check for the existence of a result record.
Returns:
  • True if the result record exists, False otherwise.

​
apersist_result_record 

apersist_result_record(self, result_record: 'ResultRecord[Any]', holder: str | None = None) -> None
Persist a result record to storage. Args:
  • result_record: The result record to persist.

​
aread 

aread(self, key: str, holder: str | None = None) -> 'ResultRecord[Any]'
Read a result record from storage. Args:
  • key: The key to read the result record from.
  • holder: The holder of the lock if a lock was set on the record.
Returns:
  • A result record.

​
await_for_lock 

await_for_lock(self, key: str, timeout: float | None = None) -> bool
Wait for the corresponding transaction record to become free.

​
awrite 

awrite(self, obj: Any, key: str | None = None, expiration: DateTime | None = None, holder: str | None = None) -> None
Write a result to storage. Args:
  • key: The key to write the result record to.
  • obj: The object to write to storage.
  • expiration: The expiration time for the result record.
  • holder: The holder of the lock if a lock was set on the record.

​
create_result_record 

create_result_record(self, obj: Any, key: str | None = None, expiration: DateTime | None = None) -> 'ResultRecord[Any]'
Create a result record. Args:
  • key: The key to create the result record for.
  • obj: The object to create the result record for.
  • expiration: The expiration time for the result record.

​
exists 

exists(self, key: str) -> bool
Check if a result record exists in storage. Args:
  • key: The key to check for the existence of a result record.
Returns:
  • True if the result record exists, False otherwise.

​
generate_default_holder 

generate_default_holder() -> str
Generate a default holder string using hostname, PID, and thread ID. Returns:
  • A unique identifier string.

​
is_lock_holder 

is_lock_holder(self, key: str, holder: str | None = None) -> bool
Check if the current holder is the lock holder for the result record. Args:
  • key: The key to check the lock for.
  • holder: The holder of the lock. If not provided, a default holder based on the current host, process, and thread will be used.
Returns:
  • True if the current holder is the lock holder; False otherwise.

​
is_locked 

is_locked(self, key: str) -> bool
Check if a result record is locked.

​
persist_result_record 

persist_result_record(self, result_record: 'ResultRecord[Any]', holder: str | None = None) -> None
Persist a result record to storage. Args:
  • result_record: The result record to persist.

​
read 

read(self, key: str, holder: str | None = None) -> 'ResultRecord[Any]'
Read a result record from storage. Args:
  • key: The key to read the result record from.
  • holder: The holder of the lock if a lock was set on the record.
Returns:
  • A result record.

​
read_parameters 

read_parameters(self, identifier: UUID) -> dict[str, Any]

​
release_lock 

release_lock(self, key: str, holder: str | None = None) -> None
Release a lock for a result record. Args:
  • key: The key to release the lock for.
  • holder: The holder of the lock. Must match the holder that acquired the lock. If not provided, a default holder based on the current host, process, and thread will be used.

​
result_storage_block_id 

result_storage_block_id(self) -> UUID | None

​
store_parameters 

store_parameters(self, identifier: UUID, parameters: dict[str, Any])

​
supports_isolation_level 

supports_isolation_level(self, level: 'IsolationLevel') -> bool
Check if the result store supports a given isolation level. Args:
  • level: The isolation level to check.
Returns:
  • True if the isolation level is supported, False otherwise.

​
update_for_flow 

update_for_flow(self, flow: 'Flow[..., Any]') -> Self
Create a new result store for a flow with updated settings. Args:
  • flow: The flow to update the result store for.
Returns:
  • An updated result store.

​
update_for_task 

update_for_task(self: Self, task: 'Task[P, R]') -> Self
Create a new result store for a task. Args:
  • task: The task to update the result store for.
Returns:
  • An updated result store.

​
wait_for_lock 

wait_for_lock(self, key: str, timeout: float | None = None) -> bool
Wait for the corresponding transaction record to become free.

​
write 

write(self, obj: Any, key: str | None = None, expiration: DateTime | None = None, holder: str | None = None) -> None
Write a result to storage. Handles the creation of a ResultRecord and its serialization to storage. Args:
  • key: The key to write the result record to.
  • obj: The object to write to storage.
  • expiration: The expiration time for the result record.
  • holder: The holder of the lock if a lock was set on the record.