prefect-client 2.14.20__tar.gz → 2.14.21__tar.gz

{prefect-client-2.14.20 → prefect-client-2.14.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prefect-client
-Version: 2.14.20
+Version: 2.14.21
 Summary: Workflow orchestration and management.
 Home-page: https://www.prefect.io
 Author: Prefect Technologies, Inc.

{prefect-client-2.14.20 → prefect-client-2.14.21}/requirements-dev.txt

@@ -1,7 +1,7 @@
 ruff
 cairosvg
 codespell
-flaky
+ddtrace
 # Pin IPython to 8.12 when building on Python 3.8
 # https://github.com/ipython/ipython/blob/main/README.rst
 ipython == 8.12.*; python_version == '3.8'
@@ -13,12 +13,13 @@ mkdocs-material
 mkdocstrings-python
 mike
 mock; python_version < '3.8'
-moto < 5
+moto >= 5
 mypy
 numpy
 pillow
 pre-commit
-pytest > 7, < 8
+pluggy >= 1.4.0
+pytest > 7, < 8 # Datadog's ddtrace does not support pytest 8 yet. See https://github.com/DataDog/dd-trace-py/issues/8220
 pytest-asyncio >= 0.18.2, != 0.22.0, < 0.23.0 # Cannot override event loop in 0.23.0. See https://github.com/pytest-dev/pytest-asyncio/issues/706 for more details.
 pytest-cov
 pytest-benchmark

{prefect-client-2.14.20 → prefect-client-2.14.21}/requirements.txt

@@ -12,7 +12,7 @@ graphviz >= 0.20.1
 griffe >= 0.20.0
 jinja2 >= 3.0.0, < 4.0.0
 kubernetes >= 24.2.0, < 30.0.0
-pytz >= 2021.1, < 2024
+pytz >= 2021.1, < 2025
 readchar >= 4.0.0, < 5.0.0
 sqlalchemy[asyncio] >= 1.4.22, != 1.4.33, < 3.0.0
 typer >= 0.4.2

{prefect-client-2.14.20 → prefect-client-2.14.21}/setup.cfg

@@ -1,5 +1,5 @@
 [tool:pytest]
-addopts = -rfEsx
+addopts = -rfEs
 norecursedirs = *.egg-info .git .mypy_cache node_modules .pytest_cache .vscode
 python_files = 
 	test_*.py
@@ -13,7 +13,7 @@ markers =
 env = 
 	PREFECT_TEST_MODE = 1
 asyncio_mode = auto
-timeout = 60
+timeout = 90
 filterwarnings = 
 	error
 	ignore::DeprecationWarning:tornado.platform.asyncio.*
@@ -26,7 +26,7 @@ filterwarnings =
 	ignore:The `dict` method is deprecated; use `model_dump` instead
 	ignore:The `schema` method is deprecated; use `model_json_schema` instead
 	ignore:Default value default=
-	ignore:Implicitly cleaning up <TemporaryDirectory 'C:ResourceWarning
+	ignore:Implicitly cleaning up:ResourceWarning
 	ignore::ResourceWarning:distributed.diskutils
 	ignore:unclosed:ResourceWarning:distributed.node
 	ignore::ImportWarning:google.api_core.exceptions
@@ -46,6 +46,10 @@ filterwarnings =
 	ignore:`PREFECT_API_URL` should have `/api` after the base URL.:UserWarning
 	ignore:datetime\.datetime\.utcnow\(\) is deprecated and scheduled for removal in a future version\..*:DeprecationWarning
 	ignore:datetime\.datetime\.utcfromtimestamp\(\) is deprecated and scheduled for removal in a future version\..*:DeprecationWarning
+	ignore::sqlalchemy.exc.SAWarning
+	ignore::ResourceWarning
+	ignore::pytest.PytestUnraisableExceptionWarning
+	ignore::pluggy.PluggyTeardownRaisedWarning
 
 [mypy]
 disallow_untyped_defs = False

{prefect-client-2.14.20 → prefect-client-2.14.21}/src/prefect/blocks/notifications.py

@@ -714,7 +714,8 @@ class CustomWebhookNotificationBlock(NotificationBlock):
 
         # make request with httpx
         client = httpx.AsyncClient(headers={"user-agent": "Prefect Notifications"})
-        resp = await client.request(**self._build_request_args(body, subject))
+        async with client:
+            resp = await client.request(**self._build_request_args(body, subject))
         resp.raise_for_status()
 
 

{prefect-client-2.14.20 → prefect-client-2.14.21}/src/prefect/client/schemas/objects.py

@@ -97,6 +97,14 @@ class DeploymentStatus(AutoEnum):
     NOT_READY = AutoEnum.auto()
 
 
+class WorkQueueStatus(AutoEnum):
+    """Enumeration of work queue statuses."""
+
+    READY = AutoEnum.auto()
+    NOT_READY = AutoEnum.auto()
+    PAUSED = AutoEnum.auto()
+
+
 class StateDetails(PrefectBaseModel):
     flow_run_id: UUID = None
     task_run_id: UUID = None
@@ -1222,6 +1230,9 @@ class WorkQueue(ObjectBaseModel):
     last_polled: Optional[DateTimeTZ] = Field(
         default=None, description="The last time an agent polled this queue for work."
     )
+    status: Optional[WorkQueueStatus] = Field(
+        default=None, description="The queue status."
+    )
 
     @validator("name", check_fields=False)
     def validate_name_characters(cls, v):

{prefect-client-2.14.20 → prefect-client-2.14.21}/src/prefect/client/subscriptions.py

@@ -1,5 +1,5 @@
 import asyncio
-from typing import Generic, Type, TypeVar
+from typing import Generic, List, Type, TypeVar
 
 import orjson
 import websockets
@@ -8,18 +8,23 @@ from starlette.status import WS_1008_POLICY_VIOLATION
 from typing_extensions import Self
 
 from prefect._internal.schemas.bases import IDBaseModel
+from prefect.logging import get_logger
 from prefect.settings import PREFECT_API_KEY, PREFECT_API_URL
 
+logger = get_logger(__name__)
+
 S = TypeVar("S", bound=IDBaseModel)
 
 
 class Subscription(Generic[S]):
-    def __init__(self, model: Type[S], path: str):
+    def __init__(self, model: Type[S], path: str, keys: List[str]):
         self.model = model
 
         base_url = PREFECT_API_URL.value().replace("http", "ws", 1)
         self.subscription_url = f"{base_url}{path}"
 
+        self.keys = keys
+
         self._connect = websockets.connect(
             self.subscription_url,
             subprotocols=["prefect"],
@@ -57,13 +62,19 @@ class Subscription(Generic[S]):
 
         websocket = await self._connect.__aenter__()
 
-        await websocket.send(
-            orjson.dumps({"type": "auth", "token": PREFECT_API_KEY.value()}).decode()
-        )
-
         try:
+            await websocket.send(
+                orjson.dumps(
+                    {"type": "auth", "token": PREFECT_API_KEY.value()}
+                ).decode()
+            )
+
             auth = orjson.loads(await websocket.recv())
             assert auth["type"] == "auth_success"
+
+            await websocket.send(
+                orjson.dumps({"type": "subscribe", "keys": self.keys}).decode()
+            )
         except (
             AssertionError,
             websockets.exceptions.ConnectionClosedError,

{prefect-client-2.14.20 → prefect-client-2.14.21}/src/prefect/context.py

@@ -236,7 +236,7 @@ class EngineContext(RunContext):
     autonomous_task_run: Optional[TaskRun] = None
     task_runner: BaseTaskRunner
     log_prints: bool = False
-    parameters: Dict[str, Any]
+    parameters: Optional[Dict[str, Any]] = None
 
     # Result handling
     result_factory: ResultFactory

{prefect-client-2.14.20 → prefect-client-2.14.21}/src/prefect/engine.py

@@ -1341,12 +1341,13 @@ async def resume_flow_run(flow_run_id, run_input: Optional[Dict] = None):
         run_input: a dictionary of inputs to provide to the flow run.
     """
     client = get_client()
-    flow_run = await client.read_flow_run(flow_run_id)
+    async with client:
+        flow_run = await client.read_flow_run(flow_run_id)
 
-    if not flow_run.state.is_paused():
-        raise NotPausedError("Cannot resume a run that isn't paused!")
+        if not flow_run.state.is_paused():
+            raise NotPausedError("Cannot resume a run that isn't paused!")
 
-    response = await client.resume_flow_run(flow_run_id, run_input=run_input)
+        response = await client.resume_flow_run(flow_run_id, run_input=run_input)
 
     if response.status == SetStateStatus.REJECT:
         if response.state.type == StateType.FAILED:
@@ -1369,7 +1370,17 @@ def enter_task_run_engine(
 
     if not flow_run_context:
         if PREFECT_EXPERIMENTAL_ENABLE_TASK_SCHEDULING.value():
-            return _create_autonomous_task_run(task=task, parameters=parameters)
+            create_autonomous_task_run = create_call(
+                _create_autonomous_task_run, task=task, parameters=parameters
+            )
+            if task.isasync:
+                return from_async.wait_for_call_in_loop_thread(
+                    create_autonomous_task_run
+                )
+            else:
+                return from_sync.wait_for_call_in_loop_thread(
+                    create_autonomous_task_run
+                )
 
         raise RuntimeError(
             "Tasks cannot be run outside of a flow"
@@ -1738,7 +1749,10 @@ async def submit_task_run(
         ),
     )
 
-    if task_runner.concurrency_type != TaskConcurrencyType.SEQUENTIAL:
+    if (
+        task_runner.concurrency_type != TaskConcurrencyType.SEQUENTIAL
+        and not flow_run_context.autonomous_task_run
+    ):
         logger.info(f"Submitted task run {task_run.name!r} for execution.")
 
     return future
@@ -2200,7 +2214,6 @@ async def orchestrate_task_run(
         level=logging.INFO if state.is_completed() else logging.ERROR,
         msg=f"Finished in state {display_state}",
     )
-    logger.warning(f"Task run {task_run.name!r} finished in state {display_state}")
     return state
 
 
@@ -2914,7 +2927,6 @@ def _emit_task_run_state_change_event(
     )
 
 
-@sync_compatible
 async def _create_autonomous_task_run(
     task: Task, parameters: Dict[str, Any]
 ) -> TaskRun:

{prefect-client-2.14.20 → prefect-client-2.14.21}/src/prefect/events/utilities.py

@@ -8,7 +8,7 @@ from prefect._internal.schemas.fields import DateTimeTZ
 
 from .clients import AssertingEventsClient, PrefectCloudEventsClient
 from .schemas import Event, RelatedResource
-from .worker import EventsWorker
+from .worker import EventsWorker, emit_events_to_cloud
 
 TIGHT_TIMING = timedelta(minutes=5)
 
@@ -42,6 +42,9 @@ def emit_event(
         The event that was emitted if worker is using a client that emit
         events, otherwise None.
     """
+    if not emit_events_to_cloud():
+        return None
+
     operational_clients = [AssertingEventsClient, PrefectCloudEventsClient]
     worker_instance = EventsWorker.instance()
 

{prefect-client-2.14.20 → prefect-client-2.14.21}/src/prefect/events/worker.py

@@ -14,6 +14,15 @@ from .related import related_resources_from_run_context
 from .schemas import Event
 
 
+def emit_events_to_cloud() -> bool:
+    api = PREFECT_API_URL.value()
+    return (
+        experiment_enabled("events_client")
+        and api
+        and api.startswith(PREFECT_CLOUD_API_URL.value())
+    )
+
+
 class EventsWorker(QueueService[Event]):
     def __init__(
         self, client_type: Type[EventsClient], client_options: Tuple[Tuple[str, Any]]
@@ -52,12 +61,7 @@ class EventsWorker(QueueService[Event]):
 
         # Select a client type for this worker based on settings
         if client_type is None:
-            api = PREFECT_API_URL.value()
-            if (
-                experiment_enabled("events_client")
-                and api
-                and api.startswith(PREFECT_CLOUD_API_URL.value())
-            ):
+            if emit_events_to_cloud():
                 client_type = PrefectCloudEventsClient
                 client_kwargs = {
                     "api_url": PREFECT_API_URL.value(),

{prefect-client-2.14.20 → prefect-client-2.14.21}/src/prefect/results.py

@@ -185,10 +185,9 @@ class ResultFactory(pydantic.BaseModel):
                 persist_result=(
                     flow.persist_result
                     if flow.persist_result is not None
-                    else
                     # !! Child flows persist their result by default if the it or the
                     #    parent flow uses a feature that requires it
-                    (
+                    else (
                         flow_features_require_result_persistence(flow)
                         or flow_features_require_child_result_persistence(ctx.flow)
                         or get_default_persist_setting()
@@ -209,10 +208,9 @@ class ResultFactory(pydantic.BaseModel):
                 persist_result=(
                     flow.persist_result
                     if flow.persist_result is not None
-                    else
                     # !! Flows persist their result by default if uses a feature that
                     #    requires it
-                    (
+                    else (
                         flow_features_require_result_persistence(flow)
                         or get_default_persist_setting()
                     )
@@ -246,10 +244,9 @@ class ResultFactory(pydantic.BaseModel):
         persist_result = (
             task.persist_result
             if task.persist_result is not None
-            else
             # !! Tasks persist their result by default if their parent flow uses a
             #    feature that requires it or the task uses a feature that requires it
-            (
+            else (
                 (
                     flow_features_require_child_result_persistence(ctx.flow)
                     if ctx

{prefect-client-2.14.20 → prefect-client-2.14.21}/src/prefect/runner/server.py

@@ -87,7 +87,7 @@ async def _build_endpoint_for_deployment(
     deployment: "DeploymentResponse", runner: "Runner"
 ) -> Callable:
     async def _create_flow_run_for_deployment(
-        body: Optional[Dict[Any, Any]] = None
+        body: Optional[Dict[Any, Any]] = None,
     ) -> JSONResponse:
         body = body or {}
         if deployment.enforce_parameter_schema and deployment.parameter_openapi_schema:

{prefect-client-2.14.20 → prefect-client-2.14.21}/src/prefect/settings.py

@@ -1416,6 +1416,22 @@ PREFECT_TASK_SCHEDULING_DELETE_FAILED_SUBMISSIONS = Setting(
 Whether or not to delete failed task submissions from the database.
 """
 
+PREFECT_TASK_SCHEDULING_MAX_SCHEDULED_QUEUE_SIZE = Setting(
+    int,
+    default=1000,
+)
+"""
+The maximum number of scheduled tasks to queue for submission.
+"""
+
+PREFECT_TASK_SCHEDULING_MAX_RETRY_QUEUE_SIZE = Setting(
+    int,
+    default=100,
+)
+"""
+The maximum number of retries to queue for submission.
+"""
+
 PREFECT_EXPERIMENTAL_ENABLE_EXTRA_RUNNER_ENDPOINTS = Setting(bool, default=False)
 """
 Whether or not to enable experimental worker webserver endpoints.
@@ -1447,6 +1463,11 @@ PREFECT_EXPERIMENTAL_ENABLE_TASK_SCHEDULING = Setting(bool, default=False)
 Whether or not to enable experimental task scheduling.
 """
 
+PREFECT_EXPERIMENTAL_ENABLE_WORK_QUEUE_STATUS = Setting(bool, default=False)
+"""
+Whether or not to enable experimental work queue status in-place of work queue health.
+"""
+
 # Defaults -----------------------------------------------------------------------------
 
 PREFECT_DEFAULT_RESULT_STORAGE_BLOCK = Setting(

{prefect-client-2.14.20 → prefect-client-2.14.21}/src/prefect/task_engine.py

@@ -8,7 +8,6 @@ from typing import (
 )
 
 import anyio
-from anyio import start_blocking_portal
 from typing_extensions import Literal
 
 from prefect._internal.concurrency.api import create_call, from_async, from_sync
@@ -21,7 +20,7 @@ from prefect.engine import (
 )
 from prefect.futures import PrefectFuture
 from prefect.results import ResultFactory
-from prefect.task_runners import BaseTaskRunner, SequentialTaskRunner
+from prefect.task_runners import BaseTaskRunner
 from prefect.tasks import Task
 from prefect.utilities.asyncutils import sync_compatible
 
@@ -32,28 +31,28 @@ EngineReturnType = Literal["future", "state", "result"]
 async def submit_autonomous_task_to_engine(
     task: Task,
     task_run: TaskRun,
+    task_runner: Type[BaseTaskRunner],
     parameters: Optional[Dict] = None,
     wait_for: Optional[Iterable[PrefectFuture]] = None,
     mapped: bool = False,
     return_type: EngineReturnType = "future",
-    task_runner: Optional[Type[BaseTaskRunner]] = None,
+    client=None,
 ) -> Any:
-    parameters = parameters or {}
     async with AsyncExitStack() as stack:
+        if not task_runner._started:
+            task_runner_ctx = await stack.enter_async_context(task_runner.start())
+        else:
+            task_runner_ctx = task_runner
+        parameters = parameters or {}
         with EngineContext(
             flow=None,
             flow_run=None,
             autonomous_task_run=task_run,
-            task_runner=await stack.enter_async_context(
-                (task_runner if task_runner else SequentialTaskRunner()).start()
-            ),
-            client=await stack.enter_async_context(get_client()),
+            task_runner=task_runner_ctx,
+            client=client or await stack.enter_async_context(get_client()),
             parameters=parameters,
             result_factory=await ResultFactory.from_task(task),
             background_tasks=await stack.enter_async_context(anyio.create_task_group()),
-            sync_portal=(
-                stack.enter_context(start_blocking_portal()) if task.isasync else None
-            ),
         ) as flow_run_context:
             begin_run = create_call(
                 begin_task_map if mapped else get_task_call_return_value,

{prefect-client-2.14.20 → prefect-client-2.14.21}/src/prefect/task_server.py

@@ -1,8 +1,9 @@
 import asyncio
 import signal
 import sys
+from contextlib import AsyncExitStack
 from functools import partial
-from typing import Iterable, Optional
+from typing import Iterable, Optional, Type
 
 import anyio
 import anyio.abc
@@ -19,40 +20,44 @@ from prefect.settings import (
     PREFECT_TASK_SCHEDULING_DELETE_FAILED_SUBMISSIONS,
 )
 from prefect.task_engine import submit_autonomous_task_to_engine
+from prefect.task_runners import BaseTaskRunner, ConcurrentTaskRunner
 from prefect.utilities.asyncutils import asyncnullcontext, sync_compatible
-from prefect.utilities.collections import distinct
 from prefect.utilities.processutils import _register_signal
 
 logger = get_logger("task_server")
 
 
 class TaskServer:
-    """This class is responsible for serving tasks that may be executed autonomously
-    (i.e., without a parent flow run).
+    """This class is responsible for serving tasks that may be executed autonomously by a
+    task runner in the engine.
 
-    When `start()` is called, the task server will subscribe to the task run scheduling
-    topic and poll for scheduled task runs. When a scheduled task run is found, it
-    will submit the task run to the engine for execution, using `submit_autonomous_task_to_engine`
-    to construct a minimal `EngineContext` for the task run.
+    When `start()` is called, the task server will open a websocket connection to a
+    server-side queue of scheduled task runs. When a scheduled task run is found, the
+    scheduled task run is submitted to the engine for execution with a minimal `EngineContext`
+    so that the task run can be governed by orchestration rules.
 
     Args:
         - tasks: A list of tasks to serve. These tasks will be submitted to the engine
             when a scheduled task run is found.
-        - tags: A list of tags to apply to the task server. Defaults to `["autonomous"]`.
+        - task_runner: The task runner to use for executing the tasks. Defaults to
+            `ConcurrentTaskRunner`.
     """
 
     def __init__(
         self,
         *tasks: Task,
-        tags: Optional[Iterable[str]] = None,
+        task_runner: Optional[Type[BaseTaskRunner]] = None,
+        extra_tags: Optional[Iterable[str]] = None,
     ):
         self.tasks: list[Task] = tasks
-        self.tags: Iterable[str] = tags or ["autonomous"]
+        self.task_runner: Type[BaseTaskRunner] = task_runner or ConcurrentTaskRunner()
+        self.extra_tags: Iterable[str] = extra_tags or []
         self.last_polled: Optional[pendulum.DateTime] = None
-        self.started = False
-        self.stopping = False
+        self.started: bool = False
+        self.stopping: bool = False
 
         self._client = get_client()
+        self._exit_stack = AsyncExitStack()
 
         if not asyncio.get_event_loop().is_running():
             raise RuntimeError(
@@ -89,14 +94,15 @@ class TaskServer:
                 " calling .start()"
             )
 
-        logger.info("Stopping task server...")
         self.started = False
         self.stopping = True
 
     async def _subscribe_to_task_scheduling(self):
-        subscription = Subscription(TaskRun, "/task_runs/subscriptions/scheduled")
-        logger.debug(f"Created: {subscription}")
-        async for task_run in subscription:
+        async for task_run in Subscription(
+            TaskRun,
+            "/task_runs/subscriptions/scheduled",
+            [task.task_key for task in self.tasks],
+        ):
             logger.info(f"Received task run: {task_run.id} - {task_run.name}")
             await self._submit_pending_task_run(task_run)
 
@@ -142,22 +148,23 @@ class TaskServer:
             f"Submitting run {task_run.name!r} of task {task.name!r} to engine"
         )
 
-        task_run.tags = distinct(task_run.tags + list(self.tags))
-
         self._runs_task_group.start_soon(
             partial(
                 submit_autonomous_task_to_engine,
                 task=task,
                 task_run=task_run,
                 parameters=parameters,
+                task_runner=self.task_runner,
+                client=self._client,
             )
         )
 
     async def __aenter__(self):
         logger.debug("Starting task server...")
-        self._client = get_client()
-        await self._client.__aenter__()
-        await self._runs_task_group.__aenter__()
+
+        self._client = await self._exit_stack.enter_async_context(get_client())
+        await self._exit_stack.enter_async_context(self._runs_task_group)
+        await self._exit_stack.enter_async_context(self.task_runner.start())
 
         self.started = True
         return self
@@ -165,20 +172,25 @@ class TaskServer:
     async def __aexit__(self, *exc_info):
         logger.debug("Stopping task server...")
         self.started = False
-        if self._runs_task_group:
-            await self._runs_task_group.__aexit__(*exc_info)
-        if self._client:
-            await self._client.__aexit__(*exc_info)
+
+        await self._exit_stack.__aexit__(*exc_info)
 
 
 @sync_compatible
-async def serve(*tasks: Task, tags: Optional[Iterable[str]] = None):
-    """Serve the provided tasks so that they may be executed autonomously.
+async def serve(
+    *tasks: Task,
+    task_runner: Optional[Type[BaseTaskRunner]] = None,
+    extra_tags: Optional[Iterable[str]] = None,
+):
+    """Serve the provided tasks so that they may be submitted and executed to the engine.
+    Tasks do not need to be within a flow run context to be submitted and executed.
+    Ideally, you should `.submit` the same task object that you pass to `serve`.
 
     Args:
         - tasks: A list of tasks to serve. When a scheduled task run is found for a
             given task, the task run will be submitted to the engine for execution.
-        - tags: A list of tags to apply to the task server. Defaults to `["autonomous"]`.
+        - task_runner: The task runner to use for executing the tasks. Defaults to
+            `ConcurrentTaskRunner`.
 
     Example:
         ```python
@@ -204,5 +216,9 @@ async def serve(*tasks: Task, tags: Optional[Iterable[str]] = None):
             " to True."
         )
 
-    task_server = TaskServer(*tasks, tags=tags)
-    await task_server.start()
+    task_server = TaskServer(*tasks, task_runner=task_runner)
+    try:
+        await task_server.start()
+
+    except (asyncio.CancelledError, KeyboardInterrupt):
+        logger.info("Task server interrupted, stopping...")

{prefect-client-2.14.20 → prefect-client-2.14.21}/src/prefect/utilities/asyncutils.py

@@ -28,6 +28,8 @@ import anyio.abc
 import sniffio
 from typing_extensions import Literal, ParamSpec, TypeGuard
 
+from prefect.logging import get_logger
+
 T = TypeVar("T")
 P = ParamSpec("P")
 R = TypeVar("R")
@@ -40,6 +42,8 @@ EVENT_LOOP_GC_REFS = {}
 
 PREFECT_THREAD_LIMITER: Optional[anyio.CapacityLimiter] = None
 
+logger = get_logger()
+
 
 def get_thread_limiter():
     global PREFECT_THREAD_LIMITER
@@ -334,7 +338,13 @@ async def add_event_loop_shutdown_callback(coroutine_fn: Callable[[], Awaitable]
     EVENT_LOOP_GC_REFS[key] = on_shutdown(key)
 
     # Begin iterating so it will be cleaned up as an incomplete generator
-    await EVENT_LOOP_GC_REFS[key].__anext__()
+    try:
+        await EVENT_LOOP_GC_REFS[key].__anext__()
+    # There is a poorly understood edge case we've seen in CI where the key is
+    # removed from the dict before we begin generator iteration.
+    except KeyError:
+        logger.warn("The event loop shutdown callback was not properly registered. ")
+        pass
 
 
 class GatherIncomplete(RuntimeError):

{prefect-client-2.14.20 → prefect-client-2.14.21}/src/prefect/utilities/filesystem.py

@@ -3,6 +3,7 @@ Utilities for working with file systems
 """
 import os
 import pathlib
+import threading
 from contextlib import contextmanager
 from pathlib import Path, PureWindowsPath
 from typing import Union
@@ -51,6 +52,9 @@ def filter_files(
     return included_files
 
 
+chdir_lock = threading.Lock()
+
+
 @contextmanager
 def tmpchdir(path: str):
     """
@@ -62,11 +66,12 @@ def tmpchdir(path: str):
 
     owd = os.getcwd()
 
-    try:
-        os.chdir(path)
-        yield path
-    finally:
-        os.chdir(owd)
+    with chdir_lock:
+        try:
+            os.chdir(path)
+            yield path
+        finally:
+            os.chdir(owd)
 
 
 def filename(path: str) -> str: