prefect-client 3.9.1.dev2__tar.gz → 3.9.1.dev4__tar.gz

{prefect_client-3.9.1.dev2 → prefect_client-3.9.1.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: prefect-client
-Version: 3.9.1.dev2
+Version: 3.9.1.dev4
 Summary: Workflow orchestration and management.
 Project-URL: Changelog, https://github.com/PrefectHQ/prefect/releases
 Project-URL: Documentation, https://docs.prefect.io
@@ -50,7 +50,7 @@ Requires-Dist: pydantic-core<3.0.0,>=2.12.0
 Requires-Dist: pydantic-extra-types<3.0.0,>=2.8.2
 Requires-Dist: pydantic-settings<3.0.0,>=2.9.1
 Requires-Dist: python-dateutil<3.0.0,>=2.8.2
-Requires-Dist: python-slugify<9.1,>=9
+Requires-Dist: python-slugify<9.2,>=9
 Requires-Dist: pytz<2027,>=2021.1
 Requires-Dist: pyyaml<7.0.0,>=5.4.1
 Requires-Dist: rfc3339-validator<0.2.0,>=0.1.4
@@ -62,9 +62,9 @@ Requires-Dist: toml>=0.10.0
 Requires-Dist: typing-extensions<5.0.0,>=4.10.0
 Requires-Dist: uvicorn!=0.29.0,>=0.14.0
 Requires-Dist: websockets<17.0,>=15.0.1
-Requires-Dist: whenever<0.11.0,>=0.10.5; python_version >= '3.13'
+Requires-Dist: whenever<0.12.0,>=0.10.5; python_version >= '3.13'
 Provides-Extra: notifications
-Requires-Dist: apprise<2.0.0,>=1.13.0; extra == 'notifications'
+Requires-Dist: apprise<2.1.0,>=1.13.0; extra == 'notifications'
 Description-Content-Type: text/markdown
 
 <p align="center"><img src="https://github.com/PrefectHQ/prefect/assets/3407835/c654cbc6-63e8-4ada-a92a-efd2f8f24b85" width=1000></p>

{prefect_client-3.9.1.dev2 → prefect_client-3.9.1.dev4}/pyproject.toml

@@ -55,7 +55,7 @@ dependencies = [
     "pydantic_extra_types>=2.8.2,<3.0.0",
     "pydantic_settings>=2.9.1,<3.0.0",
     "python-dateutil>=2.8.2,<3.0.0",
-    "python-slugify>=9,<9.1",
+    "python-slugify>=9,<9.2",
     "pytz>=2021.1,<2027",
     "pyyaml>=5.4.1,<7.0.0",
     "rfc3339-validator>=0.1.4,<0.2.0",
@@ -67,7 +67,7 @@ dependencies = [
     "typing_extensions>=4.10.0,<5.0.0",
     "uvicorn>=0.14.0,!=0.29.0",
     "websockets>=15.0.1,<17.0",
-    "whenever>=0.10.5,<0.11.0; python_version>='3.13'",
+    "whenever>=0.10.5,<0.12.0; python_version>='3.13'",
 ]
 [project.urls]
 Changelog = "https://github.com/PrefectHQ/prefect/releases"
@@ -75,7 +75,7 @@ Documentation = "https://docs.prefect.io"
 Source = "https://github.com/PrefectHQ/prefect"
 Tracker = "https://github.com/PrefectHQ/prefect/issues"
 [project.optional-dependencies]
-notifications = ["apprise>=1.13.0, <2.0.0"]
+notifications = ["apprise>=1.13.0, <2.1.0"]
 
 
 [tool.hatch.version]

{prefect_client-3.9.1.dev2 → prefect_client-3.9.1.dev4}/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 between whenever 0.7.x–0.9.x and ≥ 0.10.0. The `_WHENEVER_NEW_API` flag (True when whenever ≥ 0.10.0) guards version-specific code. 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. 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.dev4/src/prefect/_build_info.py

@@ -0,0 +1,5 @@
+# Generated by versioningit
+__version__ = "3.9.1.dev4"
+__build_date__ = "2026-10-25 08:17:20.425573+00:00"
+__git_commit__ = "7257ae44f0246277f4f5083ef3bb98ed7ef3fa61"
+__dirty__ = False

{prefect_client-3.9.1.dev2 → prefect_client-3.9.1.dev4}/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.dev2 → prefect_client-3.9.1.dev4}/src/prefect/blocks/notifications.py

@@ -47,7 +47,7 @@ class AbstractAppriseNotificationBlock(NotificationBlock, ABC):
         )
 
         self._apprise_client = Apprise(asset=prefect_app_data)
-        self._apprise_client.add(servers=url.get_secret_value())  # pyright: ignore[reportUnknownMemberType]
+        self._apprise_client.add(url.get_secret_value())  # pyright: ignore[reportUnknownMemberType]
 
     def block_initialization(self) -> None:
         self._start_apprise_client(getattr(self, "url"))
@@ -1115,9 +1115,7 @@ class SendgridEmail(AbstractAppriseNotificationBlock):
         """Update apprise client with current to_emails before sending."""
         if hasattr(self, "_apprise_client") and self._apprise_client:
             self._apprise_client.clear()
-            self._apprise_client.add(
-                servers=self._build_sendgrid_url().get_secret_value()
-            )
+            self._apprise_client.add(self._build_sendgrid_url().get_secret_value())
 
     async def anotify(
         self,

{prefect_client-3.9.1.dev2 → prefect_client-3.9.1.dev4}/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.dev2 → prefect_client-3.9.1.dev4}/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.dev2 → prefect_client-3.9.1.dev4}/src/prefect/flow_engine.py

@@ -811,7 +811,16 @@ class FlowRunEngine(BaseFlowRunEngine[P, R]):
         )
         raise_if_flow_run_suspension_requested()
         self._return_value = resolved_result
-        self.set_state(terminal_state)
+        state = self.set_state(terminal_state)
+        if terminal_state.is_failed() and state.is_scheduled():
+            self.logger.info(
+                f"Received non-final state {state.name!r} when proposing final"
+                f" state {terminal_state.name!r} and will attempt to run again..."
+            )
+            raise_if_flow_run_suspension_requested()
+            self._return_value = NotSet
+            self.set_state(Running())
+            return result
 
         link_state_to_flow_run_result(terminal_state, resolved_result)
         self._telemetry.end_span_on_success()
@@ -1534,7 +1543,16 @@ class AsyncFlowRunEngine(BaseFlowRunEngine[P, R]):
         )
         raise_if_flow_run_suspension_requested()
         self._return_value = resolved_result
-        await self.set_state(terminal_state)
+        state = await self.set_state(terminal_state)
+        if terminal_state.is_failed() and state.is_scheduled():
+            self.logger.info(
+                f"Received non-final state {state.name!r} when proposing final"
+                f" state {terminal_state.name!r} and will attempt to run again..."
+            )
+            raise_if_flow_run_suspension_requested()
+            self._return_value = NotSet
+            await self.set_state(Running())
+            return result
 
         self._telemetry.end_span_on_success()
 

{prefect_client-3.9.1.dev2 → prefect_client-3.9.1.dev4}/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.dev2 → prefect_client-3.9.1.dev4}/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.dev2 → prefect_client-3.9.1.dev4}/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.dev2 → prefect_client-3.9.1.dev4}/src/prefect/server/api/__init__.py

@@ -24,6 +24,7 @@ if TYPE_CHECKING:
         flows,
         logs,
         middleware,
+        observed_states,
         root,
         run_history,
         saved_searches,
@@ -58,6 +59,7 @@ __all__ = [
     "flows",
     "logs",
     "middleware",
+    "observed_states",
     "root",
     "run_history",
     "saved_searches",

{prefect_client-3.9.1.dev2 → prefect_client-3.9.1.dev4}/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.dev4/src/prefect/server/api/observed_states.py

@@ -0,0 +1,32 @@
+"""Routes for discovering observed state types and names."""
+
+from typing import Annotated
+
+from fastapi import Depends, Query
+
+from prefect.server import models
+from prefect.server.database import PrefectDBInterface, provide_database_interface
+from prefect.server.schemas.observed_states import ObservedState, ObservedStateSort
+from prefect.server.utilities.server import PrefectRouter
+
+router: PrefectRouter = PrefectRouter(
+    prefix="/observed-states", tags=["Observed States"]
+)
+
+
+@router.get("")
+async def read_observed_states(
+    db: Annotated[PrefectDBInterface, Depends(provide_database_interface)],
+    query: Annotated[str | None, Query(max_length=100)] = None,
+    order_by: ObservedStateSort = ObservedStateSort.LAST_SEEN_DESC,
+    limit: Annotated[int, Query(ge=1, le=200)] = 200,
+) -> list[ObservedState]:
+    """Discover exact state names and types from retained run transitions.
+
+    Search by case-insensitive name or type prefix. Timestamps describe retained
+    history; deleting runs can change them or remove a state from the results.
+    """
+    async with db.session_context() as session:
+        return await models.observed_states.read_observed_states(
+            session=session, query=query, order_by=order_by, limit=limit
+        )

{prefect_client-3.9.1.dev2 → prefect_client-3.9.1.dev4}/src/prefect/server/api/server.py

@@ -105,6 +105,7 @@ API_ROUTERS = (
     api.task_runs.router,
     api.flow_run_states.router,
     api.task_run_states.router,
+    api.observed_states.router,
     api.deployments.router,
     api.saved_searches.router,
     api.logs.router,

{prefect_client-3.9.1.dev2 → prefect_client-3.9.1.dev4}/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 {

{prefect_client-3.9.1.dev2 → prefect_client-3.9.1.dev4}/src/prefect/task_runners.py

@@ -40,6 +40,7 @@ from prefect.futures import (
 from prefect.logging.handlers import APILogWorker, set_api_log_sink
 from prefect.logging.loggers import get_logger, get_run_logger
 from prefect.settings.context import get_current_settings
+from prefect.settings.models.root import Settings
 from prefect.utilities.annotations import allow_failure, opaque, quote, unmapped
 from prefect.utilities.callables import (
     cloudpickle_wrapped_call,
@@ -607,13 +608,23 @@ def _run_task_in_subprocess(
     """
     Wrapper function to update environment variables and settings before running a task in a subprocess.
     """
+    # Apply this task's environment and restore the worker's environment
+    # afterwards so values from one task's settings do not leak into later
+    # tasks run by the same worker process.
+    original_environ = os.environ.copy()
+    os.environ.update(env or {})
+    try:
+        return _run_task_with_hydrated_context(*args, **kwargs)
+    finally:
+        os.environ.clear()
+        os.environ.update(original_environ)
+
+
+def _run_task_with_hydrated_context(*args: Any, **kwargs: Any) -> Any:
     from prefect.context import hydrated_context
     from prefect.engine import handle_engine_signals
     from prefect.task_engine import run_task_async, run_task_sync
 
-    # Update environment variables
-    os.environ.update(env or {})
-
     # Extract context from kwargs
     context = kwargs.pop("context", None)
 
@@ -871,8 +882,8 @@ class ProcessPoolTaskRunner(TaskRunner[PrefectConcurrentFuture[Any]]):
         self._subprocess_message_processor_factories: tuple[
             _SubprocessMessageProcessorFactory, ...
         ] = tuple(subprocess_message_processor_factories or ())
-        self._cached_context: dict[str, Any] | None = None
         self._cached_env: dict[str, str] | None = None
+        self._cached_env_settings: Settings | None = None
 
     def duplicate(self) -> Self:
         duplicate_runner = type(self)(max_workers=self._max_workers)
@@ -1201,16 +1212,21 @@ class ProcessPoolTaskRunner(TaskRunner[PrefectConcurrentFuture[Any]]):
                 f"Submitting task {task.name} to process pool executor..."
             )
 
-        # Serialize the current context for the subprocess (cached per runner lifecycle)
-        if self._cached_context is None:
-            from prefect.context import serialize_context
+        from prefect.context import serialize_context
 
-            self._cached_context = serialize_context()
+        # Context (tags, settings, etc.) can change between submits, so it is
+        # serialized every time. The env is only rebuilt when settings change.
+        context = serialize_context()
+        current_settings = get_current_settings()
+        if (
+            self._cached_env is None
+            or self._cached_env_settings is not current_settings
+        ):
             self._cached_env = (
-                get_current_settings().to_environment_variables(exclude_unset=True)
+                current_settings.to_environment_variables(exclude_unset=True)
                 | os.environ
             )
-        context = self._cached_context
+            self._cached_env_settings = current_settings
         env = self._cached_env
 
         # Submit the resolution and subprocess execution to a background thread
@@ -1261,9 +1277,9 @@ class ProcessPoolTaskRunner(TaskRunner[PrefectConcurrentFuture[Any]]):
         return super().map(task, parameters, wait_for)
 
     def cancel_all(self) -> None:
-        # Invalidate cached context and env so they are recomputed on next start
-        self._cached_context = None
+        # Invalidate cached env so it is recomputed on next start
         self._cached_env = None
+        self._cached_env_settings = None
 
         # Clear cancel events first to avoid resource tracking issues
         events_to_set = list(self._cancel_events.values())