prefect-client 3.7.4.dev4__tar.gz → 3.7.5__tar.gz

{prefect_client-3.7.4.dev4 → prefect_client-3.7.5}/PKG-INFO

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

prefect_client-3.7.5/src/prefect/_build_info.py

@@ -0,0 +1,5 @@
+# Generated by versioningit
+__version__ = "3.7.5"
+__build_date__ = "2026-06-18 21:29:47.502929+00:00"
+__git_commit__ = "756685ab55d5afe34017dc5c7ab68cf79600d664"
+__dirty__ = False

{prefect_client-3.7.4.dev4 → prefect_client-3.7.5}/src/prefect/_internal/concurrency/threads.py

@@ -38,9 +38,18 @@ def _reset_after_fork_in_child():
 
     This handler is called by os.register_at_fork() in the child process after fork().
     """
+    global _global_loop, _run_sync_loop
+
     for instance in list(_active_instances):
         instance.reset_for_fork()
 
+    # Clear global references so get_global_loop() / get_run_sync_loop() create
+    # fresh instances.  After fork the old EventLoopThread objects have a stale
+    # Thread whose is_alive() still returns True (the dead thread's tstate lock
+    # is held), so the "is the thread alive?" guard in the getters never fires.
+    _global_loop = None
+    _run_sync_loop = None
+
 
 # Register fork handler if supported (POSIX systems)
 if hasattr(os, "register_at_fork"):

prefect_client-3.7.5/src/prefect/_internal/schemas/_registry.py

@@ -0,0 +1,13 @@
+from referencing import Registry
+
+
+def non_fetching_registry() -> Registry:
+    """An empty `referencing.Registry` that disables remote `$ref` fetching.
+
+    Passing an explicit registry to jsonschema suppresses its default behavior of
+    fetching `$ref` URLs over the network while validating an instance. With an
+    empty registry, external references raise `referencing.exceptions.Unresolvable`
+    without any network request, while in-document references (`#/$defs/...`) still
+    resolve normally.
+    """
+    return Registry()

{prefect_client-3.7.4.dev4 → prefect_client-3.7.5}/src/prefect/_internal/schemas/validators.py

@@ -21,7 +21,9 @@ from uuid import UUID
 from zoneinfo import ZoneInfo
 
 import jsonschema
+import referencing.exceptions
 
+from prefect._internal.schemas._registry import non_fetching_registry
 from prefect.types._datetime import DateTime, create_datetime_instance, get_timezones
 from prefect.utilities.collections import isiterable
 from prefect.utilities.filesystem import relative_path_to_current_platform
@@ -65,7 +67,9 @@ def validate_values_conform_to_schema(
 
     try:
         if schema is not None and values is not None:
-            jsonschema.validate(values, schema)
+            jsonschema.validate(values, schema, registry=non_fetching_registry())
+    except referencing.exceptions.Unresolvable as exc:
+        raise ValueError(f"Validation failed. Failure reason: {exc}") from exc
     except jsonschema.ValidationError as exc:
         if exc.json_path == "$":
             error_message = "Validation failed."

{prefect_client-3.7.4.dev4 → prefect_client-3.7.5}/src/prefect/client/schemas/actions.py

@@ -6,6 +6,7 @@ from typing import Annotated, Any, Callable, Optional, TypeVar, Union
 from uuid import UUID, uuid4
 
 import jsonschema
+import referencing.exceptions
 from pydantic import (
     AfterValidator,
     BaseModel,
@@ -18,6 +19,7 @@ from pydantic import (
 import prefect.client.schemas.objects as objects
 from prefect._internal.result_records import ResultRecordMetadata
 from prefect._internal.schema import ParameterSchema
+from prefect._internal.schemas._registry import non_fetching_registry
 from prefect._internal.schemas.bases import ActionBaseModel
 from prefect._internal.schemas.validators import (
     convert_to_strings,
@@ -324,7 +326,14 @@ class DeploymentCreate(ActionBaseModel):
                     if "default" in v and k in required:
                         required.remove(k)
 
-            jsonschema.validate(self.job_variables, variables_schema)
+            try:
+                jsonschema.validate(
+                    self.job_variables,
+                    variables_schema,
+                    registry=non_fetching_registry(),
+                )
+            except referencing.exceptions.Unresolvable as exc:
+                raise jsonschema.ValidationError(str(exc)) from exc
 
 
 class DeploymentUpdate(ActionBaseModel):
@@ -403,7 +412,14 @@ class DeploymentUpdate(ActionBaseModel):
                         required.remove(k)
 
         if variables_schema is not None:
-            jsonschema.validate(self.job_variables, variables_schema)
+            try:
+                jsonschema.validate(
+                    self.job_variables,
+                    variables_schema,
+                    registry=non_fetching_registry(),
+                )
+            except referencing.exceptions.Unresolvable as exc:
+                raise jsonschema.ValidationError(str(exc)) from exc
 
 
 class DeploymentBranch(ActionBaseModel):

{prefect_client-3.7.4.dev4 → prefect_client-3.7.5}/src/prefect/client/schemas/schedules.py

@@ -26,6 +26,26 @@ MAX_ITERATIONS = 1000
 MAX_RRULE_LENGTH = 6500
 
 
+def _iana_timezone_name(tzinfo: datetime.tzinfo) -> str:
+    """Return a valid IANA timezone name for *tzinfo*, or `"UTC"`."""
+    for attr in ("key", "name"):
+        value: Optional[str] = getattr(tzinfo, attr, None)
+        if value and is_valid_timezone(value):
+            return value
+
+    filename: Optional[str] = getattr(tzinfo, "_filename", None)
+    if filename:
+        normalized = filename.replace("\\", "/")
+        marker = "/zoneinfo/"
+        idx = normalized.find(marker)
+        if idx != -1:
+            candidate = normalized[idx + len(marker) :]
+            if candidate and is_valid_timezone(candidate):
+                return candidate
+
+    return "UTC"
+
+
 def is_valid_timezone(v: str) -> bool:
     """
     Validate that the provided timezone is a valid IANA timezone.
@@ -204,26 +224,27 @@ class RRuleSchedule(PrefectBaseModel):
         if isinstance(rrule, dateutil.rrule.rrule):
             dtstart = _rrule_dt(rrule)
             if dtstart and dtstart.tzinfo is not None:
-                timezone = dtstart.tzinfo.tzname(dtstart)
+                timezone = _iana_timezone_name(dtstart.tzinfo)
             else:
                 timezone = "UTC"
             return RRuleSchedule(rrule=str(rrule), timezone=timezone)
         rrules = _rrule(rrule)
         dtstarts = [dts for rr in rrules if (dts := _rrule_dt(rr)) is not None]
         unique_dstarts = set(d.astimezone(ZoneInfo("UTC")) for d in dtstarts)
-        unique_timezones = set(d.tzinfo for d in dtstarts if d.tzinfo is not None)
+        unique_tz_names = set(
+            _iana_timezone_name(d.tzinfo) for d in dtstarts if d.tzinfo is not None
+        )
 
-        if len(unique_timezones) > 1:
+        if len(unique_tz_names) > 1:
             raise ValueError(
-                f"rruleset has too many dtstart timezones: {unique_timezones}"
+                f"rruleset has too many dtstart timezones: {unique_tz_names}"
             )
 
         if len(unique_dstarts) > 1:
             raise ValueError(f"rruleset has too many dtstarts: {unique_dstarts}")
 
-        if unique_dstarts and unique_timezones:
-            [unique_tz] = unique_timezones
-            timezone = unique_tz.tzname(dtstarts[0])
+        if unique_dstarts and unique_tz_names:
+            [timezone] = unique_tz_names
         else:
             timezone = "UTC"
 

{prefect_client-3.7.4.dev4 → prefect_client-3.7.5}/src/prefect/deployments/base.py

@@ -278,6 +278,33 @@ def _interval_schedule_to_dict(schedule: IntervalSchedule) -> dict[str, Any]:
     return schedule_config
 
 
+def _deployment_already_saved_to_prefect_file(
+    deployment: dict[str, Any],
+    prefect_file: Path = Path("prefect.yaml"),
+) -> bool:
+    """
+    Return True if `prefect.yaml` already contains a deployment entry matching the
+    given deployment's name and entrypoint.
+
+    Used to decide whether the interactive `prefect deploy` flow should offer to
+    persist a newly-created deployment: a deployment that is already declared in
+    the file does not need to be saved again, but a brand-new one (even when the
+    file otherwise exists) should still be offered up for saving.
+    """
+    if not prefect_file.exists():
+        return False
+
+    with prefect_file.open(mode="r") as f:
+        contents = yaml.safe_load(f) or {}
+
+    for existing in contents.get("deployments") or []:
+        if existing.get("name") == deployment.get("name") and existing.get(
+            "entrypoint"
+        ) == deployment.get("entrypoint"):
+            return True
+    return False
+
+
 def _save_deployment_to_prefect_file(
     deployment: dict[str, Any],
     build_steps: list[dict[str, Any]] | None = None,

{prefect_client-3.7.4.dev4 → prefect_client-3.7.5}/src/prefect/flow_engine.py

@@ -972,6 +972,7 @@ class FlowRunEngine(BaseFlowRunEngine[P, R]):
             parent_task = Task(
                 name=self.flow.name, fn=self.flow.fn, version=self.flow.version
             )
+            setattr(parent_task, "_is_subflow_tracking_task", True)
 
             parent_task_run = run_coro_as_sync(
                 parent_task.create_run(
@@ -1667,6 +1668,7 @@ class AsyncFlowRunEngine(BaseFlowRunEngine[P, R]):
             parent_task = Task(
                 name=self.flow.name, fn=self.flow.fn, version=self.flow.version
             )
+            setattr(parent_task, "_is_subflow_tracking_task", True)
 
             parent_task_run = await parent_task.create_run(
                 flow_run_context=flow_run_ctx,

{prefect_client-3.7.4.dev4 → prefect_client-3.7.5}/src/prefect/flows.py

@@ -706,7 +706,11 @@ class Flow(Generic[P, R]):
                 from fastapi.encoders import jsonable_encoder
 
                 serialized_parameters[key] = jsonable_encoder(value)
-            except (TypeError, ValueError):
+            except (TypeError, ValueError, RecursionError):
+                # `jsonable_encoder` recurses into unknown objects with no cycle
+                # or depth limit, so a deeply-nested or self-referential value
+                # raises `RecursionError`. Treat it like any other unserializable
+                # value and fall back to the placeholder below.
                 logger.debug(
                     f"Parameter {key!r} for flow {self.name!r} is unserializable. "
                     f"Type {type(value).__name__!r} and will not be stored "

{prefect_client-3.7.4.dev4 → prefect_client-3.7.5}/src/prefect/runner/AGENTS.md

@@ -15,7 +15,7 @@ Thin facade over single-responsibility extracted classes. New behavior belongs i
 | CancelFinalizer | _cancel_finalizer.py | Persist Cancelled state after kill; fall back to Crashed if state cannot be confirmed |
 | ControlChannel | _control_channel.py | Runner-side TCP loopback IPC for delivering cancel intent to child processes before kill |
 | HookRunner | _hook_runner.py | on_cancellation / on_crashed hook execution |
-| EventEmitter | _event_emitter.py | Event emission via EventsClient; degrades to NullEventsClient on WebSocket rejection |
+| EventEmitter | _event_emitter.py | Event emission via EventsClient; degrades to NullEventsClient on any WebSocket connection failure |
 | LimitManager | _limit_manager.py | Concurrency limiting |
 | DeploymentRegistry | _deployment_registry.py | Deployment/flow/storage/bundle maps |
 | ScheduledRunPoller | _scheduled_run_poller.py | Poll loop, run discovery, scheduling |
@@ -49,7 +49,7 @@ These will be removed once internal callers (notably ProcessWorker) are migrated
 
 ## EventEmitter WebSocket Degradation
 
-`EventEmitter.__aenter__` catches `websockets.exceptions.InvalidStatus` (HTTP 4xx rejections) and silently swaps the failed client for a `NullEventsClient`. This handles old clients (≤3.6.13) connecting to servers ≥3.6.14 with `PREFECT_SERVER_API_AUTH_STRING` configured — the server rejects the WebSocket handshake, but events are non-critical telemetry so the flow run must not crash. A `WARNING` is logged. If `__aenter__` raises, `__aexit__` is **not** called on the original client (it was never successfully entered); the replacement `NullEventsClient` is entered instead.
+`EventEmitter.__aenter__` catches connection failures and silently swaps the failed client for a `NullEventsClient` — events are non-critical telemetry (the runner emits only `prefect.runner.cancelled-flow-run`), so the flow run must not crash when the events WebSocket is unreachable. Two failure classes are caught (`_NONFATAL_CONNECTION_EXCEPTIONS`): permanent rejections (`websockets.exceptions.InvalidStatus`, i.e. HTTP 4xx — e.g. a client ≤3.6.13 connecting to a server ≥3.6.14 with `PREFECT_SERVER_API_AUTH_STRING` configured) and transient failures (`RETRYABLE_EXCEPTIONS` from `events/clients.py`: `ConnectionClosed`, `TimeoutError`, `OSError`) that outlive the events client's own reconnection attempts. A `WARNING` is logged. If `__aenter__` raises, `__aexit__` is **not** called on the original client (it was never successfully entered); the replacement `NullEventsClient` is entered instead.
 
 ## AsyncExitStack LIFO Ordering
 

{prefect_client-3.7.4.dev4 → prefect_client-3.7.5}/src/prefect/runner/_event_emitter.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING, Any, Callable
 from cachetools import TTLCache
 from websockets.exceptions import InvalidStatus as _WsInvalidStatus
 
-from prefect.events.clients import NullEventsClient
+from prefect.events.clients import RETRYABLE_EXCEPTIONS, NullEventsClient
 from prefect.events.related import tags_as_related_resources
 from prefect.events.schemas.events import Event, RelatedResource, Resource
 from prefect.logging import get_logger
@@ -18,12 +18,19 @@ if TYPE_CHECKING:
     from prefect.client.schemas.responses import DeploymentResponse
     from prefect.events.clients import EventsClient
 
-# Exceptions that indicate a permanent connection failure (e.g. auth rejected).
-# On these, EventEmitter degrades gracefully to NullEventsClient rather than
-# crashing the flow run.  This preserves backwards-compatibility with clients
-# running against a server that has PREFECT_SERVER_API_AUTH_STRING configured
-# (server >=3.6.14) where the WS handshake is rejected with HTTP 401/403.
-_NONFATAL_CONNECTION_EXCEPTIONS: tuple[type[Exception], ...] = (_WsInvalidStatus,)
+# Connection failures that must not crash the flow run.  The events WebSocket
+# carries non-critical telemetry, so a failure to connect degrades to
+# NullEventsClient rather than taking the flow run down with it.
+# - _WsInvalidStatus: the server rejected the handshake (HTTP 401/403), e.g. a
+#   client <=3.6.13 connecting to a server >=3.6.14 that has
+#   PREFECT_SERVER_API_AUTH_STRING configured.  A permanent failure.
+# - RETRYABLE_EXCEPTIONS: transient failures (handshake timeout, dropped
+#   connection, network errors) that the events client already retries; once
+#   those retries are exhausted the error must still not be fatal here.
+_NONFATAL_CONNECTION_EXCEPTIONS: tuple[type[Exception], ...] = (
+    _WsInvalidStatus,
+    *RETRYABLE_EXCEPTIONS,
+)
 
 
 def _default_get_events_client() -> "EventsClient":
@@ -60,17 +67,18 @@ class EventEmitter:
         try:
             await self._events_client.__aenter__()
         except _NONFATAL_CONNECTION_EXCEPTIONS as exc:
-            # The events WebSocket was rejected by the server (e.g. HTTP 401/403).
-            # This happens when an old client (<=3.6.13) connects to a server
-            # >=3.6.14 that has PREFECT_SERVER_API_AUTH_STRING configured: the
-            # server now requires the "prefect" subprotocol + auth handshake, but
-            # old clients omit it.  Events are non-critical telemetry, so we
-            # degrade gracefully instead of crashing the flow run.
+            # The events WebSocket could not be established -- either rejected by
+            # the server (HTTP 401/403, e.g. a client <=3.6.13 connecting to a
+            # server >=3.6.14 with PREFECT_SERVER_API_AUTH_STRING configured) or a
+            # transient connection failure that outlived the events client's own
+            # retries.  Events are non-critical telemetry, so degrade gracefully
+            # instead of crashing the flow run.
             self._logger.warning(
                 "Unable to connect to the events WebSocket (%s). "
-                "Event data will not be emitted for this runner. "
-                "Upgrade the Prefect client to >=3.6.14 to restore event support "
-                "when the server has authentication configured.",
+                "Event data will not be emitted for this runner; the flow run "
+                "will continue. Upgrade the Prefect client to >=3.6.14 to "
+                "restore event support if the server has authentication "
+                "configured.",
                 exc,
             )
             # __aenter__ failed, so __aexit__ must NOT be called on the original

{prefect_client-3.7.4.dev4 → prefect_client-3.7.5}/src/prefect/server/api/background_workers.py

@@ -14,6 +14,7 @@ from prefect.server.models.work_queues import mark_work_queues_ready
 from prefect.server.services.cancellation_cleanup import (
     cancel_child_task_runs,
     cancel_subflow_run,
+    handle_cancelling_timeout,
 )
 from prefect.server.services.db_vacuum import (
     vacuum_events_with_retention_overrides,
@@ -40,6 +41,7 @@ task_functions: list[Callable[..., Any]] = [
     delete_task_run_logs,
     delete_flow_run_logs,
     # Find-and-flood pattern tasks used by perpetual services
+    handle_cancelling_timeout,
     cancel_child_task_runs,
     cancel_subflow_run,
     fail_expired_pause,

{prefect_client-3.7.4.dev4 → prefect_client-3.7.5}/src/prefect/server/api/deployments.py

@@ -311,7 +311,11 @@ async def update_deployment(
             )
             try:
                 deployment.check_valid_configuration(work_pool.base_job_template)
-            except (MissingVariableError, jsonschema.exceptions.ValidationError) as exc:
+            except (
+                MissingVariableError,
+                jsonschema.exceptions.ValidationError,
+                ValidationError,
+            ) as exc:
                 raise HTTPException(
                     status_code=status.HTTP_409_CONFLICT,
                     detail=f"Error creating deployment: {exc!r}",

{prefect_client-3.7.4.dev4 → prefect_client-3.7.5}/src/prefect/server/api/flow_runs.py

@@ -13,13 +13,14 @@ from uuid import UUID
 import orjson
 import sqlalchemy as sa
 from docket import Depends as DocketDepends
-from docket import Retry
+from docket import Docket, Retry
 from fastapi import (
     Body,
     Depends,
     HTTPException,
     Path,
     Query,
+    Request,
     Response,
 )
 from fastapi.encoders import jsonable_encoder
@@ -53,6 +54,9 @@ from prefect.server.schemas.responses import (
     FlowRunPaginationResponse,
     OrchestrationResult,
 )
+from prefect.server.services.cancellation_cleanup import (
+    maybe_schedule_cancelling_timeout_check_for_state,
+)
 from prefect.server.utilities.server import PrefectRouter
 from prefect.types import DateTime
 from prefect.types._datetime import earliest_possible_datetime, now
@@ -66,9 +70,41 @@ logger: "logging.Logger" = get_logger("server.api")
 router: PrefectRouter = PrefectRouter(prefix="/flow_runs", tags=["Flow Runs"])
 
 
+def _get_request_docket(request: Request) -> Docket | None:
+    return getattr(request.app.state, "docket", None)
+
+
+async def _maybe_schedule_cancelling_timeout_check_for_state(
+    *,
+    request: Request,
+    flow_run_id: UUID,
+    state: schemas.states.State | None,
+) -> None:
+    docket = _get_request_docket(request)
+    if docket is None:
+        return
+
+    try:
+        await maybe_schedule_cancelling_timeout_check_for_state(
+            docket=docket,
+            flow_run_id=flow_run_id,
+            state=state,
+        )
+    except Exception:
+        logger.exception(
+            "Failed to schedule CANCELLING timeout check; allowing accepted "
+            "state transition to proceed",
+            extra={
+                "flow_run_id": str(flow_run_id),
+                "flow_run_state_id": str(state.id) if state and state.id else None,
+            },
+        )
+
+
 @router.post("/")
 async def create_flow_run(
     flow_run: schemas.actions.FlowRunCreate,
+    request: Request,
     db: PrefectDBInterface = Depends(provide_database_interface),
     response: Response = None,  # type: ignore
     created_by: Optional[schemas.core.CreatedBy] = Depends(dependencies.get_created_by),
@@ -124,13 +160,27 @@ async def create_flow_run(
             flow_run=flow_run_object,
             orchestration_parameters=orchestration_parameters,
         )
-        if model.created >= right_now:
-            response.status_code = status.HTTP_201_CREATED
-
-        return schemas.responses.FlowRunResponse.model_validate(
+        created = model.created >= right_now
+        timeout_check_state = (
+            schemas.states.State.from_orm_without_result(model.state)
+            if created and model.state
+            else None
+        )
+        flow_run_id = model.id
+        flow_run_response = schemas.responses.FlowRunResponse.model_validate(
             model, from_attributes=True
         )
 
+    await _maybe_schedule_cancelling_timeout_check_for_state(
+        request=request,
+        flow_run_id=flow_run_id,
+        state=timeout_check_state,
+    )
+    if created:
+        response.status_code = status.HTTP_201_CREATED
+
+    return flow_run_response
+
 
 @router.patch("/{id:uuid}", status_code=status.HTTP_204_NO_CONTENT)
 async def update_flow_run(
@@ -669,6 +719,7 @@ async def bulk_delete_flow_runs(
 
 @router.post("/bulk_set_state")
 async def bulk_set_flow_run_state(
+    request: Request,
     flow_runs: Optional[schemas.filters.FlowRunFilter] = Body(
         None, description="Filter criteria for flow runs to update"
     ),
@@ -718,6 +769,7 @@ async def bulk_set_flow_run_state(
 
     # Process flow runs sequentially to avoid session conflicts
     for flow_run in db_flow_runs:
+        state_to_schedule: schemas.states.State | None = None
         async with db.session_context(
             begin_transaction=True, with_for_update=True
         ) as session:
@@ -739,6 +791,11 @@ async def bulk_set_flow_run_state(
                         details=orchestration_result.details,
                     )
                 )
+                if (
+                    orchestration_result.status
+                    == schemas.responses.SetStateStatus.ACCEPT
+                ):
+                    state_to_schedule = orchestration_result.state
             except Exception as e:
                 results.append(
                     FlowRunOrchestrationResult(
@@ -748,6 +805,14 @@ async def bulk_set_flow_run_state(
                         details=schemas.responses.StateAbortDetails(reason=str(e)),
                     )
                 )
+                continue
+
+        if state_to_schedule is not None:
+            await _maybe_schedule_cancelling_timeout_check_for_state(
+                request=request,
+                flow_run_id=flow_run.id,
+                state=state_to_schedule,
+            )
 
     return FlowRunBulkSetStateResponse(results=results)
 
@@ -755,6 +820,7 @@ async def bulk_set_flow_run_state(
 @router.post("/{id:uuid}/set_state")
 async def set_flow_run_state(
     response: Response,
+    request: Request,
     flow_run_id: UUID = Path(..., description="The flow run id", alias="id"),
     state: schemas.actions.StateCreate = Body(..., description="The intended state."),
     force: bool = Body(
@@ -796,6 +862,13 @@ async def set_flow_run_state(
             client_version=client_version,
         )
 
+    if orchestration_result.status == schemas.responses.SetStateStatus.ACCEPT:
+        await _maybe_schedule_cancelling_timeout_check_for_state(
+            request=request,
+            flow_run_id=flow_run_id,
+            state=orchestration_result.state,
+        )
+
     # set the 201 if a new state was created
     if orchestration_result.state and orchestration_result.state.timestamp >= right_now:
         response.status_code = status.HTTP_201_CREATED

{prefect_client-3.7.4.dev4 → prefect_client-3.7.5}/src/prefect/server/api/server.py

@@ -10,6 +10,7 @@ import base64
 import contextlib
 import gc
 import hmac
+import importlib.metadata
 import logging
 import mimetypes
 import os
@@ -41,6 +42,7 @@ from fastapi.middleware.gzip import GZipMiddleware
 from fastapi.openapi.utils import get_openapi
 from fastapi.responses import JSONResponse, RedirectResponse
 from fastapi.staticfiles import StaticFiles
+from packaging.version import Version
 from starlette.exceptions import HTTPException
 from typing_extensions import Self
 
@@ -73,6 +75,12 @@ from prefect.utilities.hashing import hash_objects
 
 logfire: Any | None = configure_logfire()
 
+# FastAPI < 0.137 copies routes when including a router; 0.137+ keeps a
+# reference to the original via _IncludedRouter.
+_FASTAPI_COPIES_ROUTES_ON_INCLUDE: bool = Version(
+    importlib.metadata.version("fastapi")
+) < Version("0.137.0")
+
 TITLE = "Prefect Server"
 API_TITLE = "Prefect REST API"
 UI_TITLE = "Prefect REST API UI"
@@ -491,21 +499,16 @@ def create_api_app(
 
     for router in API_ROUTERS:
         api_app.include_router(router, dependencies=dependencies)
-        if final:
-            # Important note about how FastAPI works:
-            #
-            # When including a router, FastAPI copies the routes and builds entirely new
-            # Pydantic models to represent the request bodies of the routes in the
-            # router.  This is because the dependencies may change if the same router is
-            # included multiple times, but it also means that we are holding onto an
-            # entire set of Pydantic models on the original routers for the duration of
-            # the server process that will never be used.
+        if final and _FASTAPI_COPIES_ROUTES_ON_INCLUDE:
+            # When including a router, older versions of FastAPI (< 0.137) copy
+            # the routes and build entirely new Pydantic models.  Since Prefect
+            # does not reuse routers, we can delete the originals to reclaim
+            # ~50-55 MB of memory.
             #
-            # Because Prefect does not reuse routers, we are free to clean up the routes
-            # because we know they won't be used again.  Thus, if we have the hint that
-            # this is the final instance we will create in this process, we can clean up
-            # the routes on the original source routers to conserve memory (~50-55MB as
-            # of introducing this change).
+            # FastAPI 0.137+ wraps included routers in an _IncludedRouter that
+            # references the original router for request matching, so the
+            # originals must be kept.  The duplication no longer occurs in this
+            # case either, so the optimisation is unnecessary.
             del router.routes
 
     if final:
@@ -840,6 +843,22 @@ def _memoize_block_auto_registration(
     return wrapper
 
 
+def _log_worker_channel_config() -> None:
+    """Log worker channel queue backend and key configuration at startup."""
+    wc_settings = prefect.settings.get_current_settings().server.worker_channel
+    logger.debug(
+        "Worker channel configuration: "
+        "cleanup_queue_storage=%s "
+        "cleanup_lease_seconds=%s "
+        "cleanup_max_delivery_attempts=%s "
+        "cleanup_completed_idempotency_retention_seconds=%s",
+        wc_settings.cleanup_queue_storage,
+        wc_settings.cleanup_lease_seconds,
+        wc_settings.cleanup_max_delivery_attempts,
+        wc_settings.cleanup_completed_idempotency_retention_seconds,
+    )
+
+
 def create_app(
     settings: Optional[prefect.settings.Settings] = None,
     ephemeral: bool = False,
@@ -909,6 +928,8 @@ def create_app(
         await run_migrations()
         await add_block_types()
 
+        _log_worker_channel_config()
+
         Services: type[Service] | None = (
             RunInWebservers
             if webserver_only

{prefect_client-3.7.4.dev4 → prefect_client-3.7.5}/src/prefect/server/api/ui/schemas.py

@@ -10,6 +10,7 @@ from prefect.server.utilities.server import APIRouter
 from prefect.utilities.schema_tools.hydration import HydrationContext, hydrate
 from prefect.utilities.schema_tools.validation import (
     CircularSchemaRefError,
+    ValidationError,
     build_error_obj,
     is_valid_schema,
     preprocess_schema,
@@ -60,6 +61,11 @@ async def validate_obj(
             status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
             detail="Invalid schema: Unable to validate schema with circular references.",
         )
+    except ValidationError as exc:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=f"Invalid schema: {exc}",
+        )
     error_obj = build_error_obj(errors)
 
     return error_obj