prefect-client 3.9.2.dev4__tar.gz → 3.9.2.dev6__tar.gz

{prefect_client-3.9.2.dev4 → prefect_client-3.9.2.dev6}/PKG-INFO

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

{prefect_client-3.9.2.dev4 → prefect_client-3.9.2.dev6}/src/prefect/AGENTS.md

@@ -41,6 +41,7 @@ Runtime flow/task parameter values must come from `utilities.callables.get_call_
 - **`ResultRecordMetadata` tolerates unknown serializer types.** When loading persisted metadata, an unrecognized serializer `type` is converted to an `UnknownSerializer` placeholder rather than raising `ValidationError`. This allows inspecting result metadata when the serializer implementation is unavailable in the current environment. However, known serializer types with invalid fields still raise `ValidationError`. `UnknownSerializer.dumps()` and `UnknownSerializer.loads()` raise `RuntimeError` — the tolerance is for inspection only, not actual serialization/deserialization.
 - **`ResultRecord` must be marked persisted after every storage write.** `ResultStore` calls `mark_persisted()` on every record it writes; `to_state_create` in `states.py` consults `is_persisted` as a fallback when `should_persist_result()` returns `False` (e.g., after run context teardown). Any new sync or async persist path that omits `mark_persisted()` will silently drop state metadata for already-written results.
 - **Flow-run suspension is enforced at orchestration boundaries.** Suspension is delivered via `FlowRunSuspensionRequest` and raised with `raise_if_flow_run_suspension_requested()`. When changing engines, futures, task runners, or generator execution, check before returning control to flow user code or proposing a flow state that could leave `Suspended`; keep sync/async paths aligned and avoid per-boundary API reads.
+- **Flow state hooks accept the same signatures on every execution path.** The sync and async flow engines and `runner/_hook_runner.py` share `_internal/engine.py::resolve_flow_hook_arguments`; `runner/_workspace_runtime_bootstrap.py` keeps its own copy because it may run under an older Prefect. Change the shared function and the copy together.
 - **Subflow tracking tasks use UUID dynamic keys when called from within a submitted task.** `flow_engine.py` marks the synthetic tracking `Task` with `_is_subflow_tracking_task=True`; `tasks.py` checks this flag to assign UUID-based (unstable) `dynamic_key` values when the tracking task runs inside a submitted task context. This prevents key collisions between concurrent sibling subflows on parent-flow retry. Direct subflow calls (no enclosing task context) keep stable sequential keys to preserve the retry optimization that reuses completed subflow results.
 
 ## Logging

prefect_client-3.9.2.dev6/src/prefect/_build_info.py

@@ -0,0 +1,5 @@
+# Generated by versioningit
+__version__ = "3.9.2.dev6"
+__build_date__ = "2026-11-06 08:12:53.240258+00:00"
+__git_commit__ = "802fc9435423bed0d16fe30862de25a8df62493f"
+__dirty__ = False

{prefect_client-3.9.2.dev4 → prefect_client-3.9.2.dev6}/src/prefect/_internal/engine.py

@@ -1,5 +1,6 @@
 """Internal engine utilities"""
 
+import inspect
 from collections.abc import Callable
 from functools import partial
 from typing import TYPE_CHECKING, Any, Union
@@ -9,6 +10,9 @@ from prefect.context import FlowRunContext
 from prefect.flows import Flow
 from prefect.tasks import Task, TaskRunNameCallbackWithParameters
 
+if TYPE_CHECKING:
+    from prefect.client.schemas.objects import FlowRun, State
+
 
 def dynamic_key_for_task_run(
     context: FlowRunContext, task: "Task[..., Any]", stable: bool = True
@@ -93,3 +97,58 @@ def get_hook_name(hook: Callable[..., Any]) -> str:
             hook.func.__name__ if isinstance(hook, partial) else hook.__class__.__name__
         )
     )
+
+
+def resolve_flow_hook_arguments(
+    hook: Callable[..., Any],
+    flow: "Flow[..., Any]",
+    flow_run: "FlowRun",
+    state: "State",
+) -> tuple[tuple[Any, ...], dict[str, Any]]:
+    """
+    Return the positional and keyword arguments to call a flow state hook with,
+    checking its signature without calling it.
+
+    A hook that names its parameters `flow`, `flow_run` (or `run`) and `state`
+    gets them by name, in any order and including keyword-only parameters.
+    Otherwise, a hook that takes three positional arguments gets them in that
+    order, whatever their names, and a hook that only takes keyword arguments
+    gets them by name.
+
+    Raises:
+        TypeError: if the hook accepts none of these forms.
+    """
+    try:
+        signature = inspect.signature(hook)
+    except (TypeError, ValueError):
+        return (flow, flow_run, state), {}
+
+    def binds(*args: Any, **kwargs: Any) -> bool:
+        try:
+            signature.bind(*args, **kwargs)
+        except TypeError:
+            return False
+        return True
+
+    named = (inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.KEYWORD_ONLY)
+    for flow_run_name in ("flow_run", "run"):
+        kwargs = {"flow": flow, flow_run_name: flow_run, "state": state}
+        declared = all(
+            name in signature.parameters and signature.parameters[name].kind in named
+            for name in kwargs
+        )
+        if declared and binds(**kwargs):
+            return (), kwargs
+
+    if binds(flow, flow_run, state):
+        return (flow, flow_run, state), {}
+
+    kwargs = {"flow": flow, "flow_run": flow_run, "state": state}
+    if binds(**kwargs):
+        return (), kwargs
+
+    raise TypeError(
+        f"Hook {get_hook_name(hook)!r} must accept the flow, the flow run and the"
+        " state as three positional arguments or as parameters named `flow`,"
+        " `flow_run` (or `run`) and `state`"
+    )

{prefect_client-3.9.2.dev4 → prefect_client-3.9.2.dev6}/src/prefect/client/schemas/objects.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import datetime
+import json
 import warnings
 from collections.abc import Callable, Mapping
 from enum import Enum
@@ -17,7 +18,6 @@ from typing import (
 )
 from uuid import UUID
 
-import orjson
 from pydantic import (
     AfterValidator,
     ConfigDict,
@@ -1768,7 +1768,7 @@ class FlowRunInput(ObjectBaseModel):
         Returns:
             Any: the decoded value
         """
-        return orjson.loads(self.value)
+        return json.loads(self.value)
 
 
 class GlobalConcurrencyLimit(ObjectBaseModel):

{prefect_client-3.9.2.dev4 → prefect_client-3.9.2.dev6}/src/prefect/flow_engine.py

@@ -11,7 +11,7 @@ import signal
 import sys
 import threading
 import time
-from collections.abc import Mapping
+from collections.abc import Callable, Mapping
 from contextlib import (
     AsyncExitStack,
     ExitStack,
@@ -59,7 +59,11 @@ from prefect._internal.control_listener import (
     get_intent,
     report_engine_outcome,
 )
-from prefect._internal.engine import get_hook_name, resolve_custom_flow_run_name
+from prefect._internal.engine import (
+    get_hook_name,
+    resolve_custom_flow_run_name,
+    resolve_flow_hook_arguments,
+)
 from prefect._internal.metrics import RunMetrics
 from prefect.client.orchestration import PrefectClient, SyncPrefectClient, get_client
 from prefect.client.schemas import FlowRun, TaskRun
@@ -330,28 +334,40 @@ def _send_heartbeats(
     resource, related = engine._build_heartbeat_event_template()
 
     stop_event = threading.Event()
+    # The heartbeat thread checks for a stop and emits while holding this lock,
+    # so once `stop_heartbeats` returns, no heartbeat is mid-emit and none will
+    # be emitted.
+    emit_lock = threading.Lock()
 
-    def heartbeat_loop() -> None:
-        while not stop_event.is_set():
-            # Check state before emitting - don't emit if final
-            if (
-                engine.flow_run
-                and engine.flow_run.state
-                and engine.flow_run.state.is_final()
-            ):
-                engine.logger.debug("Flow run in terminal state, stopping heartbeat")
-                return
-
-            try:
-                engine._emit_flow_run_heartbeat(resource, related)
-            except Exception:
-                engine.logger.debug("Failed to emit heartbeat", exc_info=True)
+    def stop_heartbeats() -> None:
+        with emit_lock:
+            stop_event.set()
 
-            # Sleep in increments to allow quick shutdown
-            for _ in range(heartbeat_seconds):
+    def heartbeat_loop() -> None:
+        while True:
+            with emit_lock:
                 if stop_event.is_set():
                     return
-                time.sleep(1)
+
+                # Check state before emitting - don't emit if final
+                if (
+                    engine.flow_run
+                    and engine.flow_run.state
+                    and engine.flow_run.state.is_final()
+                ):
+                    engine.logger.debug(
+                        "Flow run in terminal state, stopping heartbeat"
+                    )
+                    return
+
+                try:
+                    engine._emit_flow_run_heartbeat(resource, related)
+                except Exception:
+                    engine.logger.debug("Failed to emit heartbeat", exc_info=True)
+
+            # Waiting on the event wakes the thread as soon as heartbeats stop
+            if stop_event.wait(heartbeat_seconds):
+                return
 
     # Copy the current context so the heartbeat thread sees the same
     # `SettingsContext` (and therefore the same `PREFECT_API_URL`) as the
@@ -366,13 +382,14 @@ def _send_heartbeats(
     thread = threading.Thread(
         target=heartbeat_ctx.run, args=(heartbeat_loop,), daemon=True
     )
+    engine._stop_heartbeats = stop_heartbeats
     thread.start()
     engine.logger.debug("Started flow run heartbeat context")
 
     try:
         yield
     finally:
-        stop_event.set()
+        stop_heartbeats()
         if join_on_exit:
             thread.join(timeout=2)
         engine.logger.debug("Stopped flow run heartbeat context")
@@ -424,6 +441,15 @@ class BaseFlowRunEngine(Generic[P, R]):
         default_factory=FlowRunSuspensionRequest
     )
     _attempt_conclusion: EngineOutcomeReceipt | None = field(default=None, init=False)
+    # Stops the heartbeat thread started by the most recent `_send_heartbeats`.
+    # `set_state` calls it before proposing a terminal state: the server
+    # timestamps that state when it accepts it, but the heartbeat thread sees
+    # it only after the response arrives.  A heartbeat sent in that gap occurs
+    # after the terminal state, and an automation that expects every heartbeat
+    # to be followed by another event then fires on the finished run.
+    _stop_heartbeats: Callable[[], None] | None = field(
+        default=None, init=False, repr=False
+    )
 
     def __post_init__(self) -> None:
         if self.flow is None and self.flow_run_id is None:
@@ -757,6 +783,9 @@ class FlowRunEngine(BaseFlowRunEngine[P, R]):
         if self.short_circuit:
             return self.state
 
+        if state.is_final() and self._stop_heartbeats is not None:
+            self._stop_heartbeats()
+
         state = propose_state_sync(
             self.client, state, flow_run_id=self.flow_run.id, force=force
         )  # type: ignore
@@ -1072,7 +1101,8 @@ class FlowRunEngine(BaseFlowRunEngine[P, R]):
                     f"Running hook {hook_name!r} in response to entering state"
                     f" {state.name!r}"
                 )
-                result = hook(flow, flow_run, state)
+                args, kwargs = resolve_flow_hook_arguments(hook, flow, flow_run, state)
+                result = hook(*args, **kwargs)
                 if asyncio.iscoroutine(result):
                     run_coro_as_sync(result)
             except Exception:
@@ -1495,6 +1525,9 @@ class AsyncFlowRunEngine(BaseFlowRunEngine[P, R]):
         if self.short_circuit:
             return self.state
 
+        if state.is_final() and self._stop_heartbeats is not None:
+            self._stop_heartbeats()
+
         state = await propose_state(
             self.client, state, flow_run_id=self.flow_run.id, force=force
         )  # type: ignore
@@ -1803,7 +1836,8 @@ class AsyncFlowRunEngine(BaseFlowRunEngine[P, R]):
                     f"Running hook {hook_name!r} in response to entering state"
                     f" {state.name!r}"
                 )
-                result = hook(flow, flow_run, state)
+                args, kwargs = resolve_flow_hook_arguments(hook, flow, flow_run, state)
+                result = hook(*args, **kwargs)
                 if asyncio.iscoroutine(result):
                     await result
             except Exception:

{prefect_client-3.9.2.dev4 → prefect_client-3.9.2.dev6}/src/prefect/flows.py

@@ -121,15 +121,22 @@ F = TypeVar("F", bound="Flow[Any, Any]")  # The type of the flow
 class FlowStateHook(Protocol, Generic[P, R]):
     """
     A callable that is invoked when a flow enters a given state.
+
+    It receives the flow, the flow run, and the state as its first three
+    parameters, whatever their names. A hook whose parameters are named `flow`,
+    `flow_run` (or `run`), and `state` receives them by name instead.
     """
 
     __name__: str
 
     def __call__(
-        self, flow: Flow[P, R], flow_run: FlowRun, state: State
+        self, flow: Flow[P, R], flow_run: FlowRun, state: State, /
     ) -> Awaitable[None] | None: ...
 
 
+_FlowStateHookT = TypeVar("_FlowStateHookT", bound="FlowStateHook[..., Any]")
+
+
 if TYPE_CHECKING:
     import logging
 
@@ -593,6 +600,11 @@ class Flow(Generic[P, R]):
         Validate parameters for compatibility with the flow by attempting to cast the inputs to the
         associated types specified by the function's type annotations.
 
+        Resolve saved block references by UUID or by a dictionary containing
+        `block_document_id` or `block_document_slug`. UUID strings, including UUID
+        URNs, retain their block-reference meaning. Other `$ref` values, such as
+        JSON Schema paths and URLs, are preserved as parameter data.
+
         Returns:
             A new dict of parameters that have been cast to the appropriate types
 
@@ -601,11 +613,24 @@ class Flow(Generic[P, R]):
         """
 
         def resolve_block_reference(data: Any | dict[str, Any]) -> Any:
-            if isinstance(data, dict) and "$ref" in data:
-                from prefect.blocks.core import Block
+            if not isinstance(data, dict) or "$ref" not in data:
+                return data
+
+            ref = data["$ref"]
+            if isinstance(ref, str):
+                try:
+                    UUID(ref)
+                except ValueError:
+                    return data
+            elif not isinstance(ref, UUID) and not (
+                isinstance(ref, dict)
+                and ("block_document_id" in ref or "block_document_slug" in ref)
+            ):
+                return data
+
+            from prefect.blocks.core import Block
 
-                return Block.load_from_ref(data["$ref"], _sync=True)
-            return data
+            return Block.load_from_ref(ref, _sync=True)
 
         try:
             parameters = visit_collection(
@@ -1004,23 +1029,23 @@ class Flow(Generic[P, R]):
                 _sla=_sla,
             )
 
-    def on_completion(self, fn: FlowStateHook[P, R]) -> FlowStateHook[P, R]:
+    def on_completion(self, fn: _FlowStateHookT) -> _FlowStateHookT:
         self.on_completion_hooks.append(fn)
         return fn
 
-    def on_cancellation(self, fn: FlowStateHook[P, R]) -> FlowStateHook[P, R]:
+    def on_cancellation(self, fn: _FlowStateHookT) -> _FlowStateHookT:
         self.on_cancellation_hooks.append(fn)
         return fn
 
-    def on_crashed(self, fn: FlowStateHook[P, R]) -> FlowStateHook[P, R]:
+    def on_crashed(self, fn: _FlowStateHookT) -> _FlowStateHookT:
         self.on_crashed_hooks.append(fn)
         return fn
 
-    def on_running(self, fn: FlowStateHook[P, R]) -> FlowStateHook[P, R]:
+    def on_running(self, fn: _FlowStateHookT) -> _FlowStateHookT:
         self.on_running_hooks.append(fn)
         return fn
 
-    def on_failure(self, fn: FlowStateHook[P, R]) -> FlowStateHook[P, R]:
+    def on_failure(self, fn: _FlowStateHookT) -> _FlowStateHookT:
         self.on_failure_hooks.append(fn)
         return fn
 

{prefect_client-3.9.2.dev4 → prefect_client-3.9.2.dev6}/src/prefect/infrastructure/provisioners/coiled.py

@@ -215,7 +215,7 @@ class CoiledPushProvisioner:
                 else:
                     raise RuntimeError(
                         "Coiled credentials not found. Please create a new token by"
-                        " running [blue]coiled login[/] and try again."
+                        " running `coiled login` and try again."
                     )
 
             # Create the credentials block

{prefect_client-3.9.2.dev4 → prefect_client-3.9.2.dev6}/src/prefect/infrastructure/provisioners/modal.py

@@ -220,7 +220,7 @@ class ModalPushProvisioner:
                 else:
                     raise RuntimeError(
                         "Modal credentials not found. Please create a new token by"
-                        " running [blue]modal token new[/] and try again."
+                        " running `modal token new` and try again."
                     )
 
             # Create the credentials block

{prefect_client-3.9.2.dev4 → prefect_client-3.9.2.dev6}/src/prefect/input/actions.py

@@ -1,3 +1,4 @@
+import json
 from typing import TYPE_CHECKING, Any, Optional, Set
 from uuid import UUID
 
@@ -236,7 +237,7 @@ async def aread_flow_run_input(
             return None
         raise
     else:
-        return orjson.loads(value)
+        return json.loads(value)
 
 
 @async_dispatch(aread_flow_run_input)
@@ -261,7 +262,7 @@ def read_flow_run_input(key: str, flow_run_id: Optional[UUID] = None) -> Any:
                 return None
             raise
         else:
-            return orjson.loads(value)
+            return json.loads(value)
 
 
 @client_injector

{prefect_client-3.9.2.dev4 → prefect_client-3.9.2.dev6}/src/prefect/locking/filesystem.py

@@ -194,13 +194,18 @@ class FileSystemLockManager(LockManager):
 
     def release_lock(self, key: str, holder: str) -> None:
         lock_path = self._lock_path_for_key(key)
-        if not self.is_locked(key):
-            raise ValueError(f"No lock for transaction with key {key}")
         if self.is_lock_holder(key, holder):
             Path(lock_path).unlink(missing_ok=True)
             self._locks.pop(key, None)
-        else:
-            raise ValueError(f"No lock held by {holder} for transaction with key {key}")
+            return
+        if not self.is_locked(key):
+            # The lock was already released or expired (e.g. its hold timeout
+            # elapsed or it was released during a task retry) — including
+            # between the checks above — so releasing it is a no-op, matching
+            # RedisLockManager.
+            self._locks.pop(key, None)
+            return
+        raise ValueError(f"No lock held by {holder} for transaction with key {key}")
 
     def is_locked(self, key: str, use_cache: bool = False) -> bool:
         if (lock_info := self._get_lock_info(key, use_cache=use_cache)) is None:

{prefect_client-3.9.2.dev4 → prefect_client-3.9.2.dev6}/src/prefect/locking/memory.py

@@ -180,13 +180,18 @@ class MemoryLockManager(LockManager):
 
     def release_lock(self, key: str, holder: str) -> None:
         with self._locks_dict_lock:
-            if key in self._locks and self._locks[key]["holder"] == holder:
-                if (
-                    expiration_timer := self._locks[key]["expiration_timer"]
-                ) is not None:
+            lock_info = self._locks.get(key)
+            if lock_info is not None and lock_info["holder"] == holder:
+                if (expiration_timer := lock_info["expiration_timer"]) is not None:
                     expiration_timer.cancel()
-                self._locks[key]["lock"].release()
+                if lock_info["lock"].locked():
+                    lock_info["lock"].release()
                 del self._locks[key]
+            elif lock_info is None or not lock_info["lock"].locked():
+                # The lock was already released or expired (e.g. its hold
+                # timeout elapsed or it was released during a task retry);
+                # releasing it is a no-op, matching RedisLockManager.
+                return
             else:
                 raise ValueError(
                     f"No lock held by {holder} for transaction with key {key}"

{prefect_client-3.9.2.dev4 → prefect_client-3.9.2.dev6}/src/prefect/locking/protocol.py

@@ -61,10 +61,16 @@ class LockManager(Protocol):
         """
         Releases the lock on the corresponding transaction record.
 
+        If the lock no longer exists (e.g. it expired or was already released),
+        this method is a no-op.
+
         Args:
             key: Unique identifier for the transaction record.
             holder: Unique identifier for the holder of the lock. Must match the
                 holder provided when acquiring the lock.
+
+        Raises:
+            ValueError: If the lock is held by a different holder.
         """
         ...
 

{prefect_client-3.9.2.dev4 → prefect_client-3.9.2.dev6}/src/prefect/runner/AGENTS.md

@@ -142,6 +142,8 @@ These validations exist to prevent git argument injection. Do not bypass them wh
 
 **Automatic dependency installation:** By default, `WorkspaceResolvingEngineCommandStarter` does not install dependencies before starting a flow run. When no explicit command is passed and `PREFECT_RUNNER_AUTO_INSTALL_DEPENDENCIES` is true, it auto-selects `uv run --no-default-groups --project <project_root>` with the worker-supplied workspace bootstrap — but only when all three conditions hold: `pyproject.toml` exists at `project_root`, the `project.dependencies` list includes `prefect`, and `uv` is found via the workspace's `PATH` env var (not the system PATH). The bootstrap uses the prepared entrypoint with `prefect.flow_engine` when that module exposes its executable `_main`; older selected runtimes fall back to `prefect.engine` with `PREFECT__FLOW_ENTRYPOINT`, preserving the prepared workspace. If the setting is false or any condition fails, the command falls back to `None`. Explicit commands always take precedence.
 
+**Version skew in the runtime bootstrap:** `_workspace_runtime_bootstrap.py` runs inside the flow's selected runtime, which may ship an older Prefect than the worker. Do not make it depend on Prefect internals newer than that runtime; it keeps local copies instead. Its flow hook argument resolution is one such copy (see the hook-parity contract in `src/prefect/AGENTS.md`).
+
 ## Reference
 
 Full refactor design and rationale: plans/completed/2026-02-18-runner-refactor.md

{prefect_client-3.9.2.dev4 → prefect_client-3.9.2.dev6}/src/prefect/runner/_hook_runner.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any, Awaitable, Callable, Protocol
 
 from prefect._internal.concurrency.api import create_call, from_async
-from prefect._internal.engine import get_hook_name
+from prefect._internal.engine import get_hook_name, resolve_flow_hook_arguments
 from prefect.logging.loggers import flow_run_logger
 from prefect.utilities.asyncutils import is_async_fn
 
@@ -35,12 +35,11 @@ async def _run_hooks(
                 hook_name,
                 state.name,
             )
+            args, kwargs = resolve_flow_hook_arguments(hook, flow, flow_run, state)
             if is_async_fn(hook):
-                await hook(flow=flow, flow_run=flow_run, state=state)
+                await hook(*args, **kwargs)
             else:
-                await from_async.call_in_new_thread(
-                    create_call(hook, flow=flow, flow_run=flow_run, state=state)
-                )
+                await from_async.call_in_new_thread(create_call(hook, *args, **kwargs))
         except Exception:
             logger.error(
                 "An error was encountered while running hook %r",

{prefect_client-3.9.2.dev4 → prefect_client-3.9.2.dev6}/src/prefect/runner/_workspace_runtime_bootstrap.py

@@ -109,6 +109,52 @@ async def _load_flow(manifest: dict[str, Any]) -> Flow[Any, Any]:
         return await _run_sync(load_function_and_convert_to_flow, entrypoint)
 
 
+def _flow_hook_arguments(
+    hook: Callable[..., Any],
+    flow: Flow[Any, Any],
+    flow_run: FlowRun,
+    state: State,
+) -> tuple[tuple[Any, ...], dict[str, Any]]:
+    # Same rule as `prefect._internal.engine.resolve_flow_hook_arguments`. This
+    # module runs with the flow's runtime, which may have an older Prefect
+    # without that function, so it keeps its own copy.
+    try:
+        signature = inspect.signature(hook)
+    except (TypeError, ValueError):
+        return (flow, flow_run, state), {}
+
+    def binds(*args: Any, **kwargs: Any) -> bool:
+        try:
+            signature.bind(*args, **kwargs)
+        except TypeError:
+            return False
+        return True
+
+    named = (inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.KEYWORD_ONLY)
+    for flow_run_name in ("flow_run", "run"):
+        kwargs = {"flow": flow, flow_run_name: flow_run, "state": state}
+        declared = all(
+            name in signature.parameters and signature.parameters[name].kind in named
+            for name in kwargs
+        )
+        if declared and binds(**kwargs):
+            return (), kwargs
+
+    if binds(flow, flow_run, state):
+        return (flow, flow_run, state), {}
+
+    kwargs = {"flow": flow, "flow_run": flow_run, "state": state}
+    if binds(**kwargs):
+        return (), kwargs
+
+    hook_name = getattr(hook, "__name__", type(hook).__name__)
+    raise TypeError(
+        f"Hook {hook_name!r} must accept the flow, the flow run and the state as"
+        " three positional arguments or as parameters named `flow`, `flow_run`"
+        " (or `run`) and `state`"
+    )
+
+
 async def _run_hooks(
     hooks: list[Callable[..., Any]],
     flow_run: FlowRun,
@@ -121,14 +167,8 @@ async def _run_hooks(
     for hook in hooks:
         hook_name = getattr(hook, "__name__", type(hook).__name__)
         try:
-            result = await _run_sync(
-                functools.partial(
-                    hook,
-                    flow=flow,
-                    flow_run=flow_run,
-                    state=state,
-                )
-            )
+            args, kwargs = _flow_hook_arguments(hook, flow, flow_run, state)
+            result = await _run_sync(functools.partial(hook, *args, **kwargs))
             if inspect.isawaitable(result):
                 await result
         except Exception:

{prefect_client-3.9.2.dev4 → prefect_client-3.9.2.dev6}/src/prefect/runner/storage.py

@@ -459,12 +459,27 @@ class GitRepository:
             # read-only attribute first to avoid `[WinError 5] Access is denied`.
             _clear_read_only_attributes(git_dir)
 
-            # Sparsely checkout the repository if directories are specified and the repo is not in sparse-checkout mode already
-            if self._directories and not await self.is_sparsely_checked_out():
+            # Make the checkout match the configured directories. The destination
+            # can be reused by runs whose `directories` differ (a redeploy that
+            # changed the list, or deployments sharing a working directory), so
+            # an existing sparse checkout only grows: narrowing it would remove
+            # files that another run may still be using.
+            is_sparse = await self.is_sparsely_checked_out()
+            if self._directories:
                 await run_process(
-                    ["git", "sparse-checkout", "set", "--", *self._directories],
+                    [
+                        "git",
+                        "sparse-checkout",
+                        "add" if is_sparse else "set",
+                        "--",
+                        *self._directories,
+                    ],
                     cwd=self.destination,
                 )
+            elif is_sparse:
+                await run_process(
+                    ["git", "sparse-checkout", "disable"], cwd=self.destination
+                )
 
             self._logger.debug("Pulling latest changes from origin/%s", self._branch)
             # Update the existing repository

{prefect_client-3.9.2.dev4 → prefect_client-3.9.2.dev6}/src/prefect/server/api/deployments.py

@@ -440,6 +440,9 @@ async def update_deployment(
         # Phase 2: Apply the actual updates. Renamed schedules use
         # their row ID (slug is now NULL); others use slug as before.
         for schedule in schedules_to_patch:
+            # A schedule sent with the deployment carries its full overrides, and
+            # `prefect deploy` leaves `parameters` out when there are none
+            schedule = schedule.model_copy(update={"parameters": schedule.parameters})
             if schedule.replaces:
                 await models.deployments.update_deployment_schedule(
                     session=session,

{prefect_client-3.9.2.dev4 → prefect_client-3.9.2.dev6}/src/prefect/server/api/flow_runs.py

@@ -581,7 +581,9 @@ async def resume_flow_run(
                 flow_run_input=schemas.core.FlowRunInput(
                     flow_run_id=flow_run_id,
                     key=keyset["response"],
-                    value=orjson.dumps(run_input).decode("utf-8"),
+                    value=pydantic_core.to_json(run_input, inf_nan_mode="null").decode(
+                        "utf-8"
+                    ),
                 ),
             )
 

{prefect_client-3.9.2.dev4 → prefect_client-3.9.2.dev6}/src/prefect/server/api/server.py

@@ -367,9 +367,12 @@ def is_client_retryable_exception(exc: Exception) -> bool:
         exc,
         (
             sqlalchemy.exc.DBAPIError,
+            sqlalchemy.exc.TimeoutError,
+            TimeoutError,
             asyncpg.exceptions.QueryCanceledError,
             asyncpg.exceptions.ConnectionDoesNotExistError,
             asyncpg.exceptions.CannotConnectNowError,
+            asyncpg.exceptions.PostgresConnectionError,
             sqlalchemy.exc.InvalidRequestError,
             sqlalchemy.orm.exc.DetachedInstanceError,
         ),