prefect-client 3.1.14__py3-none-any.whl → 3.2.0__py3-none-any.whl

prefect/deployments/runner.py

@@ -49,6 +49,7 @@ from rich.progress import Progress, SpinnerColumn, TextColumn, track
 from rich.table import Table
 
 from prefect._experimental.sla.objects import SlaTypes
+from prefect._internal.compatibility.async_dispatch import async_dispatch
 from prefect._internal.concurrency.api import create_call, from_async
 from prefect._internal.schemas.validators import (
     reconcile_paused_deployment,
@@ -56,7 +57,7 @@ from prefect._internal.schemas.validators import (
 )
 from prefect.client.base import ServerType
 from prefect.client.orchestration import PrefectClient, get_client
-from prefect.client.schemas.actions import DeploymentScheduleCreate
+from prefect.client.schemas.actions import DeploymentScheduleCreate, DeploymentUpdate
 from prefect.client.schemas.filters import WorkerFilter, WorkerFilterStatus
 from prefect.client.schemas.objects import (
     ConcurrencyLimitConfig,
@@ -76,13 +77,14 @@ from prefect.exceptions import (
     PrefectHTTPStatusError,
 )
 from prefect.runner.storage import RunnerStorage
+from prefect.schedules import Schedule
 from prefect.settings import (
     PREFECT_DEFAULT_WORK_POOL_NAME,
     PREFECT_UI_URL,
 )
 from prefect.types import ListOfNonEmptyStrings
 from prefect.types.entrypoint import EntrypointType
-from prefect.utilities.asyncutils import sync_compatible
+from prefect.utilities.asyncutils import run_coro_as_sync, sync_compatible
 from prefect.utilities.callables import ParameterSchema, parameter_schema
 from prefect.utilities.collections import get_from_dict, isiterable
 from prefect.utilities.dockerutils import (
@@ -112,7 +114,7 @@ class RunnerDeployment(BaseModel):
         description: An optional description of the deployment; defaults to the flow's
             description
         tags: An optional list of tags to associate with this deployment; note that tags
-            are used only for organizational purposes. For delegating work to agents,
+            are used only for organizational purposes. For delegating work to workers,
             see `work_queue_name`.
         schedule: A schedule to run this deployment on, once registered
         parameters: A dictionary of parameter values to pass to runs created from this
@@ -228,6 +230,10 @@ class RunnerDeployment(BaseModel):
     def entrypoint_type(self) -> EntrypointType:
         return self._entrypoint_type
 
+    @property
+    def full_name(self) -> str:
+        return f"{self.flow_name}/{self.name}"
+
     @field_validator("name", mode="before")
     @classmethod
     def validate_name(cls, value: str) -> str:
@@ -254,24 +260,9 @@ class RunnerDeployment(BaseModel):
     def reconcile_schedules(cls, values):
         return reconcile_schedules_runner(values)
 
-    @sync_compatible
-    async def apply(
+    async def _create(
         self, work_pool_name: Optional[str] = None, image: Optional[str] = None
     ) -> UUID:
-        """
-        Registers this deployment with the API and returns the deployment's ID.
-
-        Args:
-            work_pool_name: The name of the work pool to use for this
-                deployment.
-            image: The registry, name, and tag of the Docker image to
-                use for this deployment. Only used when the deployment is
-                deployed to a work pool.
-
-        Returns:
-            The ID of the created deployment.
-        """
-
         work_pool_name = work_pool_name or self.work_pool_name
 
         if image and not work_pool_name:
@@ -323,9 +314,14 @@ class RunnerDeployment(BaseModel):
                 if image:
                     create_payload["job_variables"]["image"] = image
                 create_payload["path"] = None if self.storage else self._path
-                create_payload["pull_steps"] = (
-                    [self.storage.to_pull_step()] if self.storage else []
-                )
+                if self.storage:
+                    pull_steps = self.storage.to_pull_step()
+                    if isinstance(pull_steps, list):
+                        create_payload["pull_steps"] = pull_steps
+                    else:
+                        create_payload["pull_steps"] = [pull_steps]
+                else:
+                    create_payload["pull_steps"] = []
 
             try:
                 deployment_id = await client.create_deployment(**create_payload)
@@ -338,25 +334,7 @@ class RunnerDeployment(BaseModel):
                     f"Error while applying deployment: {str(exc)}"
                 ) from exc
 
-            try:
-                # The triggers defined in the deployment spec are, essentially,
-                # anonymous and attempting truly sync them with cloud is not
-                # feasible. Instead, we remove all automations that are owned
-                # by the deployment, meaning that they were created via this
-                # mechanism below, and then recreate them.
-                await client.delete_resource_owned_automations(
-                    f"prefect.deployment.{deployment_id}"
-                )
-            except PrefectHTTPStatusError as e:
-                if e.response.status_code == 404:
-                    # This Prefect server does not support automations, so we can safely
-                    # ignore this 404 and move on.
-                    return deployment_id
-                raise e
-
-            for trigger in self.triggers:
-                trigger.set_deployment_id(deployment_id)
-                await client.create_automation(trigger.as_automation())
+            await self._create_triggers(deployment_id, client)
 
             # We plan to support SLA configuration on the Prefect Server in the future.
             # For now, we only support it on Prefect Cloud.
@@ -369,6 +347,86 @@ class RunnerDeployment(BaseModel):
 
             return deployment_id
 
+    async def _update(self, deployment_id: UUID, client: PrefectClient):
+        parameter_openapi_schema = self._parameter_openapi_schema.model_dump(
+            exclude_unset=True
+        )
+        await client.update_deployment(
+            deployment_id,
+            deployment=DeploymentUpdate(
+                parameter_openapi_schema=parameter_openapi_schema,
+                **self.model_dump(
+                    mode="json",
+                    exclude_unset=True,
+                    exclude={"storage", "name", "flow_name", "triggers"},
+                ),
+            ),
+        )
+
+        await self._create_triggers(deployment_id, client)
+
+        # We plan to support SLA configuration on the Prefect Server in the future.
+        # For now, we only support it on Prefect Cloud.
+
+        # If we're provided with an empty list, we will call the apply endpoint
+        # to remove existing SLAs for the deployment. If the argument is not provided,
+        # we will not call the endpoint.
+        if self._sla or self._sla == []:
+            await self._create_slas(deployment_id, client)
+
+        return deployment_id
+
+    async def _create_triggers(self, deployment_id: UUID, client: PrefectClient):
+        try:
+            # The triggers defined in the deployment spec are, essentially,
+            # anonymous and attempting truly sync them with cloud is not
+            # feasible. Instead, we remove all automations that are owned
+            # by the deployment, meaning that they were created via this
+            # mechanism below, and then recreate them.
+            await client.delete_resource_owned_automations(
+                f"prefect.deployment.{deployment_id}"
+            )
+        except PrefectHTTPStatusError as e:
+            if e.response.status_code == 404:
+                # This Prefect server does not support automations, so we can safely
+                # ignore this 404 and move on.
+                return deployment_id
+            raise e
+
+        for trigger in self.triggers:
+            trigger.set_deployment_id(deployment_id)
+            await client.create_automation(trigger.as_automation())
+
+    @sync_compatible
+    async def apply(
+        self, work_pool_name: Optional[str] = None, image: Optional[str] = None
+    ) -> UUID:
+        """
+        Registers this deployment with the API and returns the deployment's ID.
+
+        Args:
+            work_pool_name: The name of the work pool to use for this
+                deployment.
+            image: The registry, name, and tag of the Docker image to
+                use for this deployment. Only used when the deployment is
+                deployed to a work pool.
+
+        Returns:
+            The ID of the created deployment.
+        """
+
+        async with get_client() as client:
+            try:
+                deployment = await client.read_deployment_by_name(self.full_name)
+            except ObjectNotFound:
+                return await self._create(work_pool_name, image)
+            else:
+                if image:
+                    self.job_variables["image"] = image
+                if work_pool_name:
+                    self.work_pool_name = work_pool_name
+                return await self._update(deployment.id, client)
+
     async def _create_slas(self, deployment_id: UUID, client: PrefectClient):
         if not isinstance(self._sla, list):
             self._sla = [self._sla]
@@ -389,7 +447,7 @@ class RunnerDeployment(BaseModel):
         cron: Optional[Union[Iterable[str], str]] = None,
         rrule: Optional[Union[Iterable[str], str]] = None,
         timezone: Optional[str] = None,
-        schedule: Optional[SCHEDULE_TYPES] = None,
+        schedule: Union[SCHEDULE_TYPES, Schedule, None] = None,
         schedules: Optional["FlexibleScheduleList"] = None,
     ) -> Union[List[DeploymentScheduleCreate], "FlexibleScheduleList"]:
         """
@@ -421,7 +479,6 @@ class RunnerDeployment(BaseModel):
               this list is returned as-is, bypassing other schedule construction
               logic.
         """
-
         num_schedules = sum(
             1
             for entry in (interval, cron, rrule, schedule, schedules)
@@ -429,7 +486,7 @@ class RunnerDeployment(BaseModel):
         )
         if num_schedules > 1:
             raise ValueError(
-                "Only one of interval, cron, rrule, or schedules can be provided."
+                "Only one of interval, cron, rrule, schedule, or schedules can be provided."
             )
         elif num_schedules == 0:
             return []
@@ -482,6 +539,7 @@ class RunnerDeployment(BaseModel):
         cron: Optional[Union[Iterable[str], str]] = None,
         rrule: Optional[Union[Iterable[str], str]] = None,
         paused: Optional[bool] = None,
+        schedule: Optional[Schedule] = None,
         schedules: Optional["FlexibleScheduleList"] = None,
         concurrency_limit: Optional[Union[int, ConcurrencyLimitConfig, None]] = None,
         parameters: Optional[dict[str, Any]] = None,
@@ -507,6 +565,8 @@ class RunnerDeployment(BaseModel):
             cron: A cron schedule of when to execute runs of this flow.
             rrule: An rrule schedule of when to execute runs of this flow.
             paused: Whether or not to set this deployment as paused.
+            schedule: A schedule object defining when to execute runs of this deployment.
+                Used to provide additional scheduling options like `timezone` or `parameters`.
             schedules: A list of schedule objects defining when to execute runs of this deployment.
                 Used to define multiple schedules or additional scheduling options like `timezone`.
             concurrency_limit: The maximum number of concurrent runs this deployment will allow.
@@ -532,6 +592,7 @@ class RunnerDeployment(BaseModel):
             cron=cron,
             rrule=rrule,
             schedules=schedules,
+            schedule=schedule,
         )
 
         job_variables = job_variables or {}
@@ -626,6 +687,7 @@ class RunnerDeployment(BaseModel):
         cron: Optional[Union[Iterable[str], str]] = None,
         rrule: Optional[Union[Iterable[str], str]] = None,
         paused: Optional[bool] = None,
+        schedule: Optional[Schedule] = None,
         schedules: Optional["FlexibleScheduleList"] = None,
         concurrency_limit: Optional[Union[int, ConcurrencyLimitConfig, None]] = None,
         parameters: Optional[dict[str, Any]] = None,
@@ -681,6 +743,7 @@ class RunnerDeployment(BaseModel):
             cron=cron,
             rrule=rrule,
             schedules=schedules,
+            schedule=schedule,
         )
 
         if isinstance(concurrency_limit, ConcurrencyLimitConfig):
@@ -717,8 +780,7 @@ class RunnerDeployment(BaseModel):
         return deployment
 
     @classmethod
-    @sync_compatible
-    async def from_storage(
+    async def afrom_storage(
         cls,
         storage: RunnerStorage,
         entrypoint: str,
@@ -730,6 +792,7 @@ class RunnerDeployment(BaseModel):
         cron: Optional[Union[Iterable[str], str]] = None,
         rrule: Optional[Union[Iterable[str], str]] = None,
         paused: Optional[bool] = None,
+        schedule: Optional[Schedule] = None,
         schedules: Optional["FlexibleScheduleList"] = None,
         concurrency_limit: Optional[Union[int, ConcurrencyLimitConfig, None]] = None,
         parameters: Optional[dict[str, Any]] = None,
@@ -742,7 +805,7 @@ class RunnerDeployment(BaseModel):
         work_queue_name: Optional[str] = None,
         job_variables: Optional[dict[str, Any]] = None,
         _sla: Optional[Union[SlaTypes, list[SlaTypes]]] = None,  # experimental
-    ):
+    ) -> "RunnerDeployment":
         """
         Create a RunnerDeployment from a flow located at a given entrypoint and stored in a
         local storage location.
@@ -758,6 +821,11 @@ class RunnerDeployment(BaseModel):
                 or a timedelta object. If a number is given, it will be interpreted as seconds.
             cron: A cron schedule of when to execute runs of this flow.
             rrule: An rrule schedule of when to execute runs of this flow.
+            paused: Whether or not the deployment is paused.
+            schedule: A schedule object defining when to execute runs of this deployment.
+                Used to provide additional scheduling options like `timezone` or `parameters`.
+            schedules: A list of schedule objects defining when to execute runs of this deployment.
+                Used to provide additional scheduling options like `timezone` or `parameters`.
             triggers: A list of triggers that should kick of a run of this flow.
             parameters: A dictionary of default parameter values to pass to runs of this flow.
             description: A description for the created deployment. Defaults to the flow's
@@ -782,6 +850,7 @@ class RunnerDeployment(BaseModel):
             cron=cron,
             rrule=rrule,
             schedules=schedules,
+            schedule=schedule,
         )
 
         if isinstance(concurrency_limit, ConcurrencyLimitConfig):
@@ -831,6 +900,126 @@ class RunnerDeployment(BaseModel):
 
         return deployment
 
+    @classmethod
+    @async_dispatch(afrom_storage)
+    def from_storage(
+        cls,
+        storage: RunnerStorage,
+        entrypoint: str,
+        name: str,
+        flow_name: Optional[str] = None,
+        interval: Optional[
+            Union[Iterable[Union[int, float, timedelta]], int, float, timedelta]
+        ] = None,
+        cron: Optional[Union[Iterable[str], str]] = None,
+        rrule: Optional[Union[Iterable[str], str]] = None,
+        paused: Optional[bool] = None,
+        schedule: Optional[Schedule] = None,
+        schedules: Optional["FlexibleScheduleList"] = None,
+        concurrency_limit: Optional[Union[int, ConcurrencyLimitConfig, None]] = None,
+        parameters: Optional[dict[str, Any]] = None,
+        triggers: Optional[List[Union[DeploymentTriggerTypes, TriggerTypes]]] = None,
+        description: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+        version: Optional[str] = None,
+        enforce_parameter_schema: bool = True,
+        work_pool_name: Optional[str] = None,
+        work_queue_name: Optional[str] = None,
+        job_variables: Optional[dict[str, Any]] = None,
+        _sla: Optional[Union[SlaTypes, list[SlaTypes]]] = None,  # experimental
+    ) -> "RunnerDeployment":
+        """
+        Create a RunnerDeployment from a flow located at a given entrypoint and stored in a
+        local storage location.
+
+        Args:
+            entrypoint:  The path to a file containing a flow and the name of the flow function in
+                the format `./path/to/file.py:flow_func_name`.
+            name: A name for the deployment
+            flow_name: The name of the flow to deploy
+            storage: A storage object to use for retrieving flow code. If not provided, a
+                URL must be provided.
+            interval: An interval on which to execute the current flow. Accepts either a number
+                or a timedelta object. If a number is given, it will be interpreted as seconds.
+            cron: A cron schedule of when to execute runs of this flow.
+            rrule: An rrule schedule of when to execute runs of this flow.
+            paused: Whether or not the deployment is paused.
+            schedule: A schedule object defining when to execute runs of this deployment.
+                Used to provide additional scheduling options like `timezone` or `parameters`.
+            schedules: A list of schedule objects defining when to execute runs of this deployment.
+                Used to provide additional scheduling options like `timezone` or `parameters`.
+            triggers: A list of triggers that should kick of a run of this flow.
+            parameters: A dictionary of default parameter values to pass to runs of this flow.
+            description: A description for the created deployment. Defaults to the flow's
+                description if not provided.
+            tags: A list of tags to associate with the created deployment for organizational
+                purposes.
+            version: A version for the created deployment. Defaults to the flow's version.
+            enforce_parameter_schema: Whether or not the Prefect API should enforce the
+                parameter schema for this deployment.
+            work_pool_name: The name of the work pool to use for this deployment.
+            work_queue_name: The name of the work queue to use for this deployment's scheduled runs.
+                If not provided the default work queue for the work pool will be used.
+            job_variables: Settings used to override the values specified default base job template
+                of the chosen work pool. Refer to the base job template of the chosen work pool for
+                available settings.
+            _sla: (Experimental) SLA configuration for the deployment. May be removed or modified at any time. Currently only supported on Prefect Cloud.
+        """
+        from prefect.flows import load_flow_from_entrypoint
+
+        constructed_schedules = cls._construct_deployment_schedules(
+            interval=interval,
+            cron=cron,
+            rrule=rrule,
+            schedules=schedules,
+            schedule=schedule,
+        )
+
+        if isinstance(concurrency_limit, ConcurrencyLimitConfig):
+            concurrency_options = {
+                "collision_strategy": concurrency_limit.collision_strategy
+            }
+            concurrency_limit = concurrency_limit.limit
+        else:
+            concurrency_options = None
+
+        job_variables = job_variables or {}
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            storage.set_base_path(Path(tmpdir))
+            run_coro_as_sync(storage.pull_code())
+
+            full_entrypoint = str(storage.destination / entrypoint)
+            flow = load_flow_from_entrypoint(full_entrypoint)
+
+        deployment = cls(
+            name=Path(name).stem,
+            flow_name=flow_name or flow.name,
+            schedules=constructed_schedules,
+            concurrency_limit=concurrency_limit,
+            concurrency_options=concurrency_options,
+            paused=paused,
+            tags=tags or [],
+            triggers=triggers or [],
+            parameters=parameters or {},
+            description=description,
+            version=version,
+            entrypoint=entrypoint,
+            enforce_parameter_schema=enforce_parameter_schema,
+            storage=storage,
+            work_pool_name=work_pool_name,
+            work_queue_name=work_queue_name,
+            job_variables=job_variables,
+        )
+        deployment._sla = _sla
+        deployment._path = str(storage.destination).replace(
+            tmpdir, "$STORAGE_BASE_PATH"
+        )
+
+        cls._set_defaults_from_flow(deployment, flow)
+
+        return deployment
+
 
 @sync_compatible
 async def deploy(

prefect/deployments/schedules.py

@@ -2,6 +2,7 @@ from typing import TYPE_CHECKING, Any, List, Optional, Sequence, Union
 
 from prefect.client.schemas.actions import DeploymentScheduleCreate
 from prefect.client.schemas.schedules import is_schedule_type
+from prefect.schedules import Schedule
 
 if TYPE_CHECKING:
     from prefect.client.schemas.schedules import SCHEDULE_TYPES
@@ -12,10 +13,13 @@ FlexibleScheduleList = Sequence[
 
 
 def create_deployment_schedule_create(
-    schedule: "SCHEDULE_TYPES",
+    schedule: Union["SCHEDULE_TYPES", "Schedule"],
     active: Optional[bool] = True,
 ) -> DeploymentScheduleCreate:
     """Create a DeploymentScheduleCreate object from common schedule parameters."""
+
+    if isinstance(schedule, Schedule):
+        return DeploymentScheduleCreate.from_schedule(schedule)
     return DeploymentScheduleCreate(
         schedule=schedule,
         active=active if active is not None else True,
@@ -30,6 +34,8 @@ def normalize_to_deployment_schedule_create(
         for obj in schedules:
             if is_schedule_type(obj):
                 normalized.append(create_deployment_schedule_create(obj))
+            elif isinstance(obj, Schedule):
+                normalized.append(create_deployment_schedule_create(obj))
             elif isinstance(obj, dict):
                 normalized.append(create_deployment_schedule_create(**obj))
             elif isinstance(obj, DeploymentScheduleCreate):

prefect/engine.py

@@ -62,18 +62,13 @@ if __name__ == "__main__":
         else:
             run_flow(flow, flow_run=flow_run, error_logger=run_logger)
 
-    except Abort as abort_signal:
-        abort_signal: Abort
+    except Abort:
         engine_logger.info(
-            f"Engine execution of flow run '{flow_run_id}' aborted by orchestrator:"
-            f" {abort_signal}"
+            "Engine execution of flow run '{flow_run_id}' aborted by orchestrator."
         )
         exit(0)
-    except Pause as pause_signal:
-        pause_signal: Pause
-        engine_logger.info(
-            f"Engine execution of flow run '{flow_run_id}' is paused: {pause_signal}"
-        )
+    except Pause:
+        engine_logger.info(f"Engine execution of flow run '{flow_run_id}' is paused.")
         exit(0)
     except Exception:
         engine_logger.error(

prefect/events/clients.py

@@ -1,6 +1,7 @@
 import abc
 import asyncio
 import os
+import ssl
 from types import TracebackType
 from typing import (
     TYPE_CHECKING,
@@ -37,6 +38,7 @@ from prefect.events import Event
 from prefect.logging import get_logger
 from prefect.settings import (
     PREFECT_API_KEY,
+    PREFECT_API_TLS_INSECURE_SKIP_VERIFY,
     PREFECT_API_URL,
     PREFECT_CLOUD_API_URL,
     PREFECT_DEBUG_MODE,
@@ -120,6 +122,13 @@ class WebsocketProxyConnect(Connect):
         self._host = host
         self._port = port
 
+        if PREFECT_API_TLS_INSECURE_SKIP_VERIFY:
+            # Create an unverified context for insecure connections
+            ctx = ssl.create_default_context()
+            ctx.check_hostname = False
+            ctx.verify_mode = ssl.CERT_NONE
+            self._kwargs.setdefault("ssl", ctx)
+
     async def _proxy_connect(self: Self) -> WebSocketClientProtocol:
         if self._proxy:
             sock = await self._proxy.connect(
@@ -348,16 +357,26 @@ class PrefectEventsClient(EventsClient):
         await self._connect.__aexit__(exc_type, exc_val, exc_tb)
         return await super().__aexit__(exc_type, exc_val, exc_tb)
 
+    def _log_debug(self, message: str, *args, **kwargs) -> None:
+        message = f"EventsClient(id={id(self)}): " + message
+        logger.debug(message, *args, **kwargs)
+
     async def _reconnect(self) -> None:
+        logger.debug("Reconnecting websocket connection.")
+
         if self._websocket:
             self._websocket = None
             await self._connect.__aexit__(None, None, None)
+            logger.debug("Cleared existing websocket connection.")
 
         try:
+            logger.debug("Opening websocket connection.")
             self._websocket = await self._connect.__aenter__()
             # make sure we have actually connected
+            logger.debug("Pinging to ensure websocket connected.")
             pong = await self._websocket.ping()
             await pong
+            logger.debug("Pong received. Websocket connected.")
         except Exception as e:
             # The client is frequently run in a background thread
             # so we log an additional warning to ensure
@@ -375,11 +394,13 @@ class PrefectEventsClient(EventsClient):
             raise
 
         events_to_resend = self._unconfirmed_events
+        logger.debug("Resending %s unconfirmed events.", len(events_to_resend))
         # Clear the unconfirmed events here, because they are going back through emit
         # and will be added again through the normal checkpointing process
         self._unconfirmed_events = []
         for event in events_to_resend:
             await self.emit(event)
+        logger.debug("Finished resending unconfirmed events.")
 
     async def _checkpoint(self, event: Event) -> None:
         assert self._websocket
@@ -387,11 +408,20 @@ class PrefectEventsClient(EventsClient):
         self._unconfirmed_events.append(event)
 
         unconfirmed_count = len(self._unconfirmed_events)
+
+        logger.debug(
+            "Added event id=%s to unconfirmed events list. "
+            "There are now %s unconfirmed events.",
+            event.id,
+            unconfirmed_count,
+        )
         if unconfirmed_count < self._checkpoint_every:
             return
 
+        logger.debug("Pinging to checkpoint unconfirmed events.")
         pong = await self._websocket.ping()
         await pong
+        self._log_debug("Pong received. Events checkpointed.")
 
         # once the pong returns, we know for sure that we've sent all the messages
         # we had enqueued prior to that.  There could be more that came in after, so
@@ -401,7 +431,9 @@ class PrefectEventsClient(EventsClient):
         EVENT_WEBSOCKET_CHECKPOINTS.labels(self.client_name).inc()
 
     async def _emit(self, event: Event) -> None:
+        self._log_debug("Emitting event id=%s.", event.id)
         for i in range(self._reconnection_attempts + 1):
+            self._log_debug("Emit reconnection attempt %s.", i)
             try:
                 # If we're here and the websocket is None, then we've had a failure in a
                 # previous reconnection attempt.
@@ -410,14 +442,18 @@ class PrefectEventsClient(EventsClient):
                 # from a ConnectionClosed, so reconnect now, resending any unconfirmed
                 # events before we send this one.
                 if not self._websocket or i > 0:
+                    self._log_debug("Attempting websocket reconnection.")
                     await self._reconnect()
                     assert self._websocket
 
+                self._log_debug("Sending event id=%s.", event.id)
                 await self._websocket.send(event.model_dump_json())
+                self._log_debug("Checkpointing event id=%s.", event.id)
                 await self._checkpoint(event)
 
                 return
             except ConnectionClosed:
+                self._log_debug("Got ConnectionClosed error.")
                 if i == self._reconnection_attempts:
                     # this was our final chance, raise the most recent error
                     raise
@@ -426,6 +462,9 @@ class PrefectEventsClient(EventsClient):
                     # let the first two attempts happen quickly in case this is just
                     # a standard load balancer timeout, but after that, just take a
                     # beat to let things come back around.
+                    logger.debug(
+                        "Sleeping for 1 second before next reconnection attempt."
+                    )
                     await asyncio.sleep(1)
 
 

prefect/events/schemas/automations.py

@@ -198,7 +198,9 @@ class EventTrigger(ResourceTrigger):
                     "10 seconds"
                 )
 
-        return data | {"within": within} if within else data
+        if within:
+            data = {**data, "within": within}
+        return data
 
     def describe_for_cli(self, indent: int = 0) -> str:
         """Return a human-readable description of this trigger for the CLI"""
@@ -248,7 +250,7 @@ class MetricTriggerQuery(PrefectBaseModel):
     threshold: float = Field(
         ...,
         description=(
-            "The threshold value against which we'll compare " "the query result."
+            "The threshold value against which we'll compare the query result."
         ),
     )
     operator: MetricTriggerOperator = Field(