prefect-client 2.19.8__py3-none-any.whl → 2.20.0__py3-none-any.whl

prefect/blocks/notifications.py

@@ -139,12 +139,40 @@ class MicrosoftTeamsWebhook(AppriseNotificationBlock):
     url: SecretStr = Field(
         ...,
         title="Webhook URL",
-        description="The Teams incoming webhook URL used to send notifications.",
+        description="The Microsoft Power Automate (Workflows) URL used to send notifications to Teams.",
         examples=[
-            "https://your-org.webhook.office.com/webhookb2/XXX/IncomingWebhook/YYY/ZZZ"
+            "https://prod-NO.LOCATION.logic.azure.com:443/workflows/WFID/triggers/manual/paths/invoke?sp=%2Ftriggers%2Fmanual%2Frun&sv=1.0&sig=SIGNATURE"
         ],
     )
 
+    include_image: bool = Field(
+        default=True,
+        description="Include an image with the notification.",
+    )
+
+    wrap: bool = Field(
+        default=True,
+        description="Wrap the notification text.",
+    )
+
+    def block_initialization(self) -> None:
+        """see https://github.com/caronc/apprise/pull/1172"""
+        from apprise.plugins.workflows import NotifyWorkflows
+
+        if not (
+            parsed_url := NotifyWorkflows.parse_native_url(self.url.get_secret_value())
+        ):
+            raise ValueError("Invalid Microsoft Teams Workflow URL provided.")
+
+        parsed_url.update(
+            {
+                "include_image": self.include_image,
+                "wrap": self.wrap,
+            }
+        )
+
+        self._start_apprise_client(SecretStr(NotifyWorkflows(**parsed_url).url()))
+
 
 class PagerDutyWebHook(AbstractAppriseNotificationBlock):
     """

prefect/client/schemas/objects.py

@@ -17,6 +17,7 @@ import pendulum
 
 from prefect._internal.compatibility.deprecated import (
     DeprecatedInfraOverridesField,
+    deprecated_class,
 )
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
 from prefect.types import NonNegativeInteger, PositiveInteger
@@ -917,6 +918,10 @@ class Flow(ObjectBaseModel):
         return raise_on_name_with_banned_characters(v)
 
 
+@deprecated_class(
+    start_date="Jun 2024",
+    help="Will be removed in Prefect 3 in favor of prefect.client.schemas.actions.DeploymentScheduleCreate",
+)
 class MinimalDeploymentSchedule(PrefectBaseModel):
     schedule: SCHEDULE_TYPES = Field(
         default=..., description="The schedule for the deployment."

prefect/deployments/deployments.py

@@ -238,12 +238,17 @@ async def run_deployment(
     return flow_run
 
 
+@deprecated_callable(
+    start_date="Jun 2024",
+    help="Will be moved in Prefect 3 to prefect.flows:load_flow_from_flow_run",
+)
 @inject_client
 async def load_flow_from_flow_run(
     flow_run: FlowRun,
     client: PrefectClient,
     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.
@@ -270,7 +275,7 @@ 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
         )
         return flow
 
@@ -314,7 +319,9 @@ async def load_flow_from_flow_run(
             ).absolute()
     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
+    )
 
     return flow
 

prefect/engine.py

@@ -107,13 +107,16 @@ from uuid import UUID, uuid4
 
 import anyio
 import pendulum
-from anyio import start_blocking_portal
+from anyio.from_thread import start_blocking_portal
 from typing_extensions import Literal
 
 import prefect
 import prefect.context
 import prefect.plugins
-from prefect._internal.compatibility.deprecated import deprecated_parameter
+from prefect._internal.compatibility.deprecated import (
+    deprecated_callable,
+    deprecated_parameter,
+)
 from prefect._internal.compatibility.experimental import experimental_parameter
 from prefect._internal.concurrency.api import create_call, from_async, from_sync
 from prefect._internal.concurrency.calls import get_current_call
@@ -208,6 +211,7 @@ from prefect.utilities.engine import (
     _resolve_custom_task_run_name,
     capture_sigterm,
     check_api_reachable,
+    collapse_excgroups,
     collect_task_run_inputs,
     emit_task_run_state_change_event,
     propose_state,
@@ -276,7 +280,7 @@ def enter_flow_run_engine_from_flow_call(
     # the user. Generally, you should enter contexts _within_ the async `begin_run`
     # instead but if you need to enter a context from the main thread you'll need to do
     # it here.
-    contexts = [capture_sigterm()]
+    contexts = [capture_sigterm(), collapse_excgroups()]
 
     if flow.isasync and (
         not is_subflow_run or (is_subflow_run and parent_flow_run_context.flow.isasync)
@@ -321,7 +325,7 @@ def enter_flow_run_engine_from_subprocess(flow_run_id: UUID) -> State:
             flow_run_id,
             user_thread=threading.current_thread(),
         ),
-        contexts=[capture_sigterm()],
+        contexts=[capture_sigterm(), collapse_excgroups()],
     )
 
     APILogHandler.flush()
@@ -417,9 +421,12 @@ async def retrieve_flow_then_begin_flow_run(
 
     try:
         flow = (
-            load_flow_from_entrypoint(entrypoint)
+            # We do not want to use a placeholder flow at runtime
+            load_flow_from_entrypoint(entrypoint, use_placeholder_flow=False)
             if entrypoint
-            else await load_flow_from_flow_run(flow_run, client=client)
+            else await load_flow_from_flow_run(
+                flow_run, client=client, use_placeholder_flow=False
+            )
         )
     except Exception:
         message = (
@@ -975,6 +982,10 @@ async def orchestrate_flow_run(
     return state
 
 
+@deprecated_callable(
+    start_date="Jun 2024",
+    help="Will be moved in Prefect 3 to prefect.flow_runs:pause_flow_run",
+)
 @overload
 async def pause_flow_run(
     wait_for_input: None = None,
@@ -987,6 +998,10 @@ async def pause_flow_run(
     ...
 
 
+@deprecated_callable(
+    start_date="Jun 2024",
+    help="Will be moved in Prefect 3 to prefect.flow_runs:pause_flow_run",
+)
 @overload
 async def pause_flow_run(
     wait_for_input: Type[T],
@@ -1095,6 +1110,10 @@ async def pause_flow_run(
         )
 
 
+@deprecated_callable(
+    start_date="Jun 2024",
+    help="Will be moved in Prefect 3 to prefect.flow_runs:_in_process_pause",
+)
 @inject_client
 async def _in_process_pause(
     timeout: int = 3600,
@@ -1190,6 +1209,10 @@ async def _in_process_pause(
     raise FlowPauseTimeout("Flow run was paused and never resumed.")
 
 
+@deprecated_callable(
+    start_date="Jun 2024",
+    help="Will be moved in Prefect 3 to prefect.flow_runs.pause_flow_run.",
+)
 @inject_client
 async def _out_of_process_pause(
     flow_run_id: UUID,
@@ -1212,6 +1235,10 @@ async def _out_of_process_pause(
         raise RuntimeError(response.details.reason)
 
 
+@deprecated_callable(
+    start_date="Jun 2024",
+    help="Will be moved in Prefect 3 to prefect.flow_runs:suspend_flow_run",
+)
 @overload
 async def suspend_flow_run(
     wait_for_input: None = None,
@@ -1343,6 +1370,10 @@ async def suspend_flow_run(
         raise Pause()
 
 
+@deprecated_callable(
+    start_date="Jun 2024",
+    help="Will be moved in Prefect 3 to prefect.flow_runs:resume_flow_run",
+)
 @sync_compatible
 async def resume_flow_run(flow_run_id, run_input: Optional[Dict] = None):
     """
@@ -2218,9 +2249,9 @@ async def report_flow_run_crashes(flow_run: FlowRun, client: PrefectClient, flow
 
     This context _must_ reraise the exception to properly exit the run.
     """
-
     try:
-        yield
+        with collapse_excgroups():
+            yield
     except (Abort, Pause):
         # Do not capture internal signals as crashes
         raise
@@ -2257,7 +2288,8 @@ async def report_task_run_crashes(task_run: TaskRun, client: PrefectClient):
     This context _must_ reraise the exception to properly exit the run.
     """
     try:
-        yield
+        with collapse_excgroups():
+            yield
     except (Abort, Pause):
         # Do not capture internal signals as crashes
         raise

prefect/flows.py

@@ -1650,6 +1650,7 @@ def load_flow_from_script(path: str, flow_name: str = None) -> 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.
@@ -1657,6 +1658,9 @@ 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, a placeholder flow will be used if the entrypoint
+            cannot be loaded for any reason (e.g. dependencies are missing). If False, an
+            exception will be raised.
 
     Returns:
         The flow object from the script
@@ -1672,6 +1676,7 @@ def load_flow_from_entrypoint(
         if ":" in entrypoint:
             # split by the last colon once to handle Windows paths with drive letters i.e C:\path\to\file.py:do_stuff
             path, func_name = entrypoint.rsplit(":", maxsplit=1)
+
         else:
             path, func_name = entrypoint.rsplit(".", maxsplit=1)
         try:
@@ -1680,14 +1685,15 @@ def load_flow_from_entrypoint(
             raise MissingFlowError(
                 f"Flow function with name {func_name!r} not found in {path!r}. "
             ) from exc
-        except ScriptError as exc:
+        except ScriptError:
             # If the flow has dependencies that are not installed in the current
-            # environment, fallback to loading the flow via AST parsing. The
-            # 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)
+            # environment, fallback to loading the flow via AST parsing.
+            if use_placeholder_flow:
+                flow = safe_load_flow_from_entrypoint(entrypoint)
+                if flow is None:
+                    raise
+            else:
+                raise
 
         if not isinstance(flow, Flow):
             raise MissingFlowError(
@@ -1848,6 +1854,147 @@ def load_placeholder_flow(entrypoint: str, raises: Exception):
     return Flow(**arguments)
 
 
+def safe_load_flow_from_entrypoint(entrypoint: str) -> Optional[Flow]:
+    """
+    Load a flow from an entrypoint and return None if an exception is raised.
+
+    Args:
+        entrypoint: a string in the format `<path_to_script>:<flow_func_name>`
+          or a module path to a flow function
+    """
+    func_def, source_code = _entrypoint_definition_and_source(entrypoint)
+    path = None
+    if ":" in entrypoint:
+        path = entrypoint.rsplit(":")[0]
+    namespace = safe_load_namespace(source_code, filepath=path)
+    if func_def.name in namespace:
+        return namespace[func_def.name]
+    else:
+        # If the function is not in the namespace, if may be due to missing dependencies
+        # for the function. We will attempt to compile each annotation and default value
+        # and remove them from the function definition to see if the function can be
+        # compiled without them.
+
+        return _sanitize_and_load_flow(func_def, namespace)
+
+
+def _sanitize_and_load_flow(
+    func_def: Union[ast.FunctionDef, ast.AsyncFunctionDef], namespace: Dict[str, Any]
+) -> Optional[Flow]:
+    """
+    Attempt to load a flow from the function definition after sanitizing the annotations
+    and defaults that can't be compiled.
+
+    Args:
+        func_def: the function definition
+        namespace: the namespace to load the function into
+
+    Returns:
+        The loaded function or None if the function can't be loaded
+        after sanitizing the annotations and defaults.
+    """
+    args = func_def.args.posonlyargs + func_def.args.args + func_def.args.kwonlyargs
+    if func_def.args.vararg:
+        args.append(func_def.args.vararg)
+    if func_def.args.kwarg:
+        args.append(func_def.args.kwarg)
+    # Remove annotations that can't be compiled
+    for arg in args:
+        if arg.annotation is not None:
+            try:
+                code = compile(
+                    ast.Expression(arg.annotation),
+                    filename="<ast>",
+                    mode="eval",
+                )
+                exec(code, namespace)
+            except Exception as e:
+                logger.debug(
+                    "Failed to evaluate annotation for argument %s due to the following error. Ignoring annotation.",
+                    arg.arg,
+                    exc_info=e,
+                )
+                arg.annotation = None
+
+    # Remove defaults that can't be compiled
+    new_defaults = []
+    for default in func_def.args.defaults:
+        try:
+            code = compile(ast.Expression(default), "<ast>", "eval")
+            exec(code, namespace)
+            new_defaults.append(default)
+        except Exception as e:
+            logger.debug(
+                "Failed to evaluate default value %s due to the following error. Ignoring default.",
+                default,
+                exc_info=e,
+            )
+            new_defaults.append(
+                ast.Constant(
+                    value=None, lineno=default.lineno, col_offset=default.col_offset
+                )
+            )
+    func_def.args.defaults = new_defaults
+
+    # Remove kw_defaults that can't be compiled
+    new_kw_defaults = []
+    for default in func_def.args.kw_defaults:
+        if default is not None:
+            try:
+                code = compile(ast.Expression(default), "<ast>", "eval")
+                exec(code, namespace)
+                new_kw_defaults.append(default)
+            except Exception as e:
+                logger.debug(
+                    "Failed to evaluate default value %s due to the following error. Ignoring default.",
+                    default,
+                    exc_info=e,
+                )
+                new_kw_defaults.append(
+                    ast.Constant(
+                        value=None,
+                        lineno=default.lineno,
+                        col_offset=default.col_offset,
+                    )
+                )
+        else:
+            new_kw_defaults.append(
+                ast.Constant(
+                    value=None,
+                    lineno=func_def.lineno,
+                    col_offset=func_def.col_offset,
+                )
+            )
+    func_def.args.kw_defaults = new_kw_defaults
+
+    if func_def.returns is not None:
+        try:
+            code = compile(
+                ast.Expression(func_def.returns), filename="<ast>", mode="eval"
+            )
+            exec(code, namespace)
+        except Exception as e:
+            logger.debug(
+                "Failed to evaluate return annotation due to the following error. Ignoring annotation.",
+                exc_info=e,
+            )
+            func_def.returns = None
+
+    # Attempt to compile the function without annotations and defaults that
+    # can't be compiled
+    try:
+        code = compile(
+            ast.Module(body=[func_def], type_ignores=[]),
+            filename="<ast>",
+            mode="exec",
+        )
+        exec(code, namespace)
+    except Exception as e:
+        logger.debug("Failed to compile: %s", e)
+    else:
+        return namespace.get(func_def.name)
+
+
 def load_flow_arguments_from_entrypoint(
     entrypoint: str, arguments: Optional[Union[List[str], Set[str]]] = None
 ) -> Dict[str, Any]:
@@ -1863,6 +2010,9 @@ def load_flow_arguments_from_entrypoint(
     """
 
     func_def, source_code = _entrypoint_definition_and_source(entrypoint)
+    path = None
+    if ":" in entrypoint:
+        path = entrypoint.rsplit(":")[0]
 
     if arguments is None:
         # If no arguments are provided default to known arguments that are of
@@ -1898,7 +2048,7 @@ def load_flow_arguments_from_entrypoint(
 
                 # if the arg value is not a raw str (i.e. a variable or expression),
                 # then attempt to evaluate it
-                namespace = safe_load_namespace(source_code)
+                namespace = safe_load_namespace(source_code, filepath=path)
                 literal_arg_value = ast.get_source_segment(source_code, keyword.value)
                 cleaned_value = (
                     literal_arg_value.replace("\n", "") if literal_arg_value else ""

prefect/task_server.py

@@ -9,6 +9,7 @@ from functools import partial
 from typing import List, Optional, Type
 
 import anyio
+from exceptiongroup import BaseExceptionGroup  # novermin
 from websockets.exceptions import InvalidStatusCode
 
 from prefect import Task, get_client
@@ -225,16 +226,21 @@ class TaskServer:
             validated_state=state,
         )
 
-        self._runs_task_group.start_soon(
-            partial(
-                submit_autonomous_task_run_to_engine,
-                task=task,
-                task_run=task_run,
-                parameters=parameters,
-                task_runner=self.task_runner,
-                client=self._client,
+        try:
+            self._runs_task_group.start_soon(
+                partial(
+                    submit_autonomous_task_run_to_engine,
+                    task=task,
+                    task_run=task_run,
+                    parameters=parameters,
+                    task_runner=self.task_runner,
+                    client=self._client,
+                )
+            )
+        except BaseException as exc:
+            logger.exception(
+                f"Failed to submit task run {task_run.id!r} to engine", exc_info=exc
             )
-        )
 
     async def execute_task_run(self, task_run: TaskRun):
         """Execute a task run in the task server."""
@@ -301,6 +307,14 @@ async def serve(*tasks: Task, task_runner: Optional[Type[BaseTaskRunner]] = None
     try:
         await task_server.start()
 
+    except BaseExceptionGroup as exc:  # novermin
+        exceptions = exc.exceptions
+        n_exceptions = len(exceptions)
+        logger.error(
+            f"Task worker stopped with {n_exceptions} exception{'s' if n_exceptions != 1 else ''}:"
+            f"\n" + "\n".join(str(e) for e in exceptions)
+        )
+
     except StopTaskServer:
         logger.info("Task server stopped.")
 

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 (
@@ -76,6 +75,8 @@ P = ParamSpec("P")  # The parameters of the task
 
 logger = get_logger("tasks")
 
+NUM_CHARS_DYNAMIC_KEY: int = 8
+
 
 def task_input_hash(
     context: "TaskRunContext", arguments: Dict[str, Any]
@@ -125,6 +126,28 @@ def exponential_backoff(backoff_factor: float) -> Callable[[int], List[float]]:
     return retry_backoff_callable
 
 
+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}"
+
+
 @PrefectObjectRegistry.register_instances
 class Task(Generic[P, R]):
     """
@@ -292,17 +315,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)
 
         self.cache_key_fn = cache_key_fn
         self.cache_expiration = cache_expiration

prefect/utilities/asyncutils.py

@@ -29,7 +29,9 @@ from uuid import UUID, uuid4
 
 import anyio
 import anyio.abc
+import anyio.to_thread
 import sniffio
+from anyio.from_thread import start_blocking_portal
 from typing_extensions import Literal, ParamSpec, TypeGuard
 
 from prefect.logging import get_logger
@@ -134,7 +136,7 @@ async def run_sync_in_worker_thread(
     """
     call = partial(__fn, *args, **kwargs)
     return await anyio.to_thread.run_sync(
-        call, cancellable=True, limiter=get_thread_limiter()
+        call, abandon_on_cancel=True, limiter=get_thread_limiter()
     )
 
 
@@ -202,7 +204,7 @@ async def run_sync_in_interruptible_worker_thread(
             partial(
                 anyio.to_thread.run_sync,
                 capture_worker_thread_and_result,
-                cancellable=True,
+                abandon_on_cancel=True,
                 limiter=get_thread_limiter(),
             )
         )
@@ -228,7 +230,7 @@ def run_async_in_new_loop(__fn: Callable[..., Awaitable[T]], *args: Any, **kwarg
 
 def in_async_worker_thread() -> bool:
     try:
-        anyio.from_thread.threadlocals.current_async_module
+        anyio.from_thread.threadlocals.current_async_backend
     except AttributeError:
         return False
     else:
@@ -261,14 +263,14 @@ def sync_compatible(async_fn: T) -> T:
     """
 
     @wraps(async_fn)
-    def coroutine_wrapper(*args, **kwargs):
+    def coroutine_wrapper(*args, _sync: Optional[bool] = None, **kwargs):
         from prefect._internal.concurrency.api import create_call, from_sync
         from prefect._internal.concurrency.calls import get_current_call, logger
         from prefect._internal.concurrency.event_loop import get_running_loop
         from prefect._internal.concurrency.threads import get_global_loop
         from prefect.settings import PREFECT_EXPERIMENTAL_DISABLE_SYNC_COMPAT
 
-        if PREFECT_EXPERIMENTAL_DISABLE_SYNC_COMPAT:
+        if PREFECT_EXPERIMENTAL_DISABLE_SYNC_COMPAT or _sync is False:
             return async_fn(*args, **kwargs)
 
         global_thread_portal = get_global_loop()
@@ -276,12 +278,17 @@ def sync_compatible(async_fn: T) -> T:
         current_call = get_current_call()
         current_loop = get_running_loop()
 
-        if current_thread.ident == global_thread_portal.thread.ident:
+        if (
+            current_thread.ident == global_thread_portal.thread.ident
+            and _sync is not True
+        ):
             logger.debug(f"{async_fn} --> return coroutine for internal await")
             # In the prefect async context; return the coro for us to await
             return async_fn(*args, **kwargs)
-        elif in_async_main_thread() and (
-            not current_call or is_async_fn(current_call.fn)
+        elif (
+            in_async_main_thread()
+            and (not current_call or is_async_fn(current_call.fn))
+            and _sync is not True
         ):
             # In the main async context; return the coro for them to await
             logger.debug(f"{async_fn} --> return coroutine for user await")
@@ -333,7 +340,7 @@ def sync(__async_fn: Callable[P, Awaitable[T]], *args: P.args, **kwargs: P.kwarg
             "`sync` called from an asynchronous context; "
             "you should `await` the async function directly instead."
         )
-        with anyio.start_blocking_portal() as portal:
+        with start_blocking_portal() as portal:
             return portal.call(partial(__async_fn, *args, **kwargs))
     elif in_async_worker_thread():
         # In a sync context but we can access the event loop thread; send the async

prefect/utilities/callables.py

@@ -346,17 +346,19 @@ def parameter_schema_from_entrypoint(entrypoint: str) -> ParameterSchema:
     Returns:
         ParameterSchema: The parameter schema for the function.
     """
+    filepath = None
     if ":" in entrypoint:
         # split by the last colon once to handle Windows paths with drive letters i.e C:\path\to\file.py:do_stuff
         path, func_name = entrypoint.rsplit(":", maxsplit=1)
         source_code = Path(path).read_text()
+        filepath = path
     else:
         path, func_name = entrypoint.rsplit(".", maxsplit=1)
         spec = importlib.util.find_spec(path)
         if not spec or not spec.origin:
             raise ValueError(f"Could not find module {path!r}")
         source_code = Path(spec.origin).read_text()
-    signature = _generate_signature_from_source(source_code, func_name)
+    signature = _generate_signature_from_source(source_code, func_name, filepath)
     docstring = _get_docstring_from_source(source_code, func_name)
     return generate_parameter_schema(signature, parameter_docstrings(docstring))
 
@@ -424,7 +426,7 @@ def raise_for_reserved_arguments(fn: Callable, reserved_arguments: Iterable[str]
 
 
 def _generate_signature_from_source(
-    source_code: str, func_name: str
+    source_code: str, func_name: str, filepath: Optional[str] = None
 ) -> inspect.Signature:
     """
     Extract the signature of a function from its source code.
@@ -440,7 +442,7 @@ def _generate_signature_from_source(
     """
     # Load the namespace from the source code. Missing imports and exceptions while
     # loading local class definitions are ignored.
-    namespace = safe_load_namespace(source_code)
+    namespace = safe_load_namespace(source_code, filepath=filepath)
     # Parse the source code into an AST
     parsed_code = ast.parse(source_code)
 

prefect/utilities/engine.py

@@ -4,11 +4,13 @@ import inspect
 import os
 import signal
 import time
+from contextlib import contextmanager
 from functools import partial
 from typing import (
     Any,
     Callable,
     Dict,
+    Generator,
     Iterable,
     Optional,
     Set,
@@ -18,6 +20,7 @@ from typing import (
 from uuid import UUID, uuid4
 
 import anyio
+from exceptiongroup import BaseExceptionGroup  # novermin
 from typing_extensions import Literal
 
 import prefect
@@ -734,3 +737,14 @@ def emit_task_run_state_change_event(
         },
         follows=follows,
     )
+
+
+@contextmanager
+def collapse_excgroups() -> Generator[None, None, None]:
+    try:
+        yield
+    except BaseException as exc:
+        while isinstance(exc, BaseExceptionGroup) and len(exc.exceptions) == 1:
+            exc = exc.exceptions[0]
+
+        raise exc

prefect/utilities/importtools.py

@@ -362,79 +362,159 @@ class AliasedModuleLoader(Loader):
         sys.modules[self.alias] = root_module
 
 
-def safe_load_namespace(source_code: str):
+def safe_load_namespace(
+    source_code: str, filepath: Optional[str] = None
+) -> Dict[str, Any]:
     """
-    Safely load a namespace from source code.
+    Safely load a namespace from source code, optionally handling relative imports.
 
-    This function will attempt to import all modules and classes defined in the source
-    code. If an import fails, the error is caught and the import is skipped. This function
-    will also attempt to compile and evaluate class and function definitions locally.
+    If a `filepath` is provided, `sys.path` is modified to support relative imports.
+    Changes to `sys.path` are reverted after completion, but this function is not thread safe
+    and use of it in threaded contexts may result in undesirable behavior.
 
     Args:
         source_code: The source code to load
+        filepath: Optional file path of the source code. If provided, enables relative imports.
 
     Returns:
-        The namespace loaded from the source code. Can be used when evaluating source
-        code.
+        The namespace loaded from the source code.
     """
     parsed_code = ast.parse(source_code)
 
-    namespace = {"__name__": "prefect_safe_namespace_loader"}
+    namespace: Dict[str, Any] = {"__name__": "prefect_safe_namespace_loader"}
 
-    # Remove the body of the if __name__ == "__main__": block from the AST to prevent
-    # execution of guarded code
-    new_body = []
-    for node in parsed_code.body:
-        if _is_main_block(node):
-            continue
-        new_body.append(node)
+    # Remove the body of the if __name__ == "__main__": block
+    new_body = [node for node in parsed_code.body if not _is_main_block(node)]
     parsed_code.body = new_body
 
-    # Walk through the AST and find all import statements
-    for node in ast.walk(parsed_code):
-        if isinstance(node, ast.Import):
-            for alias in node.names:
-                module_name = alias.name
-                as_name = alias.asname if alias.asname else module_name
-                try:
-                    # Attempt to import the module
-                    namespace[as_name] = importlib.import_module(module_name)
-                    logger.debug("Successfully imported %s", module_name)
-                except ImportError as e:
-                    logger.debug(f"Failed to import {module_name}: {e}")
-        elif isinstance(node, ast.ImportFrom):
-            module_name = node.module
-            if module_name is None:
-                continue
-            try:
-                module = importlib.import_module(module_name)
+    temp_module = None
+    original_sys_path = None
+
+    if filepath:
+        # Setup for relative imports
+        file_dir = os.path.dirname(os.path.abspath(filepath))
+        package_name = os.path.basename(file_dir)
+        parent_dir = os.path.dirname(file_dir)
+
+        # Save original sys.path and modify it
+        original_sys_path = sys.path.copy()
+        sys.path.insert(0, parent_dir)
+
+        # Create a temporary module for import context
+        temp_module = ModuleType(package_name)
+        temp_module.__file__ = filepath
+        temp_module.__package__ = package_name
+
+        # Create a spec for the module
+        temp_module.__spec__ = ModuleSpec(package_name, None)
+        temp_module.__spec__.loader = None
+        temp_module.__spec__.submodule_search_locations = [file_dir]
+
+    try:
+        for node in parsed_code.body:
+            if isinstance(node, ast.Import):
                 for alias in node.names:
-                    name = alias.name
-                    asname = alias.asname if alias.asname else name
+                    module_name = alias.name
+                    as_name = alias.asname or module_name
                     try:
-                        # Get the specific attribute from the module
-                        attribute = getattr(module, name)
-                        namespace[asname] = attribute
-                    except AttributeError as e:
-                        logger.debug(
-                            "Failed to retrieve %s from %s: %s", name, module_name, e
-                        )
-            except ImportError as e:
-                logger.debug("Failed to import from %s: %s", node.module, e)
-
-    # Handle local definitions
-    for node in parsed_code.body:
-        if isinstance(node, (ast.ClassDef, ast.FunctionDef, ast.Assign)):
-            try:
-                # Compile and execute each class and function definition and assignment
-                code = compile(
-                    ast.Module(body=[node], type_ignores=[]),
-                    filename="<ast>",
-                    mode="exec",
-                )
-                exec(code, namespace)
-            except Exception as e:
-                logger.debug("Failed to compile: %s", e)
+                        namespace[as_name] = importlib.import_module(module_name)
+                        logger.debug("Successfully imported %s", module_name)
+                    except ImportError as e:
+                        logger.debug(f"Failed to import {module_name}: {e}")
+            elif isinstance(node, ast.ImportFrom):
+                module_name = node.module or ""
+                if filepath:
+                    try:
+                        if node.level > 0:
+                            # For relative imports, use the parent package to inform the import
+                            package_parts = temp_module.__package__.split(".")
+                            if len(package_parts) < node.level:
+                                raise ImportError(
+                                    "Attempted relative import beyond top-level package"
+                                )
+                            parent_package = ".".join(
+                                package_parts[: (1 - node.level)]
+                                if node.level > 1
+                                else package_parts
+                            )
+                            module = importlib.import_module(
+                                f".{module_name}" if module_name else "",
+                                package=parent_package,
+                            )
+                        else:
+                            # Absolute imports are handled as normal
+                            module = importlib.import_module(module_name)
+
+                        for alias in node.names:
+                            name = alias.name
+                            asname = alias.asname or name
+                            if name == "*":
+                                # Handle 'from module import *'
+                                module_dict = {
+                                    k: v
+                                    for k, v in module.__dict__.items()
+                                    if not k.startswith("_")
+                                }
+                                namespace.update(module_dict)
+                            else:
+                                try:
+                                    attribute = getattr(module, name)
+                                    namespace[asname] = attribute
+                                except AttributeError as e:
+                                    logger.debug(
+                                        "Failed to retrieve %s from %s: %s",
+                                        name,
+                                        module_name,
+                                        e,
+                                    )
+                    except ImportError as e:
+                        logger.debug("Failed to import from %s: %s", module_name, e)
+                else:
+                    # Handle as absolute import when no filepath is provided
+                    try:
+                        module = importlib.import_module(module_name)
+                        for alias in node.names:
+                            name = alias.name
+                            asname = alias.asname or name
+                            if name == "*":
+                                # Handle 'from module import *'
+                                module_dict = {
+                                    k: v
+                                    for k, v in module.__dict__.items()
+                                    if not k.startswith("_")
+                                }
+                                namespace.update(module_dict)
+                            else:
+                                try:
+                                    attribute = getattr(module, name)
+                                    namespace[asname] = attribute
+                                except AttributeError as e:
+                                    logger.debug(
+                                        "Failed to retrieve %s from %s: %s",
+                                        name,
+                                        module_name,
+                                        e,
+                                    )
+                    except ImportError as e:
+                        logger.debug("Failed to import from %s: %s", module_name, e)
+        # Handle local definitions
+        for node in parsed_code.body:
+            if isinstance(node, (ast.ClassDef, ast.FunctionDef, ast.Assign)):
+                try:
+                    code = compile(
+                        ast.Module(body=[node], type_ignores=[]),
+                        filename="<ast>",
+                        mode="exec",
+                    )
+                    exec(code, namespace)
+                except Exception as e:
+                    logger.debug("Failed to compile: %s", e)
+
+    finally:
+        # Restore original sys.path if it was modified
+        if original_sys_path:
+            sys.path[:] = original_sys_path
+
     return namespace
 
 

prefect/utilities/services.py

@@ -1,4 +1,5 @@
 import sys
+from asyncio import CancelledError
 from collections import deque
 from traceback import format_exception
 from types import TracebackType
@@ -67,6 +68,11 @@ async def critical_service_loop(
                 backoff_count = 0
 
             track_record.append(True)
+        except CancelledError as exc:
+            # Exit immediately because the task was cancelled, possibly due
+            # to a signal or timeout.
+            logger.debug(f"Run of {workload!r} cancelled", exc_info=exc)
+            return
         except httpx.TransportError as exc:
             # httpx.TransportError is the base class for any kind of communications
             # error, like timeouts, connection failures, etc.  This does _not_ cover
@@ -138,7 +144,7 @@ async def critical_service_loop(
             failures.clear()
             printer(
                 "Backing off due to consecutive errors, using increased interval of "
-                f" {interval * 2**backoff_count}s."
+                f" {interval * 2 ** backoff_count}s."
             )
 
         if run_once:

prefect/workers/block.py

@@ -4,6 +4,7 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional
 import anyio
 import anyio.abc
 
+from prefect._internal.compatibility.deprecated import deprecated_class
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
 from prefect._internal.schemas.validators import validate_block_is_infrastructure
 from prefect.blocks.core import Block
@@ -27,6 +28,10 @@ if TYPE_CHECKING:
     from prefect.client.schemas.responses import DeploymentResponse
 
 
+@deprecated_class(
+    start_date="Jun 2024",
+    help="Refer to the upgrade guide for more information: https://docs.prefect.io/latest/guides/upgrade-guide-agents-to-workers/",
+)
 class BlockWorkerJobConfiguration(BaseModel):
     block: Block = Field(
         default=..., description="The infrastructure block to use for job creation."
@@ -144,6 +149,10 @@ class BlockWorkerResult(BaseWorkerResult):
     """Result of a block worker job"""
 
 
+@deprecated_class(
+    start_date="Jun 2024",
+    help="Refer to the upgrade guide for more information: https://docs.prefect.io/latest/guides/upgrade-guide-agents-to-workers/",
+)
 class BlockWorker(BaseWorker):
     type = "block"
     job_configuration = BlockWorkerJobConfiguration

{prefect_client-2.19.8.dist-info → prefect_client-2.20.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prefect-client
-Version: 2.19.8
+Version: 2.20.0
 Summary: Workflow orchestration and management.
 Home-page: https://www.prefect.io
 Author: Prefect Technologies, Inc.
@@ -23,7 +23,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Topic :: Software Development :: Libraries
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-Requires-Dist: anyio <4.0.0,>=3.7.1
+Requires-Dist: anyio <5.0.0,>=4.4.0
 Requires-Dist: asgi-lifespan <3.0,>=1.0
 Requires-Dist: cachetools <6.0,>=5.3
 Requires-Dist: cloudpickle <4.0,>=2.0
@@ -31,7 +31,7 @@ Requires-Dist: coolname <3.0.0,>=1.0.4
 Requires-Dist: croniter <3.0.0,>=1.0.12
 Requires-Dist: fsspec >=2022.5.0
 Requires-Dist: graphviz >=0.20.1
-Requires-Dist: griffe >=0.20.0
+Requires-Dist: griffe <0.48.0,>=0.20.0
 Requires-Dist: httpcore <2.0.0,>=1.0.5
 Requires-Dist: httpx[http2] !=0.23.2,>=0.23
 Requires-Dist: importlib-resources <6.2.0,>=6.1.3

{prefect_client-2.19.8.dist-info → prefect_client-2.20.0.dist-info}/RECORD

@@ -5,11 +5,11 @@ prefect/agent.py,sha256=HaGT0yh3fciluYpO99dVHo_LHq7N2cYLuWNrEV_kPV8,27789
 prefect/artifacts.py,sha256=mreaBE4qMoXkjc9YI-5cAxoye7ixraHB_zr8GTK9xPU,8694
 prefect/automations.py,sha256=rjVtQblBlKhD_q24bG6zbxJeb_XQJnodMlhr565aZJY,4853
 prefect/context.py,sha256=Hgn3rIjCbqfCmGnZzV_eZ2FwxGjEhaZjUw_nppqNQSA,18189
-prefect/engine.py,sha256=L9VCeRU4iO5Utj3kOlBlNSGD_t_AqMV-A5uN_82lk3U,90832
+prefect/engine.py,sha256=czyTcLPIaj_LOpPuWNheK0FfdOwX42VKLtonm7vZqH0,91938
 prefect/exceptions.py,sha256=ElqC81_w6XbTaxLYANLMIPK8Fz46NmJZCRKL4NZ-JIg,10907
 prefect/filesystems.py,sha256=XniPSdBAqywj43X7GyfuWJQIbz07QJ5Y3cVNLhIF3lQ,35260
 prefect/flow_runs.py,sha256=mFHLavZk1yZ62H3UazuNDBZWAF7AqKttA4rMcHgsVSw,3119
-prefect/flows.py,sha256=tfQJ3UxBZFl8XDuWti-G4ZUupDRc2ta4OtBIhAh6uAM,79409
+prefect/flows.py,sha256=-Ietkctf2ONzmqcytI9Fc8T1-vtPmEuOo3m6wPNLIrQ,84735
 prefect/futures.py,sha256=RaWfYIXtH7RsWxQ5QWTTlAzwtVV8XWpXaZT_hLq35vQ,12590
 prefect/manifests.py,sha256=sTM7j8Us5d49zaydYKWsKb7zJ96v1ChkLkLeR0GFYD8,683
 prefect/new_flow_engine.py,sha256=A1adTWTBAwPCn6ay003Jsoc2SdYgHV4AcJo1bmpa_7Y,16039
@@ -23,8 +23,8 @@ prefect/settings.py,sha256=gFVXmGLapnkIV7hQvRJMJ6472UZJr6gqZYk1xwcqgnQ,74931
 prefect/states.py,sha256=B38zIXnqc8cmw3GPxmMQ4thX6pXb6UtG4PoTZ5thGQs,21036
 prefect/task_engine.py,sha256=_2I7XLwoT_nNhpzTMa_52aQKjsDoaW6WpzwIHYEWZS0,2598
 prefect/task_runners.py,sha256=HXUg5UqhZRN2QNBqMdGE1lKhwFhT8TaRN75ScgLbnw8,11012
-prefect/task_server.py,sha256=3f6rDIOXmhhF_MDHGk5owaU9lyLHsR-zgCp6pIHEUyo,11075
-prefect/tasks.py,sha256=cQ_jfI4WfPlL80TehTKX5p-rjWfJAEgN4L51Rozj32o,55686
+prefect/task_server.py,sha256=-wHuAlY8DLEQuJcEvcFfB4da0Xdnmqk6D7GjHShh-Ik,11668
+prefect/tasks.py,sha256=HWTT9Y6obBId1VcLCQbmBFN4WUKE0j1pw2IvzyTgF70,56134
 prefect/variables.py,sha256=4r5gVGpAZxLWHj5JoNZJTuktX1-u3ENzVp3t4M6FDgs,3815
 prefect/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prefect/_internal/_logging.py,sha256=HvNHY-8P469o5u4LYEDBTem69XZEt1QUeUaLToijpak,810
@@ -156,7 +156,7 @@ prefect/blocks/abstract.py,sha256=AiAs0MC5JKCf0Xg0yofC5Qu2TZ52AjDMP1ntMGuP2dY,16
 prefect/blocks/core.py,sha256=66pGFVPxtCCGWELqPXYqN8L0GoUXuUqv6jWw3Kk-tyY,43496
 prefect/blocks/fields.py,sha256=ANOzbNyDCBIvm6ktgbLTMs7JW2Sf6CruyATjAW61ks0,1607
 prefect/blocks/kubernetes.py,sha256=IN-hZkzIRvqjd_dzPZby3q8p7m2oUWqArBq24BU9cDg,4071
-prefect/blocks/notifications.py,sha256=raXBPidAfec7VCyLA1bb46RD06i0zPtVonWcXtkeOUU,27211
+prefect/blocks/notifications.py,sha256=LJd2mgV29URqItJyxtWUpdo4wswtm7KyIseuAjV3joI,28132
 prefect/blocks/system.py,sha256=aIRiFKlXIQ1sMaqniMXYolFsx2IVN3taBMH3KCThB2I,3089
 prefect/blocks/webhook.py,sha256=VzQ-qcRtW8MMuYEGYwFgt1QXtWedUtVmeTo7iE2UQ78,2008
 prefect/client/__init__.py,sha256=yJ5FRF9RxNUio2V_HmyKCKw5G6CZO0h8cv6xA_Hkpcc,477
@@ -170,7 +170,7 @@ prefect/client/utilities.py,sha256=7V4IkfC8x_OZuPXGvtIMmwZCOW63hSY8iVQkuRYTR6g,3
 prefect/client/schemas/__init__.py,sha256=KlyqFV-hMulMkNstBn_0ijoHoIwJZaBj6B1r07UmgvE,607
 prefect/client/schemas/actions.py,sha256=4mq1OXMsXs6aGlXg1G232RNcn0ivAOIgikL0IKs6S-E,27943
 prefect/client/schemas/filters.py,sha256=gv57m0bHJqL7Ifsc_vAdRODFomaMVcrGXKAahOSBU4w,35598
-prefect/client/schemas/objects.py,sha256=Ie82ck5vXXgs0Q_luVe_NJkg_SAYN68d0nTxxFKt31M,53130
+prefect/client/schemas/objects.py,sha256=bA0kAN9fbeiE6yUGX6bRlScheYtg8uxu0eeuC3-3zd8,53309
 prefect/client/schemas/responses.py,sha256=XAc95g3PRL9UIkH9_VMuv0ECHKdc19guBLmdt5KefkI,15325
 prefect/client/schemas/schedules.py,sha256=ZF7fFbkcc8rVdx2MxE8DR0av3FUE9qDPjLreEuV8HfM,12193
 prefect/client/schemas/sorting.py,sha256=EIQ6FUjUWMwk6fn6ckVLQLXOP-GI5kce7ftjUkDFWV0,2490
@@ -181,7 +181,7 @@ prefect/concurrency/services.py,sha256=PQb4cs72lTRz_XEgDEfv4OkpHWC7KAmW_Xd9vpOOu
 prefect/concurrency/sync.py,sha256=QtnPRfVX9GqVyuZOt6W9yJuT9G-PlCSVnxlZKFTjuKY,3271
 prefect/deployments/__init__.py,sha256=dM866rOEz3BbAN_xaFMHj3Hw1oOFemBTZ2yxVE6IGoY,394
 prefect/deployments/base.py,sha256=0l2D_laMc3q2Q5nvh-WANv3iDy4Ih5BqcPMNJJbHuP0,16391
-prefect/deployments/deployments.py,sha256=bYNmxU0yn2jzluGIr2tUkgRi73WGQ6gGbjb0GlD4EIk,41656
+prefect/deployments/deployments.py,sha256=S9ro-RUNrc2v8uWFkLr3-JE7h3RGC-HO_f5T7xe4ABw,41884
 prefect/deployments/runner.py,sha256=a2dxc84zCofZFXV47M2zfntqUaoAhGWvf7o0s3MjPws,44772
 prefect/deployments/schedules.py,sha256=23GDCAKOP-aAEKGappwTrM4HU67ndVH7NR4Dq0neU_U,1884
 prefect/deployments/steps/__init__.py,sha256=3pZWONAZzenDszqNQT3bmTFilnvjB6xMolMz9tr5pLw,229
@@ -254,23 +254,23 @@ prefect/software/python.py,sha256=EssQ16aMvWSzzWagtNPfjQLu9ehieRwN0iWeqpBVtRU,17
 prefect/types/__init__.py,sha256=aZvlQ2uXl949sJ_khmxSVkRH3o6edo-eJ_GBGMBN5Yg,3134
 prefect/utilities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prefect/utilities/annotations.py,sha256=bXB43j5Zsq5gaBcJe9qnszBlnNwCTwqSTgcu2OkkRLo,2776
-prefect/utilities/asyncutils.py,sha256=1xpjGFs72vQTPXfG0ww1mfNBwp0-UbRICLGVeRuiqOg,17010
-prefect/utilities/callables.py,sha256=-Ccr5JmDoafth46MPPQCRStBMSG_ickCDfBztpd_MAs,21119
+prefect/utilities/asyncutils.py,sha256=ftu6MaV9qOZ3oCIErrneW07km2BydCezOMzvPUuCMUo,17246
+prefect/utilities/callables.py,sha256=YWilWp6oyL3D-hsyUuSE-h2KZ0aO_nbjhW75KsrLVmQ,21224
 prefect/utilities/collections.py,sha256=0v-NNXxYYzkUTCCNDMNB44AnDv9yj35UYouNraCqlo8,15449
 prefect/utilities/compat.py,sha256=mNQZDnzyKaOqy-OV-DnmH_dc7CNF5nQgW_EsA4xMr7g,906
 prefect/utilities/context.py,sha256=BThuUW94-IYgFYTeMIM9KMo8ShT3oiI7w5ajZHzU1j0,1377
 prefect/utilities/dispatch.py,sha256=BSAuYf3uchA6giBB90Z9tsmnR94SAqHZMHl01fRuA64,5467
 prefect/utilities/dockerutils.py,sha256=O5lIgCej5KGRYU2TC1NzNuIK595uOIWJilhZXYEVtOA,20180
-prefect/utilities/engine.py,sha256=TKiYqpfgt4zopuI8yvh2e-V9GgLcRrh3TpKRhvLuHdw,25669
+prefect/utilities/engine.py,sha256=6O7zYZQfpo6FtsI6n9DUNs-MB7_xLs3iXiCnSukR8qI,26046
 prefect/utilities/filesystem.py,sha256=M_TeZ1MftjBf7hDLWk-Iphir369TpJ1binMsBKiO9YE,4449
 prefect/utilities/hashing.py,sha256=EOwZLmoIZImuSTxAvVqInabxJ-4RpEfYeg9e2EDQF8o,1752
-prefect/utilities/importtools.py,sha256=MxGyPxfKjn6WtXVY9t8xRfDqK5MPUa4NBZqvyqIvp-4,15535
+prefect/utilities/importtools.py,sha256=JteP9zFz-oJyxSVYr63kJ-RpDL2jjTfJMqgYaBst19M,19518
 prefect/utilities/math.py,sha256=wLwcKVidpNeWQi1TUIWWLHGjlz9UgboX9FUGhx_CQzo,2821
 prefect/utilities/names.py,sha256=x-stHcF7_tebJPvB1dz-5FvdXJXNBTg2kFZXSnIBBmk,1657
 prefect/utilities/processutils.py,sha256=yo_GO48pZzgn4A0IK5irTAoqyUCYvWKDSqHXCrtP8c4,14547
 prefect/utilities/pydantic.py,sha256=3IR73F3gkuRG6HQfCEP9ENIC6qbK6oOFawjsYJfoUkg,9984
 prefect/utilities/render_swagger.py,sha256=h2UrORVN3f7gM4zurtMnySjQXZIOWbji3uMinpbkl8U,3717
-prefect/utilities/services.py,sha256=u0Gpdw5pYceaSLCqOihGyFb2AlMBYE2P9Ts9qRb3N9Q,6584
+prefect/utilities/services.py,sha256=POYQRdvkUs-0dFcgV-BOyII0NFttgW1NjDAJR1bbGqU,6865
 prefect/utilities/slugify.py,sha256=57Vb14t13F3zm1P65KAu8nVeAz0iJCd1Qc5eMG-R5y8,169
 prefect/utilities/templating.py,sha256=t32Gcsvvm8ibzdqXwcWzY7JkwftPn73FiiLYEnQWyKM,13237
 prefect/utilities/text.py,sha256=eXGIsCcZ7h_6hy8T5GDQjL8GiKyktoOqavYub0QjgO4,445
@@ -281,12 +281,12 @@ prefect/utilities/schema_tools/hydration.py,sha256=RNuJK4Vd__V69gdQbaWSVhSkV0AUI
 prefect/utilities/schema_tools/validation.py,sha256=zZHL_UFxAlgaUzi-qsEOrhWtZ7EkFQvPkX_YN1EJNTo,8414
 prefect/workers/__init__.py,sha256=6el2Q856CuRPa5Hdrbm9QyAWB_ovcT2bImSFsoWI46k,66
 prefect/workers/base.py,sha256=LKIMS2DaQSQRV4rjbrMYeQnY-9rzgj_KWBRIq-8c5rg,45125
-prefect/workers/block.py,sha256=5bdCuqT-4I-et_8ZLG2y1AODzYiCQwFiivhdt5NMEog,7635
+prefect/workers/block.py,sha256=aYY__uq3v1eq1kkbVukxyhQNbkknaKYo6-_3tcrfKKA,8067
 prefect/workers/process.py,sha256=pPtCdA7fKQ4OsvoitT-cayZeh5HgLX4xBUYlb2Zad-Q,9475
 prefect/workers/server.py,sha256=WVZJxR8nTMzK0ov0BD0xw5OyQpT26AxlXbsGQ1OrxeQ,1551
 prefect/workers/utilities.py,sha256=VfPfAlGtTuDj0-Kb8WlMgAuOfgXCdrGAnKMapPSBrwc,2483
-prefect_client-2.19.8.dist-info/LICENSE,sha256=MCxsn8osAkzfxKC4CC_dLcUkU8DZLkyihZ8mGs3Ah3Q,11357
-prefect_client-2.19.8.dist-info/METADATA,sha256=kFZAOZgAQSC1Qz_vFIkAxOyBRHquCOa9F-Rtwds-_-M,7402
-prefect_client-2.19.8.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-prefect_client-2.19.8.dist-info/top_level.txt,sha256=MJZYJgFdbRc2woQCeB4vM6T33tr01TmkEhRcns6H_H4,8
-prefect_client-2.19.8.dist-info/RECORD,,
+prefect_client-2.20.0.dist-info/LICENSE,sha256=MCxsn8osAkzfxKC4CC_dLcUkU8DZLkyihZ8mGs3Ah3Q,11357
+prefect_client-2.20.0.dist-info/METADATA,sha256=GRcdYDHMdwoy3FRSFZvP_sNOvtU3VEgUx1VMD6wUXdU,7410
+prefect_client-2.20.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+prefect_client-2.20.0.dist-info/top_level.txt,sha256=MJZYJgFdbRc2woQCeB4vM6T33tr01TmkEhRcns6H_H4,8
+prefect_client-2.20.0.dist-info/RECORD,,