prefect-client 3.9.1.dev3__tar.gz → 3.9.1.dev5__tar.gz

{prefect_client-3.9.1.dev3 → prefect_client-3.9.1.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: prefect-client
-Version: 3.9.1.dev3
+Version: 3.9.1.dev5
 Summary: Workflow orchestration and management.
 Project-URL: Changelog, https://github.com/PrefectHQ/prefect/releases
 Project-URL: Documentation, https://docs.prefect.io

{prefect_client-3.9.1.dev3 → prefect_client-3.9.1.dev5}/src/prefect/AGENTS.md

@@ -6,6 +6,10 @@ The foundation for building and executing workflows with Python. This covers the
 
 There is no formal public/private boundary beyond the `_` prefix convention. Modules and functions prefixed with `_` are internal. Everything else is considered public and requires backward compatibility.
 
+## Runtime Parameter Defaults
+
+Runtime flow/task parameter values must come from `utilities.callables.get_call_parameters` or `get_parameter_defaults`: raw signature defaults can be `pydantic.Field(...)` objects. These helpers unwrap `FieldInfo` defaults; schema generation intentionally retains `FieldInfo` to preserve metadata.
+
 ## Entry Points
 
 - `flows.py` / `tasks.py` — `@flow` and `@task` decorator definitions. The primary user-facing API.
@@ -25,7 +29,8 @@ There is no formal public/private boundary beyond the `_` prefix convention. Mod
 - **Sync and async must stay in sync.** Both `flow_engine.py` and `task_engine.py` have sync and async paths. Any behavior change must be applied to both.
 - **Event and log WebSocket subscribers are parallel implementations.** `events/clients.py::PrefectEventSubscriber` and `logging/clients.py::PrefectLogsSubscriber` duplicate the same reconnect/backoff/dedup logic, including the `reconnect_on_clean_close` option (used by `events/subscribers.py::FlowRunSubscriber` so a clean disconnect doesn't hide a terminal event). Mirror any reconnection-behavior change across both.
 - **Flow run observers own their stream recovery.** `_internal/observers.py` observers create subscribers with `reconnection_attempts=0` and delegate polling fallback, reconnect backoff, and setup deadlines to `_internal/_observation_delivery.py::ObservationDelivery`. Subscribers close any socket left by a failed or cancelled `__aenter__`, since callers never exit a context that failed to enter.
-- **Use `whenever` compat helpers for all datetime conversions on Python 3.13+.** `types/_datetime.py` provides `now()`, `_whenever_to_stdlib()`, `_whenever_zdt_from_py()`, and `_whenever_pdt_from_py()` to abstract over API differences across supported whenever releases. Version-specific code is guarded by feature-detection flags (`_WHENEVER_NEW_API` for ≥ 0.10.0, `_SYSTEM_TZ` for ≥ 0.11), not version checks. Never call `DateTime.now()` or `pendulum.now()` directly — use `now()` from `types/_datetime.py` instead. Avoid no-argument `datetime.datetime.now()` because it returns a tz-naive datetime that raises `TypeError` when compared to the tz-aware datetimes produced by `now()`. Explicitly timezone-aware stdlib calls such as `datetime.now(ZoneInfo("UTC"))` are allowed when needed to preserve timezone information. Never call `ZonedDateTime.from_py_datetime()`, `PlainDateTime.from_py_datetime()`, or `.py_datetime()` directly — use the helpers instead. Likewise avoid `.assume_system_tz()`/`.to_system_tz()` (deprecated in 0.11; the warning fails tests under `filterwarnings = error`) — use `in_local_tz()` — and direct `DateTimeDelta` imports (removed in 0.11) — use the `Interval` alias. Violations will silently break on whichever whenever version the helpers weren't written for.
+- **Use `whenever` compat helpers for all datetime conversions on Python 3.13+.** `prefect-client` depends on `whenever` only on Python 3.13+, so modules it ships must keep `whenever` imports behind `sys.version_info >= (3, 13)`; only server code that the client build strips may import it unconditionally (see `client/AGENTS.md`). `types/_datetime.py` provides `now()`, `_whenever_to_stdlib()`, `_whenever_zdt_from_py()`, and `_whenever_pdt_from_py()` to abstract over API differences across supported whenever releases. Version-specific code is guarded by feature-detection flags (`_WHENEVER_NEW_API` for ≥ 0.10.0, `_SYSTEM_TZ` for ≥ 0.11), not version checks. Never call `DateTime.now()` or `pendulum.now()` directly — use `now()` from `types/_datetime.py` instead. Avoid no-argument `datetime.datetime.now()` because it returns a tz-naive datetime that raises `TypeError` when compared to the tz-aware datetimes produced by `now()`. Explicitly timezone-aware stdlib calls such as `datetime.now(ZoneInfo("UTC"))` are allowed when needed to preserve timezone information. Never call `ZonedDateTime.from_py_datetime()`, `PlainDateTime.from_py_datetime()`, or `.py_datetime()` directly — use the helpers instead. Likewise avoid `.assume_system_tz()`/`.to_system_tz()` (deprecated in 0.11; the warning fails tests under `filterwarnings = error`) — use `in_local_tz()` — and direct `DateTimeDelta` imports (removed in 0.11) — use the `Interval` alias. Violations will silently break on whichever whenever version the helpers weren't written for.
+- **Call Pendulum-only members via `types/_datetime.py::_pendulum_call` on Python 3.11/3.12.** Prefect's `DateTime`/`Date`/`Duration` wrap Pendulum-only members (and some shared stdlib methods like `replace`) with user-facing deprecation warnings; `_pendulum_call` bypasses them so users only see warnings for their own calls. `pyproject.toml` ignores these warnings in pytest, so direct calls from Prefect code pass tests silently unless covered by the guards in `tests/test_datetime.py`.
 - **Flow and task engines advance state differently.** The flow engine makes blocking API calls to the server to propose and advance states. The task engine emits `prefect.task_run.*` events (delivered via WebSockets) but advances state locally through `set_state` calls with polling/backoff — do not assume the two engines work the same way.
 - **Flow state transitions go through the server.** The flow engine proposes states to the server, which accepts or rejects them via orchestration rules. The task engine, by contrast, manages state transitions locally via `set_state` and emits `prefect.task_run.*` events — it does not propose states to the server.
 - **`ProcessPoolTaskRunner` requires picklable data across subprocess boundaries.** `PrefectFuture` objects are not picklable and cannot be passed to worker subprocesses. Any `wait_for` futures must be waited on in the parent process and converted to `State` objects before submission. The subprocess task engine handles `State` objects via `resolve_to_final_result`, which raises `UpstreamTaskError` for non-completed upstreams.
@@ -69,3 +74,7 @@ Use `get_logger()` from `prefect.logging` instead of raw `logging.getLogger()`
 - `docker/` → `DockerImage` class for building and pushing Docker images during deployment
 - `telemetry/` → OS-level resource metric collection and run telemetry
 - `testing/` → Test utilities shipped with the SDK: `prefect_test_harness`, assertion helpers, and reusable fixtures (see testing/AGENTS.md)
+
+## Multi-pass Templating
+
+When applying `utilities.templating.apply_values` in stages, use `remove_notset=False` on passes that must preserve placeholders for later values. The default drops unresolved whole-value dict entries and list items and blanks unresolved inline placeholders. This matters when deployment preparation applies environment values before build/push outputs exist; only remove unresolved values when the caller has reached its final resolution pass.

prefect_client-3.9.1.dev5/src/prefect/_build_info.py

@@ -0,0 +1,5 @@
+# Generated by versioningit
+__version__ = "3.9.1.dev5"
+__build_date__ = "2026-10-27 08:19:52.409161+00:00"
+__git_commit__ = "7c7b28a1be2b6db40bd61baecc1925c472f6df75"
+__dirty__ = False

{prefect_client-3.9.1.dev3 → prefect_client-3.9.1.dev5}/src/prefect/_internal/concurrency/services.py

@@ -271,8 +271,9 @@ class _QueueServiceBase(abc.ABC, Generic[T]):
 
         self._stop(at_exit=at_exit)
 
-        assert self._done_event is not None
-        if self._done_event.is_set():
+        # `_done_event` is unset if the service never started in this process, e.g.
+        # in a child process after `reset_for_fork`
+        if self._done_event is None or self._done_event.is_set():
             future: concurrent.futures.Future[bool] = concurrent.futures.Future()
             future.set_result(False)
             return future

{prefect_client-3.9.1.dev3 → prefect_client-3.9.1.dev5}/src/prefect/_internal/result_records.py

@@ -37,6 +37,7 @@ if TYPE_CHECKING:
 ResultSerializer = Union[Serializer, str]
 LITERAL_TYPES: set[type] = {type(None), bool, UUID}
 R = TypeVar("R")
+_LEGACY_RESULT_BLOB_KEYS = {"serializer", "data", "prefect_version", "expiration"}
 
 
 class ResultRecordMetadata(BaseModel):
@@ -173,16 +174,19 @@ class ResultRecord(BaseModel, Generic[R]):
         if isinstance(value, dict):
             if TYPE_CHECKING:  # TODO: # isintance doesn't accept generic parameters
                 value = cast(dict[str, Any], value)
-            if "data" in value:
+            # Only coerce the exact legacy `PersistedResultBlob` shape so that raw
+            # JSON results that happen to contain a `data` key aren't misread
+            if (
+                {"data", "serializer"} <= value.keys() <= _LEGACY_RESULT_BLOB_KEYS
+                and isinstance(value["data"], str)
+                and isinstance(value["serializer"], dict)
+            ):
                 value["result"] = value.pop("data")
-            if "metadata" not in value:
-                value["metadata"] = {}
-            if "expiration" in value:
-                value["metadata"]["expiration"] = value.pop("expiration")
-            if "serializer" in value:
-                value["metadata"]["serializer"] = value.pop("serializer")
-            if "prefect_version" in value:
-                value["metadata"]["prefect_version"] = value.pop("prefect_version")
+                value["metadata"] = {"serializer": value.pop("serializer")}
+                if "expiration" in value:
+                    value["metadata"]["expiration"] = value.pop("expiration")
+                if "prefect_version" in value:
+                    value["metadata"]["prefect_version"] = value.pop("prefect_version")
         return value
 
     def serialize_metadata(self) -> bytes:

{prefect_client-3.9.1.dev3 → prefect_client-3.9.1.dev5}/src/prefect/cache_policies.py

@@ -4,6 +4,7 @@ from copy import deepcopy
 from dataclasses import dataclass, field, replace
 from logging import Logger
 from pathlib import Path
+from types import CodeType
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -45,9 +46,10 @@ def _register_stable_transforms() -> None:
     if sys.modules.get("pandas") is not None:
         import pandas as pd  # pyright: ignore
 
-        STABLE_TRANSFORMS[pd.DataFrame] = lambda df: [  # pyright: ignore
-            df[col] for col in sorted(df.columns)
-        ]
+        STABLE_TRANSFORMS[pd.DataFrame] = lambda df: (  # pyright: ignore
+            list(df.columns),
+            [df.iloc[:, i] for i in range(len(df.columns))],
+        )
 
 
 @dataclass
@@ -282,6 +284,19 @@ class _None(CachePolicy):
         return other
 
 
+def _normalize_code_location(code: CodeType) -> CodeType:
+    """Remove compilation locations, including those in nested code constants."""
+    return code.replace(
+        co_filename="",
+        co_firstlineno=1,
+        co_linetable=b"",
+        co_consts=tuple(
+            _normalize_code_location(const) if isinstance(const, CodeType) else const
+            for const in code.co_consts
+        ),
+    )
+
+
 @dataclass
 class TaskSource(CachePolicy):
     """
@@ -312,7 +327,10 @@ class TaskSource(CachePolicy):
             lines = inspect.getsource(task_ctx.task.fn.__class__)
         except OSError as exc:
             if "source code" in str(exc):
-                lines = task_ctx.task.fn.__code__.co_code
+                return hash_objects(
+                    _normalize_code_location(task_ctx.task.fn.__code__),
+                    raise_on_failure=True,
+                )
             else:
                 raise
 

{prefect_client-3.9.1.dev3 → prefect_client-3.9.1.dev5}/src/prefect/client/orchestration/_work_pools/client.py

@@ -525,6 +525,8 @@ class WorkPoolAsyncClient(BaseAsyncClient):
                 json=work_pool.model_dump(mode="json", exclude_unset=True),
             )
         except HTTPStatusError as e:
+            if e.response.status_code == 403 and "plan does not support" in str(e):
+                raise ObjectUnsupported(http_exc=e) from e
             if e.response.status_code == 409:
                 if overwrite:
                     existing_work_pool = await self.read_work_pool(

{prefect_client-3.9.1.dev3 → prefect_client-3.9.1.dev5}/src/prefect/client/schemas/sorting.py

@@ -25,6 +25,8 @@ class TaskRunSort(AutoEnum):
     NAME_DESC = AutoEnum.auto()
     NEXT_SCHEDULED_START_TIME_ASC = AutoEnum.auto()
     END_TIME_DESC = AutoEnum.auto()
+    DURATION_DESC = AutoEnum.auto()
+    DURATION_ASC = AutoEnum.auto()
 
 
 class AutomationSort(AutoEnum):

{prefect_client-3.9.1.dev3 → prefect_client-3.9.1.dev5}/src/prefect/events/AGENTS.md

@@ -8,6 +8,7 @@ Client-side event system for emitting, subscribing to, and defining automations
 - Events follow the CloudEvents-inspired schema: `Event` with `Resource` and `RelatedResource`.
 - Automations combine triggers (event, metric, compound, sequence) with actions.
 - **Metric triggers are Cloud-only.** OSS's `ServerTriggerTypes` excludes `MetricTrigger`, so `POST /automations` returns 422. For "alert if a flow takes too long" on OSS, use a proactive `EventTrigger` (`after={prefect.flow-run.Running}`, terminal states in `expect`, SLO in `within`).
+- **Automation schemas must read values this version doesn't know.** Cloud can add action types and metric names before a client release knows about them, so unknown actions parse as `UnknownAction` and unknown metric names stay `str` in `MetricTriggerQuery.name`. Code that reads automations must handle these variants (e.g. no `.value` on a metric name without an `isinstance` check), and `prefect transfer` skips automations that use them instead of copying them.
 - **Event name prefixes differ by backend.** OSS emits `prefect.*`; Cloud emits `prefect-cloud.*` for automation/action lifecycle events (e.g., `prefect-cloud.automation.triggered`). Cross-backend tooling that filters events must match both.
 - `DeploymentTriggerTypes` are the subset of triggers usable in `prefect.yaml` deployment definitions.
 

{prefect_client-3.9.1.dev3 → prefect_client-3.9.1.dev5}/src/prefect/events/schemas/automations.py

@@ -290,9 +290,16 @@ class MetricTriggerQuery(PrefectBaseModel):
     to Metric automations, that specify the query configurations
     and breaching conditions for the Automation"""
 
-    name: PrefectMetric = Field(
+    # Prefect Cloud can add metrics before a client release knows about them.
+    # Reading an automation that uses one keeps its name as a string instead of
+    # failing, so updating the automation sends the name back unchanged.
+    name: Union[PrefectMetric, str] = Field(
         ...,
-        description="The name of the metric to query.",
+        union_mode="left_to_right",
+        description=(
+            "The name of the metric to query. Names this version of Prefect does "
+            "not recognize are kept as strings."
+        ),
     )
     threshold: float = Field(
         ...,
@@ -357,7 +364,8 @@ class MetricTrigger(ResourceTrigger):
         return textwrap.indent(
             "\n".join(
                 [
-                    f"Metric: {m.name.value} {m.operator.value} {m.threshold} for {m.range}",
+                    f"Metric: {m.name.value if isinstance(m.name, PrefectMetric) else m.name} "
+                    f"{m.operator.value} {m.threshold} for {m.range}",
                 ]
             ),
             prefix="  " * indent,

{prefect_client-3.9.1.dev3 → prefect_client-3.9.1.dev5}/src/prefect/events/schemas/events.py

@@ -31,6 +31,7 @@ from prefect.logging import get_logger
 from prefect.settings import (
     PREFECT_EVENTS_MAXIMUM_LABELS_PER_RESOURCE,
 )
+from prefect.utilities.urls import url_for
 
 from .labelling import Labelled
 
@@ -194,6 +195,12 @@ class ReceivedEvent(Event):
         description="When the event was received by Prefect Cloud",
     )
 
+    @property
+    def url(self) -> Optional[str]:
+        """Returns the UI URL for this event, allowing users to link to events
+        in automation templates without parsing date strings."""
+        return url_for(self, url_type="ui")
+
 
 def matches(expected: str, value: Optional[str]) -> bool:
     """Returns true if the given value matches the expected string, which may

{prefect_client-3.9.1.dev3 → prefect_client-3.9.1.dev5}/src/prefect/infrastructure/provisioners/ecs.py

@@ -1005,7 +1005,25 @@ class ExecutionRoleResource:
                 ],
             }
         )
-        self._requires_provisioning = None
+        # `AmazonECSTaskExecutionRolePolicy` allows creating log streams and
+        # putting log events, but not creating the log group that the ECS worker
+        # asks for with `awslogs-create-group` when CloudWatch logs are enabled.
+        self._logs_policy_name = "PrefectEcsTaskExecutionRoleLogsPolicy"
+        self._logs_policy_document = json.dumps(
+            {
+                "Version": "2012-10-17",
+                "Statement": [
+                    {
+                        "Sid": "AllowCreateLogGroup",
+                        "Effect": "Allow",
+                        "Action": "logs:CreateLogGroup",
+                        "Resource": "*",
+                    }
+                ],
+            }
+        )
+        self._requires_role_provisioning = None
+        self._requires_logs_policy_provisioning = None
 
     async def get_task_count(self) -> int:
         """
@@ -1014,27 +1032,58 @@ class ExecutionRoleResource:
         Returns:
             int: The number of tasks to be provisioned.
         """
-        return 1 if await self.requires_provisioning() else 0
-
-    async def requires_provisioning(self) -> bool:
-        """
-        Check if this resource requires provisioning.
+        role_count = 1 if await self._role_requires_provisioning() else 0
+        logs_policy_count = 1 if await self._logs_policy_requires_provisioning() else 0
+        return role_count + logs_policy_count
 
-        Returns:
-            bool: True if provisioning is required, False otherwise.
-        """
-        if self._requires_provisioning is None:
+    async def _role_requires_provisioning(self) -> bool:
+        if self._requires_role_provisioning is None:
             try:
                 await anyio.to_thread.run_sync(
                     partial(
                         self._iam_client.get_role, RoleName=self._execution_role_name
                     )
                 )
-                self._requires_provisioning = False
+                self._requires_role_provisioning = False
             except self._iam_client.exceptions.NoSuchEntityException:
-                self._requires_provisioning = True
+                self._requires_role_provisioning = True
 
-        return self._requires_provisioning
+        return self._requires_role_provisioning
+
+    async def _logs_policy_requires_provisioning(self) -> bool:
+        """
+        Checked separately from role creation so that roles provisioned before
+        the logs policy existed get it when provisioning is run again.
+        """
+        if self._requires_logs_policy_provisioning is None:
+            if await self._role_requires_provisioning():
+                self._requires_logs_policy_provisioning = True
+            else:
+                try:
+                    await anyio.to_thread.run_sync(
+                        partial(
+                            self._iam_client.get_role_policy,
+                            RoleName=self._execution_role_name,
+                            PolicyName=self._logs_policy_name,
+                        )
+                    )
+                    self._requires_logs_policy_provisioning = False
+                except self._iam_client.exceptions.NoSuchEntityException:
+                    self._requires_logs_policy_provisioning = True
+
+        return self._requires_logs_policy_provisioning
+
+    async def requires_provisioning(self) -> bool:
+        """
+        Check if this resource requires provisioning.
+
+        Returns:
+            bool: True if provisioning is required, False otherwise.
+        """
+        return (
+            await self._role_requires_provisioning()
+            or await self._logs_policy_requires_provisioning()
+        )
 
     async def get_planned_actions(self) -> List[str]:
         """
@@ -1044,12 +1093,18 @@ class ExecutionRoleResource:
             Optional[str]: A description of the planned actions for provisioning the resource,
                 or None if provisioning is not required.
         """
-        if await self.requires_provisioning():
-            return [
+        actions: list[str] = []
+        if await self._role_requires_provisioning():
+            actions.append(
                 "Creating an IAM role assigned to ECS tasks:"
                 f" [blue]{self._execution_role_name}[/]"
-            ]
-        return []
+            )
+        if await self._logs_policy_requires_provisioning():
+            actions.append(
+                "Allowing the ECS task execution role to create CloudWatch log"
+                f" groups: [blue]{self._logs_policy_name}[/]"
+            )
+        return actions
 
     async def provision(
         self,
@@ -1064,8 +1119,8 @@ class ExecutionRoleResource:
                 infrastructure for.
             advance: A callback function to indicate progress.
         """
-        if await self.requires_provisioning():
-            console = current_console.get()
+        console = current_console.get()
+        if await self._role_requires_provisioning():
             console.print("Provisioning execution role")
             response = await anyio.to_thread.run_sync(
                 partial(
@@ -1088,6 +1143,18 @@ class ExecutionRoleResource:
                 partial(self._iam_client.get_role, RoleName=self._execution_role_name)
             )
 
+        if await self._logs_policy_requires_provisioning():
+            console.print("Adding CloudWatch logs policy to execution role")
+            await anyio.to_thread.run_sync(
+                partial(
+                    self._iam_client.put_role_policy,
+                    RoleName=self._execution_role_name,
+                    PolicyName=self._logs_policy_name,
+                    PolicyDocument=self._logs_policy_document,
+                )
+            )
+            advance()
+
         base_job_template["variables"]["properties"]["execution_role_arn"][
             "default"
         ] = response["Role"]["Arn"]

{prefect_client-3.9.1.dev3 → prefect_client-3.9.1.dev5}/src/prefect/runner/runner.py

@@ -527,9 +527,15 @@ class Runner:
         Gracefully shuts down the runner when a SIGTERM is received.
         """
         self._logger.info("SIGTERM received, initiating graceful shutdown...")
-        self.stop()
+        if not self.started or self.stopping or self._loop is None:
+            sys.exit(0)
 
-        sys.exit(0)
+        # Signal handlers run on the main thread, which may or may not be the
+        # thread driving the runner's loop, so schedule `astop` thread-safely
+        # rather than blocking on it. `astop` cancels in-flight flow runs and
+        # the polling loops, letting `start` return.
+        self.stopping = True
+        self.execute_in_background(self.astop)
 
     async def start(
         self, run_once: bool = False, webserver: Optional[bool] = None
@@ -714,9 +720,9 @@ class Runner:
         6. FlowRunCancellingObserver — exits first
         """
         self._logger.debug("Starting runner...")
+        self.stopping = False
         self._tmp_dir.mkdir(parents=True, exist_ok=True)
-        if not self._loop:
-            self._loop = asyncio.get_event_loop()
+        self._loop = asyncio.get_running_loop()
 
         self._client = get_client()
 

{prefect_client-3.9.1.dev3 → prefect_client-3.9.1.dev5}/src/prefect/runner/storage.py

@@ -497,16 +497,27 @@ class GitRepository:
 
                 await self._checkout_commit(self._commit_sha)
 
-            # Otherwise, pull the latest changes from the branch
+            # Otherwise, move the branch to the remote tip. `git pull` can't do
+            # this on a shallow clone: a new remote commit shares no history with
+            # the local one, so the merge fails on every update. Like `git pull`,
+            # `reset --keep` leaves local changes alone when nothing changed
+            # upstream and refuses when they would be overwritten.
             else:
-                cmd += ["pull", "origin"]
+                fetch_cmd = cmd + ["fetch", "origin"]
                 if self._branch:
-                    cmd += [self._branch]
-                if self._include_submodules:
-                    cmd += ["--recurse-submodules"]
-                cmd += ["--depth", "1"]
+                    fetch_cmd += [self._branch]
+                fetch_cmd += ["--depth", "1"]
                 try:
-                    await run_process(cmd, cwd=self.destination)
+                    await run_process(fetch_cmd, cwd=self.destination)
+                    await run_process(
+                        ["git", "reset", "--keep", "FETCH_HEAD"],
+                        cwd=self.destination,
+                    )
+                    if self._include_submodules:
+                        await run_process(
+                            cmd + ["submodule", "update", "--init", "--recursive"],
+                            cwd=self.destination,
+                        )
                     self._logger.debug("Successfully pulled latest changes")
                 except subprocess.CalledProcessError as exc:
                     self._logger.error(

{prefect_client-3.9.1.dev3 → prefect_client-3.9.1.dev5}/src/prefect/server/api/background_workers.py

@@ -63,25 +63,31 @@ async def background_worker(
     webserver_only: bool = False,
 ) -> AsyncGenerator[None, None]:
     worker_task: asyncio.Task[None] | None = None
-    async with Worker(docket) as worker:
-        # Register background task functions
-        docket.register_collection(
-            "prefect.server.api.background_workers:task_functions"
-        )
+    try:
+        async with Worker(docket) as worker:
+            # Register background task functions
+            docket.register_collection(
+                "prefect.server.api.background_workers:task_functions"
+            )
 
-        # Register and schedule enabled perpetual services
-        await register_and_schedule_perpetual_services(
-            docket, ephemeral=ephemeral, webserver_only=webserver_only
-        )
+            # Register and schedule enabled perpetual services
+            await register_and_schedule_perpetual_services(
+                docket, ephemeral=ephemeral, webserver_only=webserver_only
+            )
 
-        try:
-            worker_task = asyncio.create_task(worker.run_forever())
-            yield
+            try:
+                worker_task = asyncio.create_task(worker.run_forever())
+                yield
 
-        finally:
-            if worker_task:
-                worker_task.cancel()
-                try:
-                    await worker_task
-                except asyncio.CancelledError:
-                    pass
+            finally:
+                if worker_task:
+                    worker_task.cancel()
+    finally:
+        # Exiting the `Worker` context above signals the worker loop to stop and
+        # waits for it, so shutdown completes even if the cancellation was lost
+        # (e.g. `asyncio.wait_for` on Python 3.11 can swallow a cancellation).
+        if worker_task:
+            try:
+                await worker_task
+            except asyncio.CancelledError:
+                pass

{prefect_client-3.9.1.dev3 → prefect_client-3.9.1.dev5}/src/prefect/server/api/clients.py

@@ -1,13 +1,22 @@
 from __future__ import annotations
 
 import base64
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+import contextvars
+from contextlib import asynccontextmanager
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    AsyncIterator,
+    Dict,
+    List,
+    Optional,
+)
 from urllib.parse import quote
 from uuid import UUID
 
 import httpx
 import pydantic
-from httpx import Response
+from httpx import Request, Response
 from starlette import status
 from typing_extensions import Self
 
@@ -27,6 +36,29 @@ if TYPE_CHECKING:
 logger: "logging.Logger" = get_logger(__name__)
 
 
+_request_scoped_headers: contextvars.ContextVar[Optional[Dict[str, str]]] = (
+    contextvars.ContextVar("_request_scoped_headers", default=None)
+)
+
+
+async def _apply_scoped_headers(request: Request) -> None:
+    extras = _request_scoped_headers.get()
+    if not extras:
+        return
+    for name, value in extras.items():
+        request.headers[name] = value
+
+
+@asynccontextmanager
+async def scoped_headers(headers: Dict[str, str]) -> AsyncIterator[None]:
+    """Attach headers to every request sent by a shared client in this scope."""
+    token = _request_scoped_headers.set(headers)
+    try:
+        yield
+    finally:
+        _request_scoped_headers.reset(token)
+
+
 class BaseClient:
     _http_client: PrefectHttpxAsyncClient
 
@@ -53,6 +85,7 @@ class BaseClient:
             base_url=f"http://prefect-in-memory{settings.server.api.base_path or '/api'}",
             enable_csrf_support=settings.server.api.csrf_protection_enabled,
             raise_on_all_errors=False,
+            event_hooks={"request": [_apply_scoped_headers]},
         )
 
     async def __aenter__(self) -> Self:

{prefect_client-3.9.1.dev3 → prefect_client-3.9.1.dev5}/src/prefect/server/api/ui/flow_runs.py

@@ -119,7 +119,7 @@ async def count_task_runs_by_flow_run(
         results = await session.execute(query)
 
         task_run_counts_by_flow_run = {
-            flow_run_id: task_run_count for flow_run_id, task_run_count in results.t
+            flow_run_id: task_run_count for flow_run_id, task_run_count in results
         }
 
         return {