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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: prefect-client
-Version: 3.9.1.dev3
+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

{prefect_client-3.9.1.dev3 → 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 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.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.dev3 → 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.dev3 → 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.dev3 → 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.dev3 → 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.dev3 → 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.dev3 → 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.dev3 → 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.dev3 → 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.dev3 → 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())

{prefect_client-3.9.1.dev3 → prefect_client-3.9.1.dev4}/src/prefect/types/_datetime.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import datetime
 import sys
 from contextlib import contextmanager
+from functools import cache
 from typing import Annotated, Any, Union, cast
 from unittest import mock
 from zoneinfo import ZoneInfo, ZoneInfoNotFoundError, available_timezones
@@ -127,6 +128,7 @@ def parse_datetime(dt: str) -> datetime.datetime:
         return cast(datetime.datetime, _wrap_pendulum_value(pendulum.parse(dt)))
 
 
+@cache
 def get_timezones() -> tuple[str, ...]:
     return tuple(available_timezones())
 

{prefect_client-3.9.1.dev3 → prefect_client-3.9.1.dev4}/src/prefect/utilities/templating/AGENTS.md

@@ -18,3 +18,4 @@ Note: this module is *not* a Jinja renderer. For Jinja hydration of `__prefect_k
 
 - **`resolve_block_document_references` raises `ValueError` for malformed block placeholders.** Placeholders must follow the format `prefect.blocks.<block-type-slug>.<block-document-name>` (at least two dot-separated parts after the prefix). A placeholder like `{{ prefect.blocks.only-type }}` (missing the document name) raises `ValueError` before any network call is made.
 - **Inline vs. whole-string block resolution behave differently.** When a block placeholder is the *entire* string value (`"{{ prefect.blocks.secret.my-token }}"`), the resolved value is returned as-is — it can be a `dict`, `list`, or scalar. When a block placeholder is *embedded* in surrounding text (`"{{ prefect.blocks.secret.my-token }}/my-image"`), the value is coerced to `str`; if it resolves to a `dict` or `list`, a `ValueError` is raised. A template string can mix block placeholders and standard `{{ variable }}` placeholders — non-block placeholders are left intact for later resolution.
+- **Keep dict/list `NotSet` handling in sync.** Changes to unresolved-value handling in either branch of `apply_values` must be mirrored in the other. See the multi-pass caller contract in `src/prefect/AGENTS.md`.

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

@@ -1,5 +0,0 @@
-# Generated by versioningit
-__version__ = "3.9.1.dev3"
-__build_date__ = "2026-10-24 08:17:11.725751+00:00"
-__git_commit__ = "f1f98c3f2468ef5af3992db9439a2ead26c9e27e"
-__dirty__ = False