prefect-client 2.19.3__py3-none-any.whl → 3.0.0rc1__py3-none-any.whl

prefect/events/actions.py

@@ -2,14 +2,8 @@ import abc
 from typing import Any, Dict, Optional, Union
 from uuid import UUID
 
-from typing_extensions import Literal, TypeAlias
-
-from prefect._internal.pydantic import HAS_PYDANTIC_V2
-
-if HAS_PYDANTIC_V2:
-    from pydantic.v1 import Field, root_validator
-else:
-    from pydantic import Field, root_validator  # type: ignore
+from pydantic import Field, model_validator
+from typing_extensions import Literal, Self, TypeAlias
 
 from prefect._internal.schemas.bases import PrefectBaseModel
 from prefect.client.schemas.objects import StateType
@@ -49,16 +43,16 @@ class DeploymentAction(Action):
         None, description="The identifier of the deployment"
     )
 
-    @root_validator
-    def selected_deployment_requires_id(cls, values):
-        wants_selected_deployment = values.get("source") == "selected"
-        has_deployment_id = bool(values.get("deployment_id"))
+    @model_validator(mode="after")
+    def selected_deployment_requires_id(self):
+        wants_selected_deployment = self.source == "selected"
+        has_deployment_id = bool(self.deployment_id)
         if wants_selected_deployment != has_deployment_id:
             raise ValueError(
                 "deployment_id is "
                 + ("not allowed" if has_deployment_id else "required")
             )
-        return values
+        return self
 
 
 class RunDeployment(DeploymentAction):
@@ -199,16 +193,16 @@ class WorkQueueAction(Action):
         None, description="The identifier of the work queue to pause"
     )
 
-    @root_validator
-    def selected_work_queue_requires_id(cls, values):
-        wants_selected_work_queue = values.get("source") == "selected"
-        has_work_queue_id = bool(values.get("work_queue_id"))
+    @model_validator(mode="after")
+    def selected_work_queue_requires_id(self) -> Self:
+        wants_selected_work_queue = self.source == "selected"
+        has_work_queue_id = bool(self.work_queue_id)
         if wants_selected_work_queue != has_work_queue_id:
             raise ValueError(
                 "work_queue_id is "
                 + ("not allowed" if has_work_queue_id else "required")
             )
-        return values
+        return self
 
 
 class PauseWorkQueue(WorkQueueAction):
@@ -241,16 +235,16 @@ class AutomationAction(Action):
         None, description="The identifier of the automation to act on"
     )
 
-    @root_validator
-    def selected_automation_requires_id(cls, values):
-        wants_selected_automation = values.get("source") == "selected"
-        has_automation_id = bool(values.get("automation_id"))
+    @model_validator(mode="after")
+    def selected_automation_requires_id(self) -> Self:
+        wants_selected_automation = self.source == "selected"
+        has_automation_id = bool(self.automation_id)
         if wants_selected_automation != has_automation_id:
             raise ValueError(
                 "automation_id is "
                 + ("not allowed" if has_automation_id else "required")
             )
-        return values
+        return self
 
 
 class PauseAutomation(AutomationAction):

prefect/events/cli/automations.py

@@ -3,19 +3,20 @@ Command line interface for working with automations.
 """
 
 import functools
-from typing import Optional
+from typing import Optional, Type
 from uuid import UUID
 
 import orjson
 import typer
 import yaml as pyyaml
+from pydantic import BaseModel
 from rich.pretty import Pretty
 from rich.table import Table
 from rich.text import Text
 
 from prefect.cli._types import PrefectTyper
 from prefect.cli._utilities import exit_with_error, exit_with_success
-from prefect.cli.root import app
+from prefect.cli.root import app, is_interactive
 from prefect.client.orchestration import get_client
 from prefect.events.schemas.automations import Automation
 from prefect.exceptions import PrefectHTTPStatusError
@@ -148,10 +149,22 @@ async def inspect(
                 exit_with_error(f"Automation with id {id!r} not found.")
 
     if yaml or json:
+
+        def no_really_json(obj: Type[BaseModel]):
+            # Working around a weird bug where pydantic isn't rendering enums as strings
+            #
+            # automation.trigger.model_dump(mode="json")
+            # {..., 'posture': 'Reactive', ...}
+            #
+            # automation.model_dump(mode="json")
+            # {..., 'posture': Posture.Reactive, ...}
+            return orjson.loads(obj.model_dump_json())
+
         if isinstance(automation, list):
-            automation = [a.dict(json_compatible=True) for a in automation]
+            automation = [no_really_json(a) for a in automation]
         elif isinstance(automation, Automation):
-            automation = automation.dict(json_compatible=True)
+            automation = no_really_json(automation)
+
         if yaml:
             app.console.print(pyyaml.dump(automation, sort_keys=False))
         elif json:
@@ -297,7 +310,7 @@ async def delete(
             automation = await client.read_automation(id)
             if not automation:
                 exit_with_error(f"Automation with id {id!r} not found.")
-            if not typer.confirm(
+            if is_interactive() and not typer.confirm(
                 (f"Are you sure you want to delete automation with id {id!r}?"),
                 default=False,
             ):
@@ -315,7 +328,7 @@ async def delete(
                 exit_with_error(
                     f"Multiple automations found with name {name!r}. Please specify an id with the `--id` flag instead."
                 )
-            if not typer.confirm(
+            if is_interactive() and not typer.confirm(
                 (f"Are you sure you want to delete automation with name {name!r}?"),
                 default=False,
             ):

prefect/events/clients.py

@@ -31,12 +31,7 @@ from websockets.exceptions import (
 from prefect.client.base import PrefectHttpxAsyncClient
 from prefect.events import Event
 from prefect.logging import get_logger
-from prefect.settings import (
-    PREFECT_API_KEY,
-    PREFECT_API_URL,
-    PREFECT_CLOUD_API_URL,
-    PREFECT_EXPERIMENTAL_EVENTS,
-)
+from prefect.settings import PREFECT_API_KEY, PREFECT_API_URL, PREFECT_CLOUD_API_URL
 
 if TYPE_CHECKING:
     from prefect.events.filters import EventFilter
@@ -54,20 +49,13 @@ def get_events_client(
             reconnection_attempts=reconnection_attempts,
             checkpoint_every=checkpoint_every,
         )
-    elif PREFECT_EXPERIMENTAL_EVENTS:
-        if PREFECT_API_URL:
-            return PrefectEventsClient(
-                reconnection_attempts=reconnection_attempts,
-                checkpoint_every=checkpoint_every,
-            )
-        else:
-            return PrefectEphemeralEventsClient()
-
-    raise RuntimeError(
-        "The current server and client configuration does not support "
-        "events.  Enable experimental events support with the "
-        "PREFECT_EXPERIMENTAL_EVENTS setting."
-    )
+    elif PREFECT_API_URL:
+        return PrefectEventsClient(
+            reconnection_attempts=reconnection_attempts,
+            checkpoint_every=checkpoint_every,
+        )
+    else:
+        return PrefectEphemeralEventsClient()
 
 
 def get_events_subscriber(
@@ -79,17 +67,11 @@ def get_events_subscriber(
         return PrefectCloudEventSubscriber(
             filter=filter, reconnection_attempts=reconnection_attempts
         )
-    elif PREFECT_EXPERIMENTAL_EVENTS:
+    else:
         return PrefectEventSubscriber(
             filter=filter, reconnection_attempts=reconnection_attempts
         )
 
-    raise RuntimeError(
-        "The current server and client configuration does not support "
-        "events.  Enable experimental events support with the "
-        "PREFECT_EXPERIMENTAL_EVENTS setting."
-    )
-
 
 class EventsClient(abc.ABC):
     """The abstract interface for all Prefect Events clients"""
@@ -132,7 +114,7 @@ class AssertingEventsClient(EventsClient):
     """A Prefect Events client that records all events sent to it for inspection during
     tests."""
 
-    last: ClassVar["AssertingEventsClient | None"] = None
+    last: ClassVar["Optional[AssertingEventsClient]"] = None
     all: ClassVar[List["AssertingEventsClient"]] = []
 
     args: Tuple
@@ -179,11 +161,6 @@ class PrefectEphemeralEventsClient(EventsClient):
     """A Prefect Events client that sends events to an ephemeral Prefect server"""
 
     def __init__(self):
-        if not PREFECT_EXPERIMENTAL_EVENTS:
-            raise ValueError(
-                "PrefectEphemeralEventsClient can only be used when "
-                "PREFECT_EXPERIMENTAL_EVENTS is set to True"
-            )
         if PREFECT_API_KEY.value():
             raise ValueError(
                 "PrefectEphemeralEventsClient cannot be used when PREFECT_API_KEY is set."
@@ -217,7 +194,7 @@ class PrefectEphemeralEventsClient(EventsClient):
     async def _emit(self, event: Event) -> None:
         await self._http_client.post(
             "/events",
-            json=[event.dict(json_compatible=True)],
+            json=[event.model_dump(mode="json")],
         )
 
 
@@ -324,7 +301,7 @@ class PrefectEventsClient(EventsClient):
                     await self._reconnect()
                     assert self._websocket
 
-                await self._websocket.send(event.json())
+                await self._websocket.send(event.model_dump_json())
                 await self._checkpoint(event)
 
                 return
@@ -489,7 +466,7 @@ class PrefectEventSubscriber:
         logger.debug("  filtering events since %s...", self._filter.occurred.since)
         filter_message = {
             "type": "filter",
-            "filter": self._filter.dict(json_compatible=True),
+            "filter": self._filter.model_dump(mode="json"),
         }
         await self._websocket.send(orjson.dumps(filter_message).decode())
 
@@ -520,7 +497,7 @@ class PrefectEventSubscriber:
 
                 while True:
                     message = orjson.loads(await self._websocket.recv())
-                    event: Event = Event.parse_obj(message["event"])
+                    event: Event = Event.model_validate(message["event"])
 
                     if event.id in self._seen_events:
                         continue

prefect/events/filters.py

@@ -2,24 +2,19 @@ from typing import List, Optional, Tuple, cast
 from uuid import UUID
 
 import pendulum
+from pydantic import Field, PrivateAttr
+from pydantic_extra_types.pendulum_dt import DateTime
 
-from prefect._internal.pydantic import HAS_PYDANTIC_V2
 from prefect._internal.schemas.bases import PrefectBaseModel
-from prefect._internal.schemas.fields import DateTimeTZ
 from prefect.utilities.collections import AutoEnum
 
 from .schemas.events import Event, Resource, ResourceSpecification
 
-if HAS_PYDANTIC_V2:
-    from pydantic.v1 import Field, PrivateAttr
-else:
-    from pydantic import Field, PrivateAttr  # type: ignore
-
 
 class AutomationFilterCreated(PrefectBaseModel):
     """Filter by `Automation.created`."""
 
-    before_: Optional[DateTimeTZ] = Field(
+    before_: Optional[DateTime] = Field(
         default=None,
         description="Only include automations created before this datetime",
     )
@@ -46,18 +41,19 @@ class AutomationFilter(PrefectBaseModel):
 class EventDataFilter(PrefectBaseModel, extra="forbid"):  # type: ignore[call-arg]
     """A base class for filtering event data."""
 
-    _top_level_filter: "EventFilter | None" = PrivateAttr(None)
+    _top_level_filter: Optional["EventFilter"] = PrivateAttr(None)
 
     def get_filters(self) -> List["EventDataFilter"]:
-        return [
+        filters: List["EventDataFilter"] = [
             filter
             for filter in [
-                getattr(self, name)
-                for name, field in self.__fields__.items()
-                if issubclass(field.type_, EventDataFilter)
+                getattr(self, name) for name, field in self.model_fields.items()
             ]
-            if filter
+            if isinstance(filter, EventDataFilter)
         ]
+        for filter in filters:
+            filter._top_level_filter = self._top_level_filter
+        return filters
 
     def includes(self, event: Event) -> bool:
         """Does the given event match the criteria of this filter?"""
@@ -69,15 +65,15 @@ class EventDataFilter(PrefectBaseModel, extra="forbid"):  # type: ignore[call-ar
 
 
 class EventOccurredFilter(EventDataFilter):
-    since: DateTimeTZ = Field(
+    since: DateTime = Field(
         default_factory=lambda: cast(
-            DateTimeTZ,
+            DateTime,
             pendulum.now("UTC").start_of("day").subtract(days=180),
         ),
         description="Only include events after this time (inclusive)",
     )
-    until: DateTimeTZ = Field(
-        default_factory=lambda: cast(DateTimeTZ, pendulum.now("UTC")),
+    until: DateTime = Field(
+        default_factory=lambda: cast(DateTime, pendulum.now("UTC")),
         description="Only include events prior to this time (inclusive)",
     )
 

prefect/events/related.py

@@ -31,7 +31,7 @@ RESOURCE_CACHE: RelatedResourceCache = {}
 
 def tags_as_related_resources(tags: Iterable[str]) -> List[RelatedResource]:
     return [
-        RelatedResource.parse_obj(
+        RelatedResource.model_validate(
             {
                 "prefect.resource.id": f"prefect.tag.{tag}",
                 "prefect.resource.role": "tag",
@@ -44,7 +44,7 @@ def tags_as_related_resources(tags: Iterable[str]) -> List[RelatedResource]:
 def object_as_related_resource(kind: str, role: str, object: Any) -> RelatedResource:
     resource_id = f"prefect.{kind}.{object.id}"
 
-    return RelatedResource.parse_obj(
+    return RelatedResource.model_validate(
         {
             "prefect.resource.id": resource_id,
             "prefect.resource.role": role,

prefect/events/schemas/__init__.py

@@ -1,5 +0,0 @@
-# TODO: these are just for backward compatibility, can can be removed in the future
-
-from .deployment_triggers import DeploymentTrigger
-
-__all__ = ["DeploymentTrigger"]

prefect/events/schemas/automations.py

@@ -14,19 +14,15 @@ from typing import (
 )
 from uuid import UUID
 
-from typing_extensions import TypeAlias
-
-from prefect._internal.pydantic import HAS_PYDANTIC_V2
-
-if HAS_PYDANTIC_V2:
-    from pydantic.v1 import Field, PrivateAttr, root_validator, validator
-    from pydantic.v1.fields import ModelField
-else:
-    from pydantic import Field, PrivateAttr, root_validator, validator  # type: ignore
-    from pydantic.fields import ModelField  # type: ignore
+from pydantic import (
+    Field,
+    PrivateAttr,
+    field_validator,
+    model_validator,
+)
+from typing_extensions import Self, TypeAlias
 
 from prefect._internal.schemas.bases import PrefectBaseModel
-from prefect._internal.schemas.validators import validate_trigger_within
 from prefect.events.actions import ActionTypes, RunDeployment
 from prefect.utilities.collections import AutoEnum
 
@@ -81,7 +77,7 @@ class Trigger(PrefectBaseModel, abc.ABC, extra="ignore"):  # type: ignore[call-a
         # This is one of the Deployment*Trigger classes, so translate it over to a
         # plain Trigger
         if hasattr(self, "trigger_type"):
-            trigger = self.trigger_type(**self.dict())
+            trigger = self.trigger_type(**self.model_dump())
 
         return AutomationCore(
             name=(
@@ -104,11 +100,11 @@ class ResourceTrigger(Trigger, abc.ABC):
     type: str
 
     match: ResourceSpecification = Field(
-        default_factory=lambda: ResourceSpecification.parse_obj({}),
+        default_factory=lambda: ResourceSpecification.model_validate({}),
         description="Labels for resources which this trigger will match.",
     )
     match_related: ResourceSpecification = Field(
-        default_factory=lambda: ResourceSpecification.parse_obj({}),
+        default_factory=lambda: ResourceSpecification.model_validate({}),
         description="Labels for related resources which this trigger will match.",
     )
 
@@ -167,9 +163,8 @@ class EventTrigger(ResourceTrigger):
         ),
     )
     within: timedelta = Field(
-        timedelta(0),
-        minimum=0.0,
-        exclusiveMinimum=False,
+        timedelta(seconds=0),
+        ge=timedelta(seconds=0),
         description=(
             "The time period over which the events must occur.  For Reactive triggers, "
             "this may be as low as 0 seconds, but must be at least 10 seconds for "
@@ -177,26 +172,33 @@ class EventTrigger(ResourceTrigger):
         ),
     )
 
-    @validator("within")
-    def enforce_minimum_within(
-        cls, value: timedelta, values, config, field: ModelField
-    ):
-        return validate_trigger_within(value, field)
+    @model_validator(mode="before")
+    @classmethod
+    def enforce_minimum_within_for_proactive_triggers(
+        cls, data: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        if not isinstance(data, dict):
+            return data
+
+        if "within" in data and data["within"] is None:
+            raise ValueError("`within` should be a valid timedelta")
 
-    @root_validator(skip_on_failure=True)
-    def enforce_minimum_within_for_proactive_triggers(cls, values: Dict[str, Any]):
-        posture: Optional[Posture] = values.get("posture")
-        within: Optional[timedelta] = values.get("within")
+        posture: Optional[Posture] = data.get("posture")
+        within: Optional[timedelta] = data.get("within")
+
+        if isinstance(within, (int, float)):
+            data["within"] = within = timedelta(seconds=within)
 
         if posture == Posture.Proactive:
             if not within or within == timedelta(0):
-                values["within"] = timedelta(seconds=10.0)
+                data["within"] = timedelta(seconds=10.0)
             elif within < timedelta(seconds=10.0):
                 raise ValueError(
-                    "The minimum within for Proactive triggers is 10 seconds"
+                    "`within` for Proactive triggers must be greater than or equal to "
+                    "10 seconds"
                 )
 
-        return values
+        return data
 
     def describe_for_cli(self, indent: int = 0) -> str:
         """Return a human-readable description of this trigger for the CLI"""
@@ -258,8 +260,6 @@ class MetricTriggerQuery(PrefectBaseModel):
     )
     range: timedelta = Field(
         timedelta(seconds=300),  # defaults to 5 minutes
-        minimum=300.0,
-        exclusiveMinimum=False,
         description=(
             "The lookback duration (seconds) for a metric query. This duration is "
             "used to determine the time range over which the query will be executed. "
@@ -268,8 +268,6 @@ class MetricTriggerQuery(PrefectBaseModel):
     )
     firing_for: timedelta = Field(
         timedelta(seconds=300),  # defaults to 5 minutes
-        minimum=300.0,
-        exclusiveMinimum=False,
         description=(
             "The duration (seconds) for which the metric query must breach "
             "or resolve continuously before the state is updated and the "
@@ -278,6 +276,12 @@ class MetricTriggerQuery(PrefectBaseModel):
         ),
     )
 
+    @field_validator("range", "firing_for")
+    def enforce_minimum_range(cls, value: timedelta):
+        if value < timedelta(seconds=300):
+            raise ValueError("The minimum range is 300 seconds (5 minutes)")
+        return value
+
 
 class MetricTrigger(ResourceTrigger):
     """
@@ -316,7 +320,14 @@ class CompositeTrigger(Trigger, abc.ABC):
 
     type: Literal["compound", "sequence"]
     triggers: List["TriggerTypes"]
-    within: Optional[timedelta]
+    within: Optional[timedelta] = Field(
+        None,
+        description=(
+            "The time period over which the events must occur.  For Reactive triggers, "
+            "this may be as low as 0 seconds, but must be at least 10 seconds for "
+            "Proactive triggers"
+        ),
+    )
 
 
 class CompoundTrigger(CompositeTrigger):
@@ -326,19 +337,17 @@ class CompoundTrigger(CompositeTrigger):
     type: Literal["compound"] = "compound"
     require: Union[int, Literal["any", "all"]]
 
-    @root_validator
-    def validate_require(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        require = values.get("require")
-
-        if isinstance(require, int):
-            if require < 1:
-                raise ValueError("required must be at least 1")
-            if require > len(values["triggers"]):
+    @model_validator(mode="after")
+    def validate_require(self) -> Self:
+        if isinstance(self.require, int):
+            if self.require < 1:
+                raise ValueError("require must be at least 1")
+            if self.require > len(self.triggers):
                 raise ValueError(
-                    "required must be less than or equal to the number of triggers"
+                    "require must be less than or equal to the number of triggers"
                 )
 
-        return values
+        return self
 
     def describe_for_cli(self, indent: int = 0) -> str:
         """Return a human-readable description of this trigger for the CLI"""
@@ -387,8 +396,8 @@ TriggerTypes: TypeAlias = Union[
 ]
 """The union of all concrete trigger types that a user may actually create"""
 
-CompoundTrigger.update_forward_refs()
-SequenceTrigger.update_forward_refs()
+CompoundTrigger.model_rebuild()
+SequenceTrigger.model_rebuild()
 
 
 class AutomationCore(PrefectBaseModel, extra="ignore"):  # type: ignore[call-arg]