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

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

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

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

@@ -0,0 +1,5 @@
+# Generated by versioningit
+__version__ = "3.6.24.dev5"
+__build_date__ = "2026-03-27 08:21:08.545102+00:00"
+__git_commit__ = "cb945cbe647c75a0476662c8daedee8530398fd7"
+__dirty__ = False

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

@@ -57,9 +57,12 @@ if hasattr(os, "register_at_fork"):
 class _QueueServiceBase(abc.ABC, Generic[T]):
     _instances: dict[int, Self] = {}
     _instance_lock = threading.Lock()
+    _max_queue_size: int = 0  # 0 means unbounded
 
     def __init__(self, *args: Hashable) -> None:
-        self._queue: queue.Queue[Optional[T]] = queue.Queue()
+        self._queue: queue.Queue[Optional[T]] = queue.Queue(
+            maxsize=self._max_queue_size
+        )
         self._loop: Optional[asyncio.AbstractEventLoop] = None
         self._done_event: Optional[asyncio.Event] = None
         self._task: Optional[asyncio.Task[None]] = None
@@ -85,7 +88,7 @@ class _QueueServiceBase(abc.ABC, Generic[T]):
         self._loop = None
         self._done_event = None
         self._task = None
-        self._queue = queue.Queue()
+        self._queue = queue.Queue(maxsize=self._max_queue_size)
         self._lock = threading.Lock()
 
     @classmethod
@@ -345,7 +348,16 @@ class QueueService(_QueueServiceBase[T]):
                 raise RuntimeError("Cannot put items in a stopped service instance.")
 
             logger.debug("Service %r enqueuing item %r", self, item)
-            self._queue.put_nowait(self._prepare_item(item))
+            prepared = self._prepare_item(item)
+            try:
+                self._queue.put_nowait(prepared)
+            except queue.Full:
+                self._logger.warning(
+                    "Service %r queue is full (%d items), dropping item",
+                    type(self).__name__,
+                    self._queue.qsize(),
+                )
+                self._on_item_dropped(prepared)
 
     def _prepare_item(self, item: T) -> T:
         """
@@ -356,6 +368,16 @@ class QueueService(_QueueServiceBase[T]):
         """
         return item
 
+    def _on_item_dropped(self, item: T) -> None:
+        """
+        Called when a prepared item is dropped because the queue is full.
+
+        Subclasses can override this to clean up any resources allocated
+        during _prepare_item.
+
+        The default implementation is a no-op.
+        """
+
     @abc.abstractmethod
     async def _handle(self, item: T) -> None:
         """

{prefect_client-3.6.24.dev3 → prefect_client-3.6.24.dev5}/src/prefect/blocks/notifications.py

@@ -714,6 +714,8 @@ class MattermostWebhook(AbstractAppriseNotificationBlock):
     )
 
     def block_initialization(self) -> None:
+        from apprise import Apprise, AppriseAsset
+
         try:
             # Try importing for apprise>=1.18.0
             from apprise.plugins.mattermost import NotifyMattermost
@@ -723,19 +725,26 @@ class MattermostWebhook(AbstractAppriseNotificationBlock):
                 NotifyMattermost,  # pyright: ignore[reportUnknownVariableType] incomplete type hints in apprise
             )
 
-        url = SecretStr(
-            NotifyMattermost(
-                token=self.token.get_secret_value(),
-                fullpath=self.path,
-                host=self.hostname,
-                user=self.botname,
-                channels=self.channels,
-                include_image=self.include_image,
-                port=self.port,
-                secure=self.secure,
-            ).url()  # pyright: ignore[reportUnknownMemberType, reportUnknownArgumentType] incomplete type hints in apprise
+        # Add the NotifyMattermost instance directly rather than going through
+        # .url() because apprise>=1.9.9 no longer includes channels in the URL.
+        # apprise>=1.9.9 renamed `channels` to `targets`.
+        mattermost_instance = NotifyMattermost(
+            token=self.token.get_secret_value(),
+            fullpath=self.path,
+            host=self.hostname,
+            targets=self.channels,
+            include_image=self.include_image,
+            port=self.port,
+            secure=self.secure,
+        )  # pyright: ignore[reportUnknownVariableType] incomplete type hints in apprise
+
+        prefect_app_data = AppriseAsset(
+            app_id="Prefect Notifications",
+            app_desc="Prefect Notifications",
+            app_url="https://prefect.io",
         )
-        self._start_apprise_client(url)
+        self._apprise_client = Apprise(asset=prefect_app_data)
+        self._apprise_client.add(mattermost_instance)  # pyright: ignore[reportUnknownMemberType]
 
 
 class DiscordWebhook(AbstractAppriseNotificationBlock):

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

@@ -33,6 +33,7 @@ For module path entrypoints, the storage destination is temporarily prepended to
 
 ## Pitfalls
 
+- **Flow source outside cwd**: `RunnerDeployment.from_flow()` computes the entrypoint path with `Path.relative_to(cwd)`. When the flow file is outside the working directory (e.g., on a different drive on Windows, or an absolute path not under cwd), `relative_to()` raises `ValueError` — the code falls back to `os.path.relpath()`, which may produce paths containing `..` components. Infrastructure that expects clean relative paths (no `..`) must handle this case.
 - **Windows shell mode**: `run_shell_script` always uses `asyncio.create_subprocess_shell` on Windows (`sys.platform == "win32"`), regardless of the `shell` parameter. This ensures cmd.exe built-ins (`echo`, `dir`, `set`, etc.) work. On non-Windows, `shell=False` (default) uses `create_subprocess_exec` with `shlex.split`.
 - **Step ID namespace**: `id` and `requires` are reserved keywords — do not use them as step output keys.
 - **Step import side effects**: steps are imported dynamically; packages listed in `requires` are installed into the current environment at execution time.

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

@@ -32,6 +32,7 @@ Example:
 from __future__ import annotations
 
 import importlib
+import os
 import sys
 import tempfile
 from datetime import datetime, timedelta
@@ -1011,9 +1012,16 @@ class RunnerDeployment(BaseModel):
                         raise ValueError(no_file_location_error)
 
                 # set entrypoint
-                entry_path = (
-                    Path(flow_file).absolute().relative_to(Path.cwd().absolute())
-                )
+                try:
+                    entry_path = (
+                        Path(flow_file).absolute().relative_to(Path.cwd().absolute())
+                    )
+                except ValueError:
+                    entry_path = Path(
+                        os.path.relpath(
+                            Path(flow_file).absolute(), Path.cwd().absolute()
+                        )
+                    )
                 deployment.entrypoint = (
                     f"{entry_path}:{getattr(flow.fn, '__qualname__', flow.fn.__name__)}"
                 )

{prefect_client-3.6.24.dev3 → prefect_client-3.6.24.dev5}/src/prefect/deployments/steps/utility.py

@@ -52,12 +52,12 @@ async def _stream_capture_process_output(
     async with create_task_group() as tg:
         tg.start_soon(
             stream_text,
-            TextReceiveStream(process.stdout),
+            TextReceiveStream(process.stdout, errors="replace"),
             *stdout_sinks,
         )
         tg.start_soon(
             stream_text,
-            TextReceiveStream(process.stderr),
+            TextReceiveStream(process.stderr, errors="replace"),
             *stderr_sinks,
         )
 
@@ -71,7 +71,7 @@ async def _read_stream(
         data = await stream.read(4096)
         if not data:
             break
-        text = data.decode()
+        text = data.decode(errors="replace")
         for sink in sinks:
             sink.write(text)
             if hasattr(sink, "flush"):

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

@@ -9,6 +9,15 @@ Client-side event system for emitting, subscribing to, and defining automations
 - Automations combine triggers (event, metric, compound, sequence) with actions.
 - `DeploymentTriggerTypes` are the subset of triggers usable in `prefect.yaml` deployment definitions.
 
+## clients.py — Checkpointing Invariant
+
+`PrefectEventsClient` uses **two independent checkpointing mechanisms** to confirm server receipt of sent events:
+
+1. **Count-based** (`checkpoint_every`, default 700): checkpoints after N emitted events.
+2. **Time-based** (`checkpoint_interval`, default 30s): a background `asyncio.Task` that fires periodically regardless of event count. Prevents unbounded buffer growth for low-throughput connections.
+
+The background task is started in `__aenter__` and after each reconnect, and cancelled in `__aexit__`. If you subclass or mock `PrefectEventsClient`, ensure both checkpointing paths are exercised — the count threshold alone is not sufficient for low-volume scenarios.
+
 ## Structure
 
 - `schemas/` — Pydantic models: `Event`, `Resource`, `RelatedResource`, `Automation`, triggers, deployment triggers

{prefect_client-3.6.24.dev3 → prefect_client-3.6.24.dev5}/src/prefect/events/clients.py

@@ -101,17 +101,20 @@ def events_out_socket_from_api_url(url: str) -> str:
 def get_events_client(
     reconnection_attempts: int = 10,
     checkpoint_every: int = 700,
+    checkpoint_interval: float = 30.0,
 ) -> "EventsClient":
     api_url = PREFECT_API_URL.value()
     if isinstance(api_url, str) and api_url.startswith(PREFECT_CLOUD_API_URL.value()):
         return PrefectCloudEventsClient(
             reconnection_attempts=reconnection_attempts,
             checkpoint_every=checkpoint_every,
+            checkpoint_interval=checkpoint_interval,
         )
     elif api_url:
         return PrefectEventsClient(
             reconnection_attempts=reconnection_attempts,
             checkpoint_every=checkpoint_every,
+            checkpoint_interval=checkpoint_interval,
         )
     elif PREFECT_SERVER_ALLOW_EPHEMERAL_MODE:
         from prefect.server.api.server import SubprocessASGIServer
@@ -122,6 +125,7 @@ def get_events_client(
             api_url=server.api_url,
             reconnection_attempts=reconnection_attempts,
             checkpoint_every=checkpoint_every,
+            checkpoint_interval=checkpoint_interval,
         )
     else:
         raise ValueError(
@@ -268,6 +272,7 @@ class PrefectEventsClient(EventsClient):
         api_url: Optional[str] = None,
         reconnection_attempts: int = 10,
         checkpoint_every: int = 700,
+        checkpoint_interval: float = 30.0,
     ):
         """
         Args:
@@ -276,6 +281,9 @@ class PrefectEventsClient(EventsClient):
                 the client should attempt to reconnect
             checkpoint_every: How often the client should sync with the server to
                 confirm receipt of all previously sent events
+            checkpoint_interval: Maximum seconds between checkpoints, regardless of
+                event count. Prevents unbounded growth of the unconfirmed events
+                buffer for low-throughput connections.
         """
         api_url = api_url or PREFECT_API_URL.value()
         if not api_url:
@@ -297,6 +305,8 @@ class PrefectEventsClient(EventsClient):
         self._reconnection_attempts = reconnection_attempts
         self._unconfirmed_events = []
         self._checkpoint_every = checkpoint_every
+        self._checkpoint_interval = checkpoint_interval
+        self._checkpoint_task: Optional[asyncio.Task[None]] = None
 
     async def __aenter__(self) -> Self:
         await super().__aenter__()
@@ -324,6 +334,7 @@ class PrefectEventsClient(EventsClient):
                 # propagate immediately with a warning
                 self._log_connection_error(e)
                 raise
+        self._start_checkpoint_task()
         return self
 
     async def __aexit__(
@@ -332,6 +343,7 @@ class PrefectEventsClient(EventsClient):
         exc_val: Optional[BaseException],
         exc_tb: Optional[TracebackType],
     ) -> None:
+        self._stop_checkpoint_task()
         self._websocket = None
         # Only call __aexit__ on the connection if it was successfully established.
         # The websockets library sets the "connection" attribute on the connect
@@ -427,6 +439,47 @@ class PrefectEventsClient(EventsClient):
         for event in events_to_resend:
             await self.emit(event)
         logger.debug("Finished resending unconfirmed events.")
+        self._start_checkpoint_task()
+
+    def _start_checkpoint_task(self) -> None:
+        self._stop_checkpoint_task()
+        self._checkpoint_task = asyncio.create_task(self._checkpoint_loop())
+
+    def _stop_checkpoint_task(self) -> None:
+        if self._checkpoint_task is not None:
+            self._checkpoint_task.cancel()
+            self._checkpoint_task = None
+
+    async def _checkpoint_loop(self) -> None:
+        """Periodically checkpoint unconfirmed events on a time interval,
+        independent of the count-based checkpoint in _checkpoint."""
+        while True:
+            await asyncio.sleep(self._checkpoint_interval)
+            if self._websocket and self._unconfirmed_events:
+                try:
+                    await self._force_checkpoint()
+                except Exception:
+                    logger.debug(
+                        "Time-based checkpoint failed, will retry next interval.",
+                        exc_info=True,
+                    )
+
+    async def _force_checkpoint(self) -> None:
+        """Checkpoint all unconfirmed events unconditionally."""
+        assert self._websocket
+
+        unconfirmed_count = len(self._unconfirmed_events)
+        if unconfirmed_count == 0:
+            return
+
+        logger.debug("Time-based checkpoint: confirming %s events.", unconfirmed_count)
+        pong = await self._websocket.ping()
+        await pong
+        self._log_debug("Pong received. Events checkpointed.")
+
+        self._unconfirmed_events = self._unconfirmed_events[unconfirmed_count:]
+
+        EVENT_WEBSOCKET_CHECKPOINTS.labels(self.client_name).inc()
 
     async def _checkpoint(self) -> None:
         assert self._websocket
@@ -547,6 +600,7 @@ class PrefectCloudEventsClient(PrefectEventsClient):
         api_key: Optional[str] = None,
         reconnection_attempts: int = 10,
         checkpoint_every: int = 700,
+        checkpoint_interval: float = 30.0,
     ):
         """
         Args:
@@ -556,12 +610,15 @@ class PrefectCloudEventsClient(PrefectEventsClient):
                 the client should attempt to reconnect
             checkpoint_every: How often the client should sync with the server to
                 confirm receipt of all previously sent events
+            checkpoint_interval: Maximum seconds between checkpoints, regardless of
+                event count.
         """
         api_url, api_key = _get_api_url_and_key(api_url, api_key)
         super().__init__(
             api_url=api_url,
             reconnection_attempts=reconnection_attempts,
             checkpoint_every=checkpoint_every,
+            checkpoint_interval=checkpoint_interval,
         )
         # Cloud authenticates via the Authorization header at the HTTP level,
         # not via the "prefect" subprotocol auth handshake used by self-hosted servers.

{prefect_client-3.6.24.dev3 → prefect_client-3.6.24.dev5}/src/prefect/events/worker.py

@@ -69,6 +69,9 @@ class EventsWorker(QueueService[Event]):
     def __init__(
         self, client_type: Type[EventsClient], client_options: Tuple[Tuple[str, Any]]
     ):
+        from prefect.settings import get_current_settings
+
+        self._max_queue_size = get_current_settings().events.worker_max_queue_size
         super().__init__(client_type, client_options)
         self.client_type = client_type
         self.client_options = client_options
@@ -90,6 +93,9 @@ class EventsWorker(QueueService[Event]):
         self._context_cache[event.id] = copy_context()
         return event
 
+    def _on_item_dropped(self, item: Event) -> None:
+        self._context_cache.pop(item.id, None)
+
     async def _handle(self, event: Event):
         context = self._context_cache.pop(event.id)
         with temporary_context(context=context):

{prefect_client-3.6.24.dev3 → prefect_client-3.6.24.dev5}/src/prefect/flow_runs.py

@@ -472,7 +472,7 @@ def pause_flow_run(
 async def asuspend_flow_run(
     wait_for_input: None = None,
     flow_run_id: UUID | None = None,
-    timeout: int | None = 3600,
+    timeout: int | None = None,
     key: str | None = None,
 ) -> None: ...
 
@@ -481,7 +481,7 @@ async def asuspend_flow_run(
 async def asuspend_flow_run(
     wait_for_input: Type[T],
     flow_run_id: UUID | None = None,
-    timeout: int | None = 3600,
+    timeout: int | None = None,
     key: str | None = None,
 ) -> T: ...
 
@@ -489,7 +489,7 @@ async def asuspend_flow_run(
 async def asuspend_flow_run(
     wait_for_input: Type[T] | None = None,
     flow_run_id: UUID | None = None,
-    timeout: int | None = 3600,
+    timeout: int | None = None,
     key: str | None = None,
 ) -> T | None:
     """
@@ -509,9 +509,9 @@ async def asuspend_flow_run(
             suspend the specified flow run. If not supplied will attempt to
             suspend the current flow run.
         timeout: the number of seconds to wait for the flow to be resumed before
-            failing. Defaults to 1 hour (3600 seconds). If the pause timeout
-            exceeds any configured flow-level timeout, the flow might fail even
-            after resuming.
+            failing. Defaults to no timeout. If the pause timeout exceeds any
+            configured flow-level timeout, the flow might fail even after
+            resuming.
         key: An optional key to prevent calling suspend more than once. This
             defaults to a random string and prevents suspends from running the
             same suspend twice. A custom key can be supplied for custom
@@ -596,7 +596,7 @@ async def asuspend_flow_run(
 def suspend_flow_run(
     wait_for_input: None = None,
     flow_run_id: UUID | None = None,
-    timeout: int | None = 3600,
+    timeout: int | None = None,
     key: str | None = None,
 ) -> None: ...
 
@@ -605,7 +605,7 @@ def suspend_flow_run(
 def suspend_flow_run(
     wait_for_input: Type[T],
     flow_run_id: UUID | None = None,
-    timeout: int | None = 3600,
+    timeout: int | None = None,
     key: str | None = None,
 ) -> T: ...
 
@@ -614,7 +614,7 @@ def suspend_flow_run(
 def suspend_flow_run(
     wait_for_input: Type[T] | None = None,
     flow_run_id: UUID | None = None,
-    timeout: int | None = 3600,
+    timeout: int | None = None,
     key: str | None = None,
 ) -> T | None:
     """
@@ -634,9 +634,9 @@ def suspend_flow_run(
             suspend the specified flow run. If not supplied will attempt to
             suspend the current flow run.
         timeout: the number of seconds to wait for the flow to be resumed before
-            failing. Defaults to 1 hour (3600 seconds). If the pause timeout
-            exceeds any configured flow-level timeout, the flow might fail even
-            after resuming.
+            failing. Defaults to no timeout. If the pause timeout exceeds any
+            configured flow-level timeout, the flow might fail even after
+            resuming.
         key: An optional key to prevent calling suspend more than once. This
             defaults to a random string and prevents suspends from running the
             same suspend twice. A custom key can be supplied for custom

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

@@ -415,6 +415,23 @@ def create_api_app(
     if final:
         gc.collect()
 
+    @api_app.middleware("http")
+    async def default_content_type(request: Request, call_next: Any):  # type: ignore[reportUnusedFunction]
+        # Older Prefect clients (<3.6.19) sent JSON bodies via httpx's
+        # content= parameter, which omits the Content-Type header.
+        # FastAPI >=0.132.0 requires Content-Type: application/json to
+        # parse request bodies. Default it here for backward compat.
+        if (
+            request.method in {"POST", "PUT", "PATCH"}
+            and "content-type" not in request.headers
+            and int(request.headers.get("content-length", "0")) > 0
+        ):
+            request.scope["headers"] = [
+                *request.scope["headers"],
+                (b"content-type", b"application/json"),
+            ]
+        return await call_next(request)
+
     auth_string = prefect.settings.PREFECT_SERVER_API_AUTH_STRING.value()
 
     if auth_string is not None:

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

@@ -13,6 +13,7 @@ All settings are rooted in the `Settings` class in `models/root.py`, which compo
 | `client` | `models/client.py` | HTTP client behavior (retries, CSRF, headers) |
 | `cloud` | `models/cloud.py` | Prefect Cloud-specific config |
 | `deployments` | `models/deployments.py` | Deployment defaults |
+| `events` | `models/events.py` | Client-side event worker behavior (queue size) |
 | `experiments` | `models/experiments.py` | Feature flags and experimental features |
 | `flows` | `models/flows.py` | Flow behavior defaults |
 | `internal` | `models/internal.py` | Internal machinery |

prefect_client-3.6.24.dev5/src/prefect/settings/models/events.py

@@ -0,0 +1,27 @@
+from typing import ClassVar
+
+from pydantic import Field
+from pydantic_settings import SettingsConfigDict
+
+from prefect.settings.base import PrefectBaseSettings, build_settings_config
+
+
+class EventsSettings(PrefectBaseSettings):
+    """
+    Settings for controlling events behavior
+    """
+
+    model_config: ClassVar[SettingsConfigDict] = build_settings_config(("events",))
+
+    worker_max_queue_size: int = Field(
+        default=0,
+        ge=0,
+        description="""
+        Maximum number of events that can be queued for delivery to the
+        Prefect server. When the queue is full, new events are dropped with
+        a warning. Set to 0 for unbounded (the default).
+
+        Warning: setting this value too low may result in data loss as events
+        will be silently dropped when the queue is full.
+        """,
+    )

{prefect_client-3.6.24.dev3 → prefect_client-3.6.24.dev5}/src/prefect/settings/models/root.py

@@ -32,6 +32,7 @@ from .cli import CLISettings
 from .client import ClientSettings
 from .cloud import CloudSettings
 from .deployments import DeploymentsSettings
+from .events import EventsSettings
 from .experiments import ExperimentsSettings
 from .flows import FlowsSettings
 from .internal import InternalSettings
@@ -98,6 +99,11 @@ class Settings(PrefectBaseSettings):
         description="Settings for configuring deployments defaults",
     )
 
+    events: EventsSettings = Field(
+        default_factory=EventsSettings,
+        description="Settings for controlling events behavior",
+    )
+
     experiments: ExperimentsSettings = Field(
         default_factory=ExperimentsSettings,
         description="Settings for controlling experimental features",

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

@@ -15,6 +15,7 @@ Does NOT include: server-specific utilities (`server/utilities/`), concurrency s
 - `callables.py` — Function signature introspection and parameter coercion
 - `collections.py` — Extended collection helpers (visit, flatten, remove nested keys)
 - `annotations.py` — Custom Prefect type annotations used in flow/task signatures
+- `processutils.py` — Subprocess execution and output streaming helpers (`run_process`, `consume_process_output`, `stream_text`)
 - `pydantic.py` — Pydantic v1/v2 compatibility shims
 - `templating.py` — Jinja template utilities and `maybe_template()` detection
 
@@ -68,3 +69,4 @@ Handlers return `Placeholder` subclasses (e.g. `RemoveValue`, `InvalidJSON`, `In
 
 - `maybe_template(s)` (in `templating.py`) only checks whether a string looks like it contains a Jinja expression — it does not validate that it's well-formed. A string with `{{` but no `}}` returns `True`.
 - `HydrationContext` workspace variables are loaded once at build time. Stale contexts don't reflect variable updates made after context creation.
+- **Non-UTF-8 subprocess output is silently replaced.** `consume_process_output` and `stream_text` (via `TextReceiveStream(errors="replace")`) replace invalid bytes with the Unicode replacement character `\ufffd` rather than raising. If captured output contains `\ufffd`, the subprocess emitted bytes that were not valid UTF-8.

{prefect_client-3.6.24.dev3 → prefect_client-3.6.24.dev5}/src/prefect/utilities/engine.py

@@ -267,21 +267,30 @@ async def resolve_inputs(
         else:
             return expr
 
-        # Do not allow uncompleted upstreams except failures when `allow_failure` has
-        # been used
+        # Do not allow uncompleted upstreams unless `allow_failure` has been used
+        # for failed or failure-derived (PENDING/NotReady) states
         if not state.is_completed() and not (
             # TODO: Note that the contextual annotation here is only at the current level
             #       if `allow_failure` is used then another annotation is used, this will
             #       incorrectly evaluate to false — to resolve this, we must track all
             #       annotations wrapping the current expression but this is not yet
             #       implemented.
-            isinstance(context.get("annotation"), allow_failure) and state.is_failed()
+            isinstance(context.get("annotation"), allow_failure)
+            and (state.is_failed() or (state.is_pending() and state.name == "NotReady"))
         ):
             raise UpstreamTaskError(
                 f"Upstream task run '{state.state_details.task_run_id}' did not reach a"
                 " 'COMPLETED' state."
             )
 
+        # When allow_failure is used and the state is not final (e.g. PENDING/NotReady
+        # from a cascading upstream failure), return state.data directly since
+        # result_by_state is only populated for final states.
+        if not state.is_final() and isinstance(
+            context.get("annotation"), allow_failure
+        ):
+            return state.data
+
         return result_by_state.get(state)
 
     resolved_parameters: dict[str, Any] = {}
@@ -747,21 +756,28 @@ def resolve_to_final_result(expr: Any, context: dict[str, Any]) -> Any:
 
     assert state
 
-    # Do not allow uncompleted upstreams except failures when `allow_failure` has
-    # been used
+    # Do not allow uncompleted upstreams unless `allow_failure` has been used
+    # for failed or failure-derived (PENDING/NotReady) states
     if not state.is_completed() and not (
         # TODO: Note that the contextual annotation here is only at the current level
         #       if `allow_failure` is used then another annotation is used, this will
         #       incorrectly evaluate to false — to resolve this, we must track all
         #       annotations wrapping the current expression but this is not yet
         #       implemented.
-        isinstance(context.get("annotation"), allow_failure) and state.is_failed()
+        isinstance(context.get("annotation"), allow_failure)
+        and (state.is_failed() or (state.is_pending() and state.name == "NotReady"))
     ):
         raise UpstreamTaskError(
             f"Upstream task run '{state.state_details.task_run_id}' did not reach a"
             " 'COMPLETED' state."
         )
 
+    # When allow_failure is used and the state is not final (e.g. PENDING/NotReady
+    # from a cascading upstream failure), we cannot call state.result() because it
+    # raises UnfinishedRun.  Return the state's data directly instead.
+    if not state.is_final() and isinstance(context.get("annotation"), allow_failure):
+        return state.data
+
     result: Any = state.result(raise_on_failure=False, _sync=True)  # pyright: ignore[reportCallIssue] _sync messes up type inference and can be removed once async_dispatch is removed
 
     if state.state_details.traceparent:

{prefect_client-3.6.24.dev3 → prefect_client-3.6.24.dev5}/src/prefect/utilities/processutils.py

@@ -338,13 +338,13 @@ async def consume_process_output(
         if process.stdout is not None:
             tg.start_soon(
                 stream_text,
-                TextReceiveStream(process.stdout),
+                TextReceiveStream(process.stdout, errors="replace"),
                 stdout_sink,
             )
         if process.stderr is not None:
             tg.start_soon(
                 stream_text,
-                TextReceiveStream(process.stderr),
+                TextReceiveStream(process.stderr, errors="replace"),
                 stderr_sink,
             )
 

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

@@ -1,5 +0,0 @@
-# Generated by versioningit
-__version__ = "3.6.24.dev3"
-__build_date__ = "2026-03-25 08:20:24.449244+00:00"
-__git_commit__ = "506781bb04ec791fdbbe4dfd99c8ff692bbffb6f"
-__dirty__ = False