prefect-client 3.0.0rc11__py3-none-any.whl → 3.0.0rc12__py3-none-any.whl

prefect/_internal/concurrency/services.py

@@ -151,6 +151,7 @@ class QueueService(abc.ABC, Generic[T]):
 
             if item is None:
                 logger.debug("Exiting service %r", self)
+                self._queue.task_done()
                 break
 
             try:
@@ -164,6 +165,8 @@ class QueueService(abc.ABC, Generic[T]):
                     item,
                     exc_info=log_traceback,
                 )
+            finally:
+                self._queue.task_done()
 
     @abc.abstractmethod
     async def _handle(self, item: T):
@@ -235,6 +238,12 @@ class QueueService(abc.ABC, Generic[T]):
         else:
             return concurrent.futures.wait(futures, timeout=timeout)
 
+    def wait_until_empty(self):
+        """
+        Wait until the queue is empty and all items have been processed.
+        """
+        self._queue.join()
+
     @classmethod
     def instance(cls: Type[Self], *args) -> Self:
         """

prefect/artifacts.py

@@ -6,6 +6,7 @@ from __future__ import annotations
 
 import json  # noqa: I001
 import math
+import warnings
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union
 from uuid import UUID
 
@@ -54,8 +55,19 @@ class Artifact(ArtifactRequest):
         Returns:
             - The created artifact.
         """
+        from prefect.context import MissingContextError, get_run_context
+
         client, _ = get_or_create_client(client)
         task_run_id, flow_run_id = get_task_and_flow_run_ids()
+
+        try:
+            get_run_context()
+        except MissingContextError:
+            warnings.warn(
+                "Artifact creation outside of a flow or task run is deprecated and will be removed in a later version.",
+                FutureWarning,
+            )
+
         return await client.create_artifact(
             artifact=ArtifactRequest(
                 type=self.type,

prefect/client/schemas/actions.py

@@ -377,6 +377,10 @@ class DeploymentFlowRunCreate(ActionBaseModel):
     parameters: Dict[str, Any] = Field(
         default_factory=dict, description="The parameters for the flow run."
     )
+    enforce_parameter_schema: Optional[bool] = Field(
+        default=None,
+        description="Whether or not to enforce the parameter schema on this run.",
+    )
     context: Dict[str, Any] = Field(
         default_factory=dict, description="The context for the flow run."
     )

prefect/events/schemas/events.py

@@ -60,6 +60,16 @@ class Resource(Labelled):
     def name(self) -> Optional[str]:
         return self.get("prefect.resource.name")
 
+    def prefect_object_id(self, kind: str) -> UUID:
+        """Extracts the UUID from an event's resource ID if it's the expected kind
+        of prefect resource"""
+        prefix = f"{kind}." if not kind.endswith(".") else kind
+
+        if not self.id.startswith(prefix):
+            raise ValueError(f"Resource ID {self.id} does not start with {prefix}")
+
+        return UUID(self.id[len(prefix) :])
+
 
 class RelatedResource(Resource):
     """A Resource with a specific role in an Event"""

prefect/flow_engine.py

@@ -91,9 +91,12 @@ def load_flow_and_flow_run(flow_run_id: UUID) -> Tuple[FlowRun, Flow]:
 
     flow_run = client.read_flow_run(flow_run_id)
     if entrypoint:
-        flow = load_flow_from_entrypoint(entrypoint)
+        # we should not accept a placeholder flow at runtime
+        flow = load_flow_from_entrypoint(entrypoint, use_placeholder_flow=False)
     else:
-        flow = run_coro_as_sync(load_flow_from_flow_run(flow_run))
+        flow = run_coro_as_sync(
+            load_flow_from_flow_run(flow_run, use_placeholder_flow=False)
+        )
 
     return flow_run, flow
 

prefect/flows.py

@@ -798,7 +798,7 @@ class Flow(Generic[P, R]):
         cron: Optional[Union[Iterable[str], str]] = None,
         rrule: Optional[Union[Iterable[str], str]] = None,
         paused: Optional[bool] = None,
-        schedules: Optional[List["FlexibleScheduleList"]] = None,
+        schedules: Optional["FlexibleScheduleList"] = None,
         schedule: Optional[SCHEDULE_TYPES] = None,
         is_schedule_active: Optional[bool] = None,
         triggers: Optional[List[Union[DeploymentTriggerTypes, TriggerTypes]]] = None,
@@ -1704,6 +1704,7 @@ def select_flow(
 
 def load_flow_from_entrypoint(
     entrypoint: str,
+    use_placeholder_flow: bool = True,
 ) -> Flow:
     """
     Extract a flow object from a script at an entrypoint by running all of the code in the file.
@@ -1711,6 +1712,8 @@ def load_flow_from_entrypoint(
     Args:
         entrypoint: a string in the format `<path_to_script>:<flow_func_name>` or a module path
             to a flow function
+        use_placeholder_flow: if True, use a placeholder Flow object if the actual flow object
+            cannot be loaded from the entrypoint (e.g. dependencies are missing)
 
     Returns:
         The flow object from the script
@@ -1737,8 +1740,10 @@ def load_flow_from_entrypoint(
         # drawback of this approach is that we're unable to actually load the
         # function, so we create a placeholder flow that will re-raise this
         # exception when called.
-
-        flow = load_placeholder_flow(entrypoint=entrypoint, raises=exc)
+        if use_placeholder_flow:
+            flow = load_placeholder_flow(entrypoint=entrypoint, raises=exc)
+        else:
+            raise
 
     if not isinstance(flow, Flow):
         raise MissingFlowError(
@@ -1856,6 +1861,7 @@ async def load_flow_from_flow_run(
     flow_run: "FlowRun",
     ignore_storage: bool = False,
     storage_base_path: Optional[str] = None,
+    use_placeholder_flow: bool = True,
 ) -> Flow:
     """
     Load a flow from the location/script provided in a deployment's storage document.
@@ -1882,7 +1888,9 @@ async def load_flow_from_flow_run(
             f"Importing flow code from module path {deployment.entrypoint}"
         )
         flow = await run_sync_in_worker_thread(
-            load_flow_from_entrypoint, deployment.entrypoint
+            load_flow_from_entrypoint,
+            deployment.entrypoint,
+            use_placeholder_flow=use_placeholder_flow,
         )
         return flow
 
@@ -1924,7 +1932,11 @@ async def load_flow_from_flow_run(
     import_path = relative_path_to_current_platform(deployment.entrypoint)
     run_logger.debug(f"Importing flow code from '{import_path}'")
 
-    flow = await run_sync_in_worker_thread(load_flow_from_entrypoint, str(import_path))
+    flow = await run_sync_in_worker_thread(
+        load_flow_from_entrypoint,
+        str(import_path),
+        use_placeholder_flow=use_placeholder_flow,
+    )
 
     return flow
 

prefect/results.py

@@ -25,7 +25,7 @@ from typing_extensions import ParamSpec, Self
 import prefect
 from prefect.blocks.core import Block
 from prefect.client.utilities import inject_client
-from prefect.exceptions import MissingResult, ObjectAlreadyExists
+from prefect.exceptions import MissingResult
 from prefect.filesystems import (
     LocalFileSystem,
     WritableFileSystem,
@@ -64,51 +64,6 @@ R = TypeVar("R")
 _default_storages: Dict[Tuple[str, str], WritableFileSystem] = {}
 
 
-async def _get_or_create_default_storage(block_document_slug: str) -> ResultStorage:
-    """
-    Generate a default file system for storage.
-    """
-    default_storage_name, storage_path = cache_key = (
-        block_document_slug,
-        PREFECT_LOCAL_STORAGE_PATH.value(),
-    )
-
-    async def get_storage() -> WritableFileSystem:
-        try:
-            return await Block.load(default_storage_name)
-        except ValueError as e:
-            if "Unable to find" not in str(e):
-                raise e
-
-        block_type_slug, name = default_storage_name.split("/")
-        if block_type_slug == "local-file-system":
-            block = LocalFileSystem(basepath=storage_path)
-        else:
-            raise ValueError(
-                "The default storage block does not exist, but it is of type "
-                f"'{block_type_slug}' which cannot be created implicitly.  Please create "
-                "the block manually."
-            )
-
-        try:
-            await block.save(name, overwrite=False)
-        except ValueError as e:
-            if "already in use" not in str(e):
-                raise e
-        except ObjectAlreadyExists:
-            # Another client created the block before we reached this line
-            block = await Block.load(default_storage_name)
-
-        return block
-
-    try:
-        return _default_storages[cache_key]
-    except KeyError:
-        storage = await get_storage()
-        _default_storages[cache_key] = storage
-        return storage
-
-
 @sync_compatible
 async def get_default_result_storage() -> ResultStorage:
     """

prefect/runner/runner.py

@@ -167,9 +167,7 @@ class Runner:
         self.query_seconds = query_seconds or PREFECT_RUNNER_POLL_FREQUENCY.value()
         self._prefetch_seconds = prefetch_seconds
 
-        self._limiter: Optional[anyio.CapacityLimiter] = anyio.CapacityLimiter(
-            self.limit
-        )
+        self._limiter: Optional[anyio.CapacityLimiter] = None
         self._client = get_client()
         self._submitting_flow_run_ids = set()
         self._cancelling_flow_run_ids = set()
@@ -1227,6 +1225,8 @@ class Runner:
         self._client = get_client()
         self._tmp_dir.mkdir(parents=True)
 
+        self._limiter = anyio.CapacityLimiter(self.limit)
+
         if not hasattr(self, "_loop") or not self._loop:
             self._loop = asyncio.get_event_loop()
 

prefect/settings.py

@@ -481,18 +481,6 @@ PREFECT_HOME = Setting(
 directory may be created automatically when required.
 """
 
-PREFECT_EXTRA_ENTRYPOINTS = Setting(
-    str,
-    default="",
-)
-"""
-Modules for Prefect to import when Prefect is imported.
-
-Values should be separated by commas, e.g. `my_module,my_other_module`.
-Objects within modules may be specified by a ':' partition, e.g. `my_module:my_object`.
-If a callable object is provided, it will be called with no arguments on import.
-"""
-
 PREFECT_DEBUG_MODE = Setting(
     bool,
     default=False,
@@ -1438,11 +1426,6 @@ a task worker should move a task from PENDING to RUNNING very quickly, so runs s
 PENDING for a while is a sign that the task worker may have crashed.
 """
 
-PREFECT_EXPERIMENTAL_DISABLE_SYNC_COMPAT = Setting(bool, default=False)
-"""
-Whether or not to disable the sync_compatible decorator utility.
-"""
-
 PREFECT_EXPERIMENTAL_ENABLE_SCHEDULE_CONCURRENCY = Setting(bool, default=False)
 
 # Defaults -----------------------------------------------------------------------------

prefect/task_engine.py

@@ -5,6 +5,7 @@ import time
 from asyncio import CancelledError
 from contextlib import ExitStack, contextmanager
 from dataclasses import dataclass, field
+from functools import wraps
 from textwrap import dedent
 from typing import (
     Any,
@@ -53,6 +54,7 @@ from prefect.records.result_store import ResultFactoryStore
 from prefect.results import BaseResult, ResultFactory, _format_user_supplied_storage_key
 from prefect.settings import (
     PREFECT_DEBUG_MODE,
+    PREFECT_EXPERIMENTAL_ENABLE_CLIENT_SIDE_TASK_ORCHESTRATION,
     PREFECT_TASKS_REFRESH_CACHE,
 )
 from prefect.states import (
@@ -124,8 +126,7 @@ class TaskRunEngine(Generic[P, R]):
             raise ValueError("Task run is not set")
         return self.task_run.state
 
-    @property
-    def can_retry(self) -> bool:
+    def can_retry(self, exc: Exception) -> bool:
         retry_condition: Optional[
             Callable[[Task[P, Coroutine[Any, Any, R]], TaskRun, State], bool]
         ] = self.task.retry_condition_fn
@@ -136,9 +137,19 @@ class TaskRunEngine(Generic[P, R]):
                 f"Running `retry_condition_fn` check {retry_condition!r} for task"
                 f" {self.task.name!r}"
             )
-            return not retry_condition or retry_condition(
-                self.task, self.task_run, self.state
+            state = Failed(
+                data=exc,
+                message=f"Task run encountered unexpected exception: {repr(exc)}",
             )
+            if inspect.iscoroutinefunction(retry_condition):
+                should_retry = run_coro_as_sync(
+                    retry_condition(self.task, self.task_run, state)
+                )
+            elif inspect.isfunction(retry_condition):
+                should_retry = retry_condition(self.task, self.task_run, state)
+            else:
+                should_retry = not retry_condition
+            return should_retry
         except Exception:
             self.logger.error(
                 (
@@ -269,6 +280,17 @@ class TaskRunEngine(Generic[P, R]):
             return
 
         new_state = Running()
+
+        if PREFECT_EXPERIMENTAL_ENABLE_CLIENT_SIDE_TASK_ORCHESTRATION:
+            self.task_run.start_time = new_state.timestamp
+            self.task_run.run_count += 1
+
+            flow_run_context = FlowRunContext.get()
+            if flow_run_context:
+                # Carry forward any task run information from the flow run
+                flow_run = flow_run_context.flow_run
+                self.task_run.flow_run_run_count = flow_run.run_count
+
         state = self.set_state(new_state)
 
         # TODO: this is temporary until the API stops rejecting state transitions
@@ -298,24 +320,37 @@ class TaskRunEngine(Generic[P, R]):
         last_state = self.state
         if not self.task_run:
             raise ValueError("Task run is not set")
-        try:
-            new_state = propose_state_sync(
-                self.client, state, task_run_id=self.task_run.id, force=force
-            )
-        except Pause as exc:
-            # We shouldn't get a pause signal without a state, but if this happens,
-            # just use a Paused state to assume an in-process pause.
-            new_state = exc.state if exc.state else Paused()
-            if new_state.state_details.pause_reschedule:
-                # If we're being asked to pause and reschedule, we should exit the
-                # task and expect to be resumed later.
-                raise
 
-        # currently this is a hack to keep a reference to the state object
-        # that has an in-memory result attached to it; using the API state
+        if PREFECT_EXPERIMENTAL_ENABLE_CLIENT_SIDE_TASK_ORCHESTRATION:
+            self.task_run.state = new_state = state
+
+            # Ensure that the state_details are populated with the current run IDs
+            new_state.state_details.task_run_id = self.task_run.id
+            new_state.state_details.flow_run_id = self.task_run.flow_run_id
+
+            # Predictively update the de-normalized task_run.state_* attributes
+            self.task_run.state_id = new_state.id
+            self.task_run.state_type = new_state.type
+            self.task_run.state_name = new_state.name
+        else:
+            try:
+                new_state = propose_state_sync(
+                    self.client, state, task_run_id=self.task_run.id, force=force
+                )
+            except Pause as exc:
+                # We shouldn't get a pause signal without a state, but if this happens,
+                # just use a Paused state to assume an in-process pause.
+                new_state = exc.state if exc.state else Paused()
+                if new_state.state_details.pause_reschedule:
+                    # If we're being asked to pause and reschedule, we should exit the
+                    # task and expect to be resumed later.
+                    raise
+
+            # currently this is a hack to keep a reference to the state object
+            # that has an in-memory result attached to it; using the API state
+            # could result in losing that reference
+            self.task_run.state = new_state
 
-        # could result in losing that reference
-        self.task_run.state = new_state
         # emit a state change event
         self._last_event = emit_task_run_state_change_event(
             task_run=self.task_run,
@@ -323,6 +358,7 @@ class TaskRunEngine(Generic[P, R]):
             validated_state=self.task_run.state,
             follows=self._last_event,
         )
+
         return new_state
 
     def result(self, raise_on_failure: bool = True) -> "Union[R, State, None]":
@@ -367,11 +403,19 @@ class TaskRunEngine(Generic[P, R]):
         )
         transaction.stage(
             terminal_state.data,
-            on_rollback_hooks=self.task.on_rollback_hooks,
-            on_commit_hooks=self.task.on_commit_hooks,
+            on_rollback_hooks=[
+                _with_transaction_hook_logging(hook, "rollback", self.logger)
+                for hook in self.task.on_rollback_hooks
+            ],
+            on_commit_hooks=[
+                _with_transaction_hook_logging(hook, "commit", self.logger)
+                for hook in self.task.on_commit_hooks
+            ],
         )
         if transaction.is_committed():
             terminal_state.name = "Cached"
+
+        self.record_terminal_state_timing(terminal_state)
         self.set_state(terminal_state)
         self._return_value = result
         return result
@@ -383,7 +427,7 @@ class TaskRunEngine(Generic[P, R]):
           - 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.
         """
-        if self.retries < self.task.retries and self.can_retry:
+        if self.retries < self.task.retries and self.can_retry(exc):
             if self.task.retry_delay_seconds:
                 delay = (
                     self.task.retry_delay_seconds[
@@ -398,6 +442,8 @@ class TaskRunEngine(Generic[P, R]):
             else:
                 delay = None
                 new_state = Retrying()
+                if PREFECT_EXPERIMENTAL_ENABLE_CLIENT_SIDE_TASK_ORCHESTRATION:
+                    self.task_run.run_count += 1
 
             self.logger.info(
                 "Task run failed with exception: %r - " "Retry %s/%s will start %s",
@@ -432,6 +478,7 @@ class TaskRunEngine(Generic[P, R]):
                     result_factory=getattr(context, "result_factory", None),
                 )
             )
+            self.record_terminal_state_timing(state)
             self.set_state(state)
             self._raised = exc
 
@@ -454,9 +501,20 @@ class TaskRunEngine(Generic[P, R]):
         state = run_coro_as_sync(exception_to_crashed_state(exc))
         self.logger.error(f"Crash detected! {state.message}")
         self.logger.debug("Crash details:", exc_info=exc)
+        self.record_terminal_state_timing(state)
         self.set_state(state, force=True)
         self._raised = exc
 
+    def record_terminal_state_timing(self, state: State) -> None:
+        if PREFECT_EXPERIMENTAL_ENABLE_CLIENT_SIDE_TASK_ORCHESTRATION:
+            if self.task_run.start_time and not self.task_run.end_time:
+                self.task_run.end_time = state.timestamp
+
+                if self.task_run.state.is_running():
+                    self.task_run.total_run_time += (
+                        state.timestamp - self.task_run.state.timestamp
+                    )
+
     @contextmanager
     def setup_run_context(self, client: Optional[SyncPrefectClient] = None):
         from prefect.utilities.engine import (
@@ -469,7 +527,8 @@ class TaskRunEngine(Generic[P, R]):
         if not self.task_run:
             raise ValueError("Task run is not set")
 
-        self.task_run = client.read_task_run(self.task_run.id)
+        if not PREFECT_EXPERIMENTAL_ENABLE_CLIENT_SIDE_TASK_ORCHESTRATION:
+            self.task_run = client.read_task_run(self.task_run.id)
         with ExitStack() as stack:
             if log_prints := should_log_prints(self.task):
                 stack.enter_context(patch_print())
@@ -483,23 +542,24 @@ class TaskRunEngine(Generic[P, R]):
                     client=client,
                 )
             )
-            # set the logger to the task run logger
+
             self.logger = task_run_logger(task_run=self.task_run, task=self.task)  # type: ignore
 
-            # update the task run name if necessary
-            if not self._task_name_set and self.task.task_run_name:
-                task_run_name = _resolve_custom_task_run_name(
-                    task=self.task, parameters=self.parameters
-                )
-                self.client.set_task_run_name(
-                    task_run_id=self.task_run.id, name=task_run_name
-                )
-                self.logger.extra["task_run_name"] = task_run_name
-                self.logger.debug(
-                    f"Renamed task run {self.task_run.name!r} to {task_run_name!r}"
-                )
-                self.task_run.name = task_run_name
-                self._task_name_set = True
+            if not PREFECT_EXPERIMENTAL_ENABLE_CLIENT_SIDE_TASK_ORCHESTRATION:
+                # update the task run name if necessary
+                if not self._task_name_set and self.task.task_run_name:
+                    task_run_name = _resolve_custom_task_run_name(
+                        task=self.task, parameters=self.parameters
+                    )
+                    self.client.set_task_run_name(
+                        task_run_id=self.task_run.id, name=task_run_name
+                    )
+                    self.logger.extra["task_run_name"] = task_run_name
+                    self.logger.debug(
+                        f"Renamed task run {self.task_run.name!r} to {task_run_name!r}"
+                    )
+                    self.task_run.name = task_run_name
+                    self._task_name_set = True
             yield
 
     @contextmanager
@@ -511,22 +571,47 @@ class TaskRunEngine(Generic[P, R]):
         """
         Enters a client context and creates a task run if needed.
         """
+
         with hydrated_context(self.context):
             with ClientContext.get_or_create() as client_ctx:
                 self._client = client_ctx.sync_client
                 self._is_started = True
                 try:
                     if not self.task_run:
-                        self.task_run = run_coro_as_sync(
-                            self.task.create_run(
-                                id=task_run_id,
-                                parameters=self.parameters,
-                                flow_run_context=FlowRunContext.get(),
-                                parent_task_run_context=TaskRunContext.get(),
-                                wait_for=self.wait_for,
-                                extra_task_inputs=dependencies,
+                        if PREFECT_EXPERIMENTAL_ENABLE_CLIENT_SIDE_TASK_ORCHESTRATION:
+                            # TODO - this maybe should be a method on Task?
+                            from prefect.utilities.engine import (
+                                _resolve_custom_task_run_name,
+                            )
+
+                            task_run_name = None
+                            if not self._task_name_set and self.task.task_run_name:
+                                task_run_name = _resolve_custom_task_run_name(
+                                    task=self.task, parameters=self.parameters
+                                )
+
+                            self.task_run = run_coro_as_sync(
+                                self.task.create_local_run(
+                                    id=task_run_id,
+                                    parameters=self.parameters,
+                                    flow_run_context=FlowRunContext.get(),
+                                    parent_task_run_context=TaskRunContext.get(),
+                                    wait_for=self.wait_for,
+                                    extra_task_inputs=dependencies,
+                                    task_run_name=task_run_name,
+                                )
+                            )
+                        else:
+                            self.task_run = run_coro_as_sync(
+                                self.task.create_run(
+                                    id=task_run_id,
+                                    parameters=self.parameters,
+                                    flow_run_context=FlowRunContext.get(),
+                                    parent_task_run_context=TaskRunContext.get(),
+                                    wait_for=self.wait_for,
+                                    extra_task_inputs=dependencies,
+                                )
                             )
-                        )
                     # Emit an event to capture that the task run was in the `PENDING` state.
                     self._last_event = emit_task_run_state_change_event(
                         task_run=self.task_run,
@@ -916,3 +1001,28 @@ def run_task(
         return run_task_async(**kwargs)
     else:
         return run_task_sync(**kwargs)
+
+
+def _with_transaction_hook_logging(
+    hook: Callable[[Transaction], None],
+    hook_type: Literal["rollback", "commit"],
+    logger: logging.Logger,
+) -> Callable[[Transaction], None]:
+    @wraps(hook)
+    def _hook(txn: Transaction) -> None:
+        hook_name = _get_hook_name(hook)
+        logger.info(f"Running {hook_type} hook {hook_name!r}")
+
+        try:
+            hook(txn)
+        except Exception as exc:
+            logger.error(
+                f"An error was encountered while running {hook_type} hook {hook_name!r}",
+            )
+            raise exc
+        else:
+            logger.info(
+                f"{hook_type.capitalize()} hook {hook_name!r} finished running successfully"
+            )
+
+    return _hook

prefect/tasks.py

@@ -6,7 +6,6 @@ Module containing the base workflow task class and decorator - for most use case
 
 import datetime
 import inspect
-import os
 from copy import copy
 from functools import partial, update_wrapper
 from typing import (
@@ -33,13 +32,19 @@ from uuid import UUID, uuid4
 
 from typing_extensions import Literal, ParamSpec
 
+import prefect.states
 from prefect._internal.compatibility.deprecated import (
     deprecated_async_method,
 )
 from prefect.cache_policies import DEFAULT, NONE, CachePolicy
 from prefect.client.orchestration import get_client
 from prefect.client.schemas import TaskRun
-from prefect.client.schemas.objects import TaskRunInput, TaskRunResult
+from prefect.client.schemas.objects import (
+    StateDetails,
+    TaskRunInput,
+    TaskRunPolicy,
+    TaskRunResult,
+)
 from prefect.context import (
     FlowRunContext,
     TagsContext,
@@ -50,6 +55,7 @@ from prefect.futures import PrefectDistributedFuture, PrefectFuture, PrefectFutu
 from prefect.logging.loggers import get_logger
 from prefect.results import ResultFactory, ResultSerializer, ResultStorage
 from prefect.settings import (
+    PREFECT_EXPERIMENTAL_ENABLE_CLIENT_SIDE_TASK_ORCHESTRATION,
     PREFECT_TASK_DEFAULT_RETRIES,
     PREFECT_TASK_DEFAULT_RETRY_DELAY_SECONDS,
 )
@@ -181,6 +187,31 @@ def _infer_parent_task_runs(
     return parents
 
 
+def _generate_task_key(fn: Callable[..., Any]) -> str:
+    """Generate a task key based on the function name and source code.
+
+    We may eventually want some sort of top-level namespace here to
+    disambiguate tasks with the same function name in different modules,
+    in a more human-readable way, while avoiding relative import problems (see #12337).
+
+    As long as the task implementations are unique (even if named the same), we should
+    not have any collisions.
+
+    Args:
+        fn: The function to generate a task key for.
+    """
+    if not hasattr(fn, "__qualname__"):
+        return to_qualified_name(type(fn))
+
+    qualname = fn.__qualname__.split(".")[-1]
+
+    code_hash = (
+        h[:NUM_CHARS_DYNAMIC_KEY] if (h := hash_objects(fn.__code__)) else "unknown"
+    )
+
+    return f"{qualname}-{code_hash}"
+
+
 class Task(Generic[P, R]):
     """
     A Prefect task definition.
@@ -263,7 +294,7 @@ class Task(Generic[P, R]):
         description: Optional[str] = None,
         tags: Optional[Iterable[str]] = None,
         version: Optional[str] = None,
-        cache_policy: Optional[CachePolicy] = NotSet,
+        cache_policy: Union[CachePolicy, Type[NotSet]] = NotSet,
         cache_key_fn: Optional[
             Callable[["TaskRunContext", Dict[str, Any]], Optional[str]]
         ] = None,
@@ -362,17 +393,7 @@ class Task(Generic[P, R]):
 
         self.tags = set(tags if tags else [])
 
-        if not hasattr(self.fn, "__qualname__"):
-            self.task_key = to_qualified_name(type(self.fn))
-        else:
-            try:
-                task_origin_hash = hash_objects(
-                    self.name, os.path.abspath(inspect.getsourcefile(self.fn))
-                )
-            except TypeError:
-                task_origin_hash = "unknown-source-file"
-
-            self.task_key = f"{self.fn.__qualname__}-{task_origin_hash}"
+        self.task_key = _generate_task_key(self.fn)
 
         if cache_policy is not NotSet and cache_key_fn is not None:
             logger.warning(
@@ -786,6 +807,130 @@ class Task(Generic[P, R]):
 
             return task_run
 
+    async def create_local_run(
+        self,
+        client: Optional["PrefectClient"] = None,
+        id: Optional[UUID] = None,
+        parameters: Optional[Dict[str, Any]] = None,
+        flow_run_context: Optional[FlowRunContext] = None,
+        parent_task_run_context: Optional[TaskRunContext] = None,
+        wait_for: Optional[Iterable[PrefectFuture]] = None,
+        extra_task_inputs: Optional[Dict[str, Set[TaskRunInput]]] = None,
+        deferred: bool = False,
+        task_run_name: Optional[str] = None,
+    ) -> TaskRun:
+        if not PREFECT_EXPERIMENTAL_ENABLE_CLIENT_SIDE_TASK_ORCHESTRATION:
+            raise RuntimeError(
+                "Cannot call `Task.create_local_run` unless "
+                "PREFECT_EXPERIMENTAL_ENABLE_CLIENT_SIDE_TASK_ORCHESTRATION is True"
+            )
+
+        from prefect.utilities.engine import (
+            _dynamic_key_for_task_run,
+            collect_task_run_inputs_sync,
+        )
+
+        if flow_run_context is None:
+            flow_run_context = FlowRunContext.get()
+        if parent_task_run_context is None:
+            parent_task_run_context = TaskRunContext.get()
+        if parameters is None:
+            parameters = {}
+        if client is None:
+            client = get_client()
+
+        async with client:
+            if not flow_run_context:
+                dynamic_key = f"{self.task_key}-{str(uuid4().hex)}"
+                task_run_name = task_run_name or self.name
+            else:
+                dynamic_key = _dynamic_key_for_task_run(
+                    context=flow_run_context, task=self
+                )
+                task_run_name = task_run_name or f"{self.name}-{dynamic_key}"
+
+            if deferred:
+                state = Scheduled()
+                state.state_details.deferred = True
+            else:
+                state = Pending()
+
+            # store parameters for background tasks so that task worker
+            # can retrieve them at runtime
+            if deferred and (parameters or wait_for):
+                parameters_id = uuid4()
+                state.state_details.task_parameters_id = parameters_id
+
+                # TODO: Improve use of result storage for parameter storage / reference
+                self.persist_result = True
+
+                factory = await ResultFactory.from_autonomous_task(self, client=client)
+                context = serialize_context()
+                data: Dict[str, Any] = {"context": context}
+                if parameters:
+                    data["parameters"] = parameters
+                if wait_for:
+                    data["wait_for"] = wait_for
+                await factory.store_parameters(parameters_id, data)
+
+            # collect task inputs
+            task_inputs = {
+                k: collect_task_run_inputs_sync(v) for k, v in parameters.items()
+            }
+
+            # collect all parent dependencies
+            if task_parents := _infer_parent_task_runs(
+                flow_run_context=flow_run_context,
+                task_run_context=parent_task_run_context,
+                parameters=parameters,
+            ):
+                task_inputs["__parents__"] = task_parents
+
+            # check wait for dependencies
+            if wait_for:
+                task_inputs["wait_for"] = collect_task_run_inputs_sync(wait_for)
+
+            # Join extra task inputs
+            for k, extras in (extra_task_inputs or {}).items():
+                task_inputs[k] = task_inputs[k].union(extras)
+
+            flow_run_id = (
+                getattr(flow_run_context.flow_run, "id", None)
+                if flow_run_context and flow_run_context.flow_run
+                else None
+            )
+            task_run_id = id or uuid4()
+            state = prefect.states.Pending(
+                state_details=StateDetails(
+                    task_run_id=task_run_id,
+                    flow_run_id=flow_run_id,
+                )
+            )
+            task_run = TaskRun(
+                id=task_run_id,
+                name=task_run_name,
+                flow_run_id=flow_run_id,
+                task_key=self.task_key,
+                dynamic_key=str(dynamic_key),
+                task_version=self.version,
+                empirical_policy=TaskRunPolicy(
+                    retries=self.retries,
+                    retry_delay=self.retry_delay_seconds,
+                    retry_jitter_factor=self.retry_jitter_factor,
+                ),
+                tags=list(set(self.tags).union(TagsContext.get().current_tags or [])),
+                task_inputs=task_inputs or {},
+                expected_start_time=state.timestamp,
+                state_id=state.id,
+                state_type=state.type,
+                state_name=state.name,
+                state=state,
+                created=state.timestamp,
+                updated=state.timestamp,
+            )
+
+            return task_run
+
     @overload
     def __call__(
         self: "Task[P, NoReturn]",
@@ -1365,7 +1510,7 @@ class Task(Generic[P, R]):
 
         Args:
             task_runner: The task runner to use for serving the task. If not provided,
-                the default ConcurrentTaskRunner will be used.
+                the default task runner will be used.
 
         Examples:
             Serve a task using the default task runner
@@ -1392,7 +1537,7 @@ def task(
     description: Optional[str] = None,
     tags: Optional[Iterable[str]] = None,
     version: Optional[str] = None,
-    cache_policy: CachePolicy = NotSet,
+    cache_policy: Union[CachePolicy, Type[NotSet]] = NotSet,
     cache_key_fn: Optional[
         Callable[["TaskRunContext", Dict[str, Any]], Optional[str]]
     ] = None,
@@ -1430,7 +1575,9 @@ def task(
     tags: Optional[Iterable[str]] = None,
     version: Optional[str] = None,
     cache_policy: Union[CachePolicy, Type[NotSet]] = NotSet,
-    cache_key_fn: Callable[["TaskRunContext", Dict[str, Any]], Optional[str]] = None,
+    cache_key_fn: Union[
+        Callable[["TaskRunContext", Dict[str, Any]], Optional[str]], None
+    ] = None,
     cache_expiration: Optional[datetime.timedelta] = None,
     task_run_name: Optional[Union[Callable[[], str], str]] = None,
     retries: Optional[int] = None,

prefect/transactions.py

@@ -26,7 +26,6 @@ from prefect.results import (
 )
 from prefect.utilities.asyncutils import run_coro_as_sync
 from prefect.utilities.collections import AutoEnum
-from prefect.utilities.engine import _get_hook_name
 
 
 class IsolationLevel(AutoEnum):
@@ -180,39 +179,20 @@ class Transaction(ContextModel):
             return False
 
         try:
-            hook_name = None
-
             for child in self.children:
                 child.commit()
 
             for hook in self.on_commit_hooks:
-                hook_name = _get_hook_name(hook)
-                if self.logger:
-                    self.logger.info(f"Running commit hook {hook_name!r}")
-
                 hook(self)
 
-                if self.logger:
-                    self.logger.info(
-                        f"Commit hook {hook_name!r} finished running successfully"
-                    )
-
             if self.store and self.key:
                 self.store.write(key=self.key, value=self._staged_value)
             self.state = TransactionState.COMMITTED
             return True
         except Exception:
             if self.logger:
-                if hook_name:
-                    msg = (
-                        f"An error was encountered while running commit hook {hook_name!r}",
-                    )
-                else:
-                    msg = (
-                        f"An error was encountered while committing transaction {self.key!r}",
-                    )
                 self.logger.exception(
-                    msg,
+                    f"An error was encountered while committing transaction {self.key!r}",
                     exc_info=True,
                 )
             self.rollback()
@@ -242,17 +222,8 @@ class Transaction(ContextModel):
 
         try:
             for hook in reversed(self.on_rollback_hooks):
-                hook_name = _get_hook_name(hook)
-                if self.logger:
-                    self.logger.info(f"Running rollback hook {hook_name!r}")
-
                 hook(self)
 
-                if self.logger:
-                    self.logger.info(
-                        f"Rollback hook {hook_name!r} finished running successfully"
-                    )
-
             self.state = TransactionState.ROLLED_BACK
 
             for child in reversed(self.children):
@@ -262,7 +233,7 @@ class Transaction(ContextModel):
         except Exception:
             if self.logger:
                 self.logger.exception(
-                    f"An error was encountered while running rollback hook {hook_name!r}",
+                    f"An error was encountered while rolling back transaction {self.key!r}",
                     exc_info=True,
                 )
             return False

prefect/utilities/asyncutils.py

@@ -267,11 +267,17 @@ async def run_sync_in_worker_thread(
     Note that cancellation of threads will not result in interrupted computation, the
     thread may continue running — the outcome will just be ignored.
     """
-    call = partial(__fn, *args, **kwargs)
-    result = await anyio.to_thread.run_sync(
-        call_with_mark, call, abandon_on_cancel=True, limiter=get_thread_limiter()
-    )
-    return result
+    # When running a sync function in a worker thread, we set this flag so that
+    # any root sync compatible functions will run as sync functions
+    token = RUNNING_ASYNC_FLAG.set(False)
+    try:
+        call = partial(__fn, *args, **kwargs)
+        result = await anyio.to_thread.run_sync(
+            call_with_mark, call, abandon_on_cancel=True, limiter=get_thread_limiter()
+        )
+        return result
+    finally:
+        RUNNING_ASYNC_FLAG.reset(token)
 
 
 def call_with_mark(call):
@@ -348,11 +354,8 @@ def sync_compatible(
         *args: Any, _sync: Optional[bool] = None, **kwargs: Any
     ) -> Union[R, Coroutine[Any, Any, R]]:
         from prefect.context import MissingContextError, get_run_context
-        from prefect.settings import (
-            PREFECT_EXPERIMENTAL_DISABLE_SYNC_COMPAT,
-        )
 
-        if PREFECT_EXPERIMENTAL_DISABLE_SYNC_COMPAT or _sync is False:
+        if _sync is False:
             return async_fn(*args, **kwargs)
 
         is_async = True

{prefect_client-3.0.0rc11.dist-info → prefect_client-3.0.0rc12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prefect-client
-Version: 3.0.0rc11
+Version: 3.0.0rc12
 Summary: Workflow orchestration and management.
 Home-page: https://www.prefect.io
 Author: Prefect Technologies, Inc.
@@ -29,7 +29,7 @@ Requires-Dist: asgi-lifespan <3.0,>=1.0
 Requires-Dist: cachetools <6.0,>=5.3
 Requires-Dist: cloudpickle <4.0,>=2.0
 Requires-Dist: coolname <3.0.0,>=1.0.4
-Requires-Dist: croniter <3.0.0,>=1.0.12
+Requires-Dist: croniter <4.0.0,>=1.0.12
 Requires-Dist: exceptiongroup >=1.0.0
 Requires-Dist: fastapi <1.0.0,>=0.111.0
 Requires-Dist: fsspec >=2022.5.0

{prefect_client-3.0.0rc11.dist-info → prefect_client-3.0.0rc12.dist-info}/RECORD

@@ -2,32 +2,32 @@ prefect/.prefectignore,sha256=awSprvKT0vI8a64mEOLrMxhxqcO-b0ERQeYpA2rNKVQ,390
 prefect/__init__.py,sha256=rFlBikby0TcAmljqECcleQE_se15eh1gLp5iac0ZhsU,3301
 prefect/_version.py,sha256=I9JsXwt7BjAAbMEZgtmE3a6dJ2jqV-wqWto9D6msb3k,24597
 prefect/agent.py,sha256=BOVVY5z-vUIQ2u8LwMTXDaNys2fjOZSS5YGDwJmTQjI,230
-prefect/artifacts.py,sha256=G-jCyce3XGtTyQpCk_s3L7e-TWFyJY8Dcnk_i4_CsY4,12647
+prefect/artifacts.py,sha256=wet3coxBtqK0914uTf-slYpXRVP0mjbZn804hXB-RS4,13011
 prefect/automations.py,sha256=NlQ62GPJzy-gnWQqX7c6CQJKw7p60WLGDAFcy82vtg4,5613
 prefect/cache_policies.py,sha256=uEKNGO-PJ3N35B2tjhRDtQULN6ok72D9raIoJaUyXk0,6365
 prefect/context.py,sha256=40FLSXI3Qd9dMwP8nQ7fGZFKpQIuEkjTpekT4V1MvF8,19942
 prefect/engine.py,sha256=BpmDbe6miZcTl1vRkxfCPYcWSXADLigGPCagFwucMz0,1976
 prefect/exceptions.py,sha256=3s69Z_IC3HKF6BKxcHrMPXkKdYwfbEfaTjy4-5LOtQ0,11132
 prefect/filesystems.py,sha256=rbFvlqHXeeo71nK1Y5I0-ucmGOYUcdkbb6N2vpsRcWE,17229
-prefect/flow_engine.py,sha256=pty-TJxjlJgk5diKXR3aIdjQNQkFZH-QN5HGxSvc-iQ,29189
+prefect/flow_engine.py,sha256=oNsRxLIZjjf-PyYl5m2cxWk1iRONI-U_KBZESfS4EAw,29328
 prefect/flow_runs.py,sha256=EaXRIQTOnwnA0fO7_EjwafFRmS57K_CRy0Xsz3JDIhc,16070
-prefect/flows.py,sha256=nHzrZG9-lQ8S_9lOKKFuX1l_BBJJ5IuLEqzuloqE4NY,84263
+prefect/flows.py,sha256=jskTdjUxH7Le1n3ME3TbkytRXrWs_B1LVRUy2-xOixk,84721
 prefect/futures.py,sha256=w5M_iZwt5aI0AUfia0JC1FkitRmQ6Oxtc_L7g_INTOM,13695
 prefect/main.py,sha256=bab5nBn37a6gmxdPbTlRS2a9Cf0KY0GaCotDOSbcQ7M,1930
 prefect/manifests.py,sha256=477XcmfdC_yE81wT6zIAKnEUEJ0lH9ZLfOVSgX2FohE,676
 prefect/plugins.py,sha256=7AICJzHIu8iAeF9vl9wAYm28pR_k7dkdnm3OyJRfCv4,2229
 prefect/profiles.toml,sha256=Fs8hD_BdWHZgAijgk8pK_Zx-Pm-YFixqDIfEP6fM-qU,38
 prefect/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-prefect/results.py,sha256=gpX2pGIYyVfxMaVJkic5i1KbJ4RBARAoIizDL_C3auI,26152
+prefect/results.py,sha256=3mVkVWZn_VSQ9Pik79StNy113rB_SEiP83SdoUsFvTM,24635
 prefect/serializers.py,sha256=Lo41EM0_qGzcfB_63390Izeo3DdK6cY6VZfxa9hpSGQ,8712
-prefect/settings.py,sha256=5H6yQqtql9GWHp1wFCaDnejfdrzd2v-9CPOHD7TA8yU,69607
+prefect/settings.py,sha256=Xmgy4S_zQWKiT7VEXiRtSjhjihrqK5feNkH3QVdDTMQ,69090
 prefect/states.py,sha256=lw22xucH46cN9stkxiV9ByIvq689mH5iL3gErri-Y18,22207
-prefect/task_engine.py,sha256=94Acrmq04i-KjJtSa72_ofGAEfs_lKBAYqhRww0jH24,34957
+prefect/task_engine.py,sha256=GXWIDMNUl0--RecH9yc41mSSpCNnIFmapi8fMIFDsdQ,39911
 prefect/task_runners.py,sha256=W1n0yMwbDIqnvffFVJADo9MGEbLaYkzWk52rqgnkMY4,15019
 prefect/task_runs.py,sha256=eDWYH5H1K4SyduhKmn3GzO6vM3fZSwOZxAb8KhkMGsk,7798
 prefect/task_worker.py,sha256=lV9rQb9YOaO28DZLW_avw6p0pTSVYtsA1gqODWxB7J0,17334
-prefect/tasks.py,sha256=VkliQAiiLiYSpBQvY1Xc4huqmGgMlgX0KChlBPOX9IY,62599
-prefect/transactions.py,sha256=Yn9XgUFJKD_QZ0OzvmW-kp7x6hcGcE5FuJ0V8lSTCEM,11032
+prefect/tasks.py,sha256=A-sQB8S5dxcLtl10crDThsfdKpMzm9Rknfwhu27rnvY,68085
+prefect/transactions.py,sha256=XBbOjAUnDWw9QcxVwEamRaWxvRA_Ao-MkIN5dFL7h54,10008
 prefect/variables.py,sha256=-t5LVY0N-K4f0fa6YwruVVQqwnU3fGWBMYXXE32XPkA,4821
 prefect/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prefect/_internal/_logging.py,sha256=HvNHY-8P469o5u4LYEDBTem69XZEt1QUeUaLToijpak,810
@@ -45,7 +45,7 @@ prefect/_internal/concurrency/cancellation.py,sha256=D1B_I2cBSGPNXcLaXNaLN_9_QAg
 prefect/_internal/concurrency/event_loop.py,sha256=1VBW862QZ6DV9dExWOT398A0fti4A7jW2kcY7Y5V-lI,2073
 prefect/_internal/concurrency/inspection.py,sha256=xfyUNr5CoES8LFhybi2DmzHeW4RpTAbrGPiZOYMVLbQ,3464
 prefect/_internal/concurrency/primitives.py,sha256=BQ0vObO7NUEq-IMbu5aTlfoZpWMbYwinzYP89GIyw68,2609
-prefect/_internal/concurrency/services.py,sha256=aggJd4IUSB6ufppRYdRT-36daEg1JSpJCvK635R8meg,11951
+prefect/_internal/concurrency/services.py,sha256=6RYcGFrHh_xO5BXeRDgNOmWsjQnQrX9jyW7SN9zuOF0,12209
 prefect/_internal/concurrency/threads.py,sha256=90Wi00pTebfihiFgP-P71DeGTnhlJKctzP69mtjphKU,8860
 prefect/_internal/concurrency/waiters.py,sha256=X6xxsKcHB9ULnCkeUf0cLTI267kI_GC4k96XRuhPhnw,8790
 prefect/_internal/pydantic/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
@@ -77,7 +77,7 @@ prefect/client/orchestration.py,sha256=W3tiqjND1lf0GtunLBayMRrUD5ykAcW0GfwxqT9fT
 prefect/client/subscriptions.py,sha256=J9uK9NGHO4VX4Y3NGgBJ4pIG_0cf-dJWPhF3f3PGYL4,3388
 prefect/client/utilities.py,sha256=Qh1WdKLs8F_GuA04FeZ1GJsPYtiCN4DjKmLEaMfKmpQ,3264
 prefect/client/schemas/__init__.py,sha256=KlyqFV-hMulMkNstBn_0ijoHoIwJZaBj6B1r07UmgvE,607
-prefect/client/schemas/actions.py,sha256=wiyq87MrHBVbZZVqA6IX4Gy_rw7sogLfqRSXK3Id0cc,28019
+prefect/client/schemas/actions.py,sha256=sZFVfN-Xks7x-sfp0kX97lSzHDbMx99E-rzIngOUU6A,28184
 prefect/client/schemas/filters.py,sha256=HyIYZQowhkHa_D6syj83zUp5uFEzA8UADLaS9mt1MTo,35305
 prefect/client/schemas/objects.py,sha256=3-qhF8qTUSB-wax4s5_zBs6A1K2hdDr1WLxpTryQbRE,53547
 prefect/client/schemas/responses.py,sha256=xW9QKmVgBftSEmtuSr5gp9HBFvIDzF6aSFq-mhv7dE8,14948
@@ -114,7 +114,7 @@ prefect/events/cli/automations.py,sha256=WIZ3-EcDibjQB5BrMEx7OZ7UfOqP8VjCI1dNh64
 prefect/events/schemas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prefect/events/schemas/automations.py,sha256=he9_v0Oq8AtCJe5gMti5GDQiaGa50sM4Jz9soDf-upU,14396
 prefect/events/schemas/deployment_triggers.py,sha256=i_BtKscXU9kOHAeqmxrYQr8itEYfuPIxAnCW3fo1YeE,3114
-prefect/events/schemas/events.py,sha256=RqosMukGfHvLPnYDcyxkm6VuifCeH5-aQ4POdMPmaUA,8649
+prefect/events/schemas/events.py,sha256=erAIoMtfFjPWeTPpja6Rg3WqUNZhlX7YM3b4CzzuomQ,9053
 prefect/events/schemas/labelling.py,sha256=bU-XYaHXhI2MEBIHngth96R9D02m8HHb85KNcHZ_1Gc,3073
 prefect/infrastructure/__init__.py,sha256=BOVVY5z-vUIQ2u8LwMTXDaNys2fjOZSS5YGDwJmTQjI,230
 prefect/infrastructure/base.py,sha256=BOVVY5z-vUIQ2u8LwMTXDaNys2fjOZSS5YGDwJmTQjI,230
@@ -138,7 +138,7 @@ prefect/records/__init__.py,sha256=7q-lwyevfVgb5S7K9frzawmiJmpZ5ET0m5yXIHBYcVA,3
 prefect/records/result_store.py,sha256=6Yh9zqqXMWjn0qWSfcjQBSfXCM7jVg9pve5TVsOodDc,1734
 prefect/records/store.py,sha256=eQM1p2vZDshXZYg6SkJwL-DP3kUehL_Zgs8xa2-0DZs,224
 prefect/runner/__init__.py,sha256=7U-vAOXFkzMfRz1q8Uv6Otsvc0OrPYLLP44srwkJ_8s,89
-prefect/runner/runner.py,sha256=33lp10HDKhB8r009eQZJ1hAbcH8_V0zVpbCL1_4-0MQ,47990
+prefect/runner/runner.py,sha256=zoW90-rYm6NLSVqmdXdQe7_aIBu6HuICe0gkz8FsKJc,47998
 prefect/runner/server.py,sha256=2o5vhrL7Zbn-HBStWhCjqqViex5Ye9GiQ1EW9RSEzdo,10500
 prefect/runner/storage.py,sha256=FFHk28iF_OLw-cnXQtJIgGXUV4xecxF70mobiszP8C4,24557
 prefect/runner/submit.py,sha256=RuyDr-ved9wjYYarXiehY5oJVFf_HE3XKKACNWpxpPc,8131
@@ -153,7 +153,7 @@ prefect/types/__init__.py,sha256=SAHJDtWEGidTKXQACJ38nj6fq8r57Gj0Pwo4Gy7pVWs,223
 prefect/types/entrypoint.py,sha256=2FF03-wLPgtnqR_bKJDB2BsXXINPdu8ptY9ZYEZnXg8,328
 prefect/utilities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prefect/utilities/annotations.py,sha256=bXB43j5Zsq5gaBcJe9qnszBlnNwCTwqSTgcu2OkkRLo,2776
-prefect/utilities/asyncutils.py,sha256=_ZN4lag5zofbXYysL8IbS3FBNjFF9bzjoVQfmgM7WLs,19998
+prefect/utilities/asyncutils.py,sha256=8bOtYljRoOn-LKaMhaQWx80MM2KwUQQC0jzOuO--ZX4,20123
 prefect/utilities/callables.py,sha256=rkPPzwiVFRoVszSUq612s9S0v3nxcMC-rIwfXoJTn0E,24915
 prefect/utilities/collections.py,sha256=pPa_SZZq80cja6l99b3TV7hRQy366WnuWpOW_FnutMI,17259
 prefect/utilities/compat.py,sha256=mNQZDnzyKaOqy-OV-DnmH_dc7CNF5nQgW_EsA4xMr7g,906
@@ -186,8 +186,8 @@ prefect/workers/cloud.py,sha256=BOVVY5z-vUIQ2u8LwMTXDaNys2fjOZSS5YGDwJmTQjI,230
 prefect/workers/process.py,sha256=t1f1EYRoPL5B25KbLgUX2b5q-lCCAXb2Gpf6T2M9WfY,19822
 prefect/workers/server.py,sha256=lgh2FfSuaNU7b6HPxSFm8JtKvAvHsZGkiOo4y4tW1Cw,2022
 prefect/workers/utilities.py,sha256=VfPfAlGtTuDj0-Kb8WlMgAuOfgXCdrGAnKMapPSBrwc,2483
-prefect_client-3.0.0rc11.dist-info/LICENSE,sha256=MCxsn8osAkzfxKC4CC_dLcUkU8DZLkyihZ8mGs3Ah3Q,11357
-prefect_client-3.0.0rc11.dist-info/METADATA,sha256=21Ipv_Qq3mfIziTr_jbFzJPBsMKfM1Tlspvek1Cpcg0,7432
-prefect_client-3.0.0rc11.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-prefect_client-3.0.0rc11.dist-info/top_level.txt,sha256=MJZYJgFdbRc2woQCeB4vM6T33tr01TmkEhRcns6H_H4,8
-prefect_client-3.0.0rc11.dist-info/RECORD,,
+prefect_client-3.0.0rc12.dist-info/LICENSE,sha256=MCxsn8osAkzfxKC4CC_dLcUkU8DZLkyihZ8mGs3Ah3Q,11357
+prefect_client-3.0.0rc12.dist-info/METADATA,sha256=mpzyZ76ECL9XsRq4Squ61UkfenYkdhJzZM7FekCZjHg,7432
+prefect_client-3.0.0rc12.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+prefect_client-3.0.0rc12.dist-info/top_level.txt,sha256=MJZYJgFdbRc2woQCeB4vM6T33tr01TmkEhRcns6H_H4,8
+prefect_client-3.0.0rc12.dist-info/RECORD,,