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

prefect/events/schemas/deployment_triggers.py

@@ -10,42 +10,27 @@ create them from YAML.
 """
 
 import abc
-import textwrap
-from datetime import timedelta
 from typing import (
     Any,
+    ClassVar,
     Dict,
-    List,
     Optional,
-    Set,
+    Type,
     Union,
 )
-from uuid import UUID
 
+from pydantic import Field
 from typing_extensions import TypeAlias
 
-from prefect._internal.pydantic import HAS_PYDANTIC_V2
-
-if HAS_PYDANTIC_V2:
-    from pydantic.v1 import Field, PrivateAttr
-else:
-    from pydantic import Field, PrivateAttr  # type: ignore
-
-from prefect._internal.compatibility.deprecated import deprecated_class
 from prefect._internal.schemas.bases import PrefectBaseModel
-from prefect.events.actions import ActionTypes, RunDeployment
 
 from .automations import (
-    AutomationCore,
     CompoundTrigger,
     EventTrigger,
     MetricTrigger,
-    MetricTriggerQuery,
-    Posture,
     SequenceTrigger,
     TriggerTypes,
 )
-from .events import ResourceSpecification
 
 
 class BaseDeploymentTrigger(PrefectBaseModel, abc.ABC, extra="ignore"):  # type: ignore[call-arg]
@@ -86,7 +71,7 @@ class DeploymentEventTrigger(BaseDeploymentTrigger, EventTrigger):
     period of time.
     """
 
-    trigger_type = EventTrigger
+    trigger_type: ClassVar[Type[TriggerTypes]] = EventTrigger
 
 
 class DeploymentMetricTrigger(BaseDeploymentTrigger, MetricTrigger):
@@ -94,21 +79,21 @@ class DeploymentMetricTrigger(BaseDeploymentTrigger, MetricTrigger):
     A trigger that fires based on the results of a metric query.
     """
 
-    trigger_type = MetricTrigger
+    trigger_type: ClassVar[Type[TriggerTypes]] = MetricTrigger
 
 
 class DeploymentCompoundTrigger(BaseDeploymentTrigger, CompoundTrigger):
     """A composite trigger that requires some number of triggers to have
     fired within the given time period"""
 
-    trigger_type = CompoundTrigger
+    trigger_type: ClassVar[Type[TriggerTypes]] = CompoundTrigger
 
 
 class DeploymentSequenceTrigger(BaseDeploymentTrigger, SequenceTrigger):
     """A composite trigger that requires some number of triggers to have fired
     within the given time period in a specific order"""
 
-    trigger_type = SequenceTrigger
+    trigger_type: ClassVar[Type[TriggerTypes]] = SequenceTrigger
 
 
 # Concrete deployment trigger types
@@ -118,178 +103,3 @@ DeploymentTriggerTypes: TypeAlias = Union[
     DeploymentCompoundTrigger,
     DeploymentSequenceTrigger,
 ]
-
-
-# The deprecated all-in-one DeploymentTrigger
-
-
-@deprecated_class(
-    start_date="Mar 2024",
-    help=textwrap.dedent(
-        """
-    To associate a specific kind of trigger with a Deployment, use one of the more
-    specific deployment trigger types instead:
-
-    * DeploymentEventTrigger to associate an EventTrigger with a deployment
-    * DeploymentMetricTrigger to associate an MetricTrigger with a deployment
-    * DeploymentCompoundTrigger to associate an CompoundTrigger with a deployment
-    * DeploymentSequenceTrigger to associate an SequenceTrigger with a deployment
-
-    In other cases, use the Automation and Trigger class hierarchy directly.
-    """
-    ),
-)
-class DeploymentTrigger(PrefectBaseModel):
-    name: Optional[str] = Field(
-        None, description="The name to give to the automation created for this trigger."
-    )
-    description: str = Field("", description="A longer description of this automation")
-    enabled: bool = Field(True, description="Whether this automation will be evaluated")
-    job_variables: Optional[Dict[str, Any]] = Field(
-        None,
-        description=(
-            "Job variables to pass to the run, or None to use the "
-            "deployment's default job variables"
-        ),
-    )
-
-    # from ResourceTrigger
-
-    match: ResourceSpecification = Field(
-        default_factory=lambda: ResourceSpecification.parse_obj({}),
-        description="Labels for resources which this trigger will match.",
-    )
-    match_related: ResourceSpecification = Field(
-        default_factory=lambda: ResourceSpecification.parse_obj({}),
-        description="Labels for related resources which this trigger will match.",
-    )
-
-    # from both EventTrigger and MetricTrigger
-
-    posture: Posture = Field(
-        Posture.Reactive,
-        description=(
-            "The posture of this trigger, either Reactive, Proactive, or Metric. "
-            "Reactive triggers respond to the _presence_ of the expected events, while "
-            "Proactive triggers respond to the _absence_ of those expected events.  "
-            "Metric triggers periodically evaluate the configured metric query."
-        ),
-    )
-
-    # from EventTrigger
-
-    after: Set[str] = Field(
-        default_factory=set,
-        description=(
-            "The event(s) which must first been seen to fire this trigger.  If "
-            "empty, then fire this trigger immediately.  Events may include "
-            "trailing wildcards, like `prefect.flow-run.*`"
-        ),
-    )
-    expect: Set[str] = Field(
-        default_factory=set,
-        description=(
-            "The event(s) this trigger is expecting to see.  If empty, this "
-            "trigger will match any event.  Events may include trailing wildcards, "
-            "like `prefect.flow-run.*`"
-        ),
-    )
-
-    for_each: Set[str] = Field(
-        default_factory=set,
-        description=(
-            "Evaluate the trigger separately for each distinct value of these labels "
-            "on the resource.  By default, labels refer to the primary resource of the "
-            "triggering event.  You may also refer to labels from related "
-            "resources by specifying `related:<role>:<label>`.  This will use the "
-            "value of that label for the first related resource in that role.  For "
-            'example, `"for_each": ["related:flow:prefect.resource.id"]` would '
-            "evaluate the trigger for each flow."
-        ),
-    )
-    threshold: int = Field(
-        1,
-        description=(
-            "The number of events required for this trigger to fire (for "
-            "Reactive triggers), or the number of events expected (for Proactive "
-            "triggers)"
-        ),
-    )
-    within: timedelta = Field(
-        timedelta(0),
-        minimum=0.0,
-        exclusiveMinimum=False,
-        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"
-        ),
-    )
-
-    # from MetricTrigger
-
-    metric: Optional[MetricTriggerQuery] = Field(
-        None,
-        description="The metric query to evaluate for this trigger. ",
-    )
-
-    _deployment_id: Optional[UUID] = PrivateAttr(default=None)
-    parameters: Optional[Dict[str, Any]] = Field(
-        None,
-        description=(
-            "The parameters to pass to the deployment, or None to use the "
-            "deployment's default parameters"
-        ),
-    )
-
-    def as_automation(self) -> AutomationCore:
-        assert self.name
-
-        trigger: TriggerTypes
-
-        if self.posture == Posture.Metric:
-            assert self.metric
-            trigger = MetricTrigger(
-                type="metric",
-                match=self.match,
-                match_related=self.match_related,
-                posture=self.posture,
-                metric=self.metric,
-            )
-        else:
-            trigger = EventTrigger(
-                match=self.match,
-                match_related=self.match_related,
-                after=self.after,
-                expect=self.expect,
-                for_each=self.for_each,
-                posture=self.posture,
-                threshold=self.threshold,
-                within=self.within,
-            )
-
-        return AutomationCore(
-            name=self.name,
-            description=self.description,
-            enabled=self.enabled,
-            trigger=trigger,
-            actions=self.actions(),
-            owner_resource=self.owner_resource(),
-        )
-
-    def set_deployment_id(self, deployment_id: UUID):
-        self._deployment_id = deployment_id
-
-    def owner_resource(self) -> Optional[str]:
-        return f"prefect.deployment.{self._deployment_id}"
-
-    def actions(self) -> List[ActionTypes]:
-        assert self._deployment_id
-        return [
-            RunDeployment(
-                source="selected",
-                deployment_id=self._deployment_id,
-                parameters=self.parameters,
-                job_variables=self.job_variables,
-            )
-        ]

prefect/events/schemas/events.py

@@ -10,21 +10,15 @@ from typing import (
     Sequence,
     Tuple,
     Union,
-    cast,
 )
 from uuid import UUID, uuid4
 
 import pendulum
-
-from prefect._internal.pydantic import HAS_PYDANTIC_V2
-
-if HAS_PYDANTIC_V2:
-    from pydantic.v1 import Field, root_validator, validator
-else:
-    from pydantic import Field, root_validator, validator  # type: ignore
+from pydantic import ConfigDict, Field, RootModel, field_validator, model_validator
+from pydantic_extra_types.pendulum_dt import DateTime
+from typing_extensions import Self
 
 from prefect._internal.schemas.bases import PrefectBaseModel
-from prefect._internal.schemas.fields import DateTimeTZ
 from prefect.logging import get_logger
 from prefect.settings import (
     PREFECT_EVENTS_MAXIMUM_LABELS_PER_RESOURCE,
@@ -39,34 +33,24 @@ logger = get_logger(__name__)
 class Resource(Labelled):
     """An observable business object of interest to the user"""
 
-    @root_validator(pre=True)
-    def enforce_maximum_labels(cls, values: Dict[str, Any]):
-        labels = values.get("__root__")
-        if not isinstance(labels, dict):
-            return values
-
-        if len(labels) > PREFECT_EVENTS_MAXIMUM_LABELS_PER_RESOURCE.value():
+    @model_validator(mode="after")
+    def enforce_maximum_labels(self) -> Self:
+        if len(self.root) > PREFECT_EVENTS_MAXIMUM_LABELS_PER_RESOURCE.value():
             raise ValueError(
                 "The maximum number of labels per resource "
                 f"is {PREFECT_EVENTS_MAXIMUM_LABELS_PER_RESOURCE.value()}"
             )
 
-        return values
-
-    @root_validator(pre=True)
-    def requires_resource_id(cls, values: Dict[str, Any]):
-        labels = values.get("__root__")
-        if not isinstance(labels, dict):
-            return values
+        return self
 
-        labels = cast(Dict[str, str], labels)
-
-        if "prefect.resource.id" not in labels:
+    @model_validator(mode="after")
+    def requires_resource_id(self) -> Self:
+        if "prefect.resource.id" not in self.root:
             raise ValueError("Resources must include the prefect.resource.id label")
-        if not labels["prefect.resource.id"]:
+        if not self.root["prefect.resource.id"]:
             raise ValueError("The prefect.resource.id label must be non-empty")
 
-        return values
+        return self
 
     @property
     def id(self) -> str:
@@ -80,22 +64,16 @@ class Resource(Labelled):
 class RelatedResource(Resource):
     """A Resource with a specific role in an Event"""
 
-    @root_validator(pre=True)
-    def requires_resource_role(cls, values: Dict[str, Any]):
-        labels = values.get("__root__")
-        if not isinstance(labels, dict):
-            return values
-
-        labels = cast(Dict[str, str], labels)
-
-        if "prefect.resource.role" not in labels:
+    @model_validator(mode="after")
+    def requires_resource_role(self) -> Self:
+        if "prefect.resource.role" not in self.root:
             raise ValueError(
                 "Related Resources must include the prefect.resource.role label"
             )
-        if not labels["prefect.resource.role"]:
+        if not self.root["prefect.resource.role"]:
             raise ValueError("The prefect.resource.role label must be non-empty")
 
-        return values
+        return self
 
     @property
     def role(self) -> str:
@@ -105,7 +83,7 @@ class RelatedResource(Resource):
 class Event(PrefectBaseModel):
     """The client-side view of an event that has happened to a Resource"""
 
-    occurred: DateTimeTZ = Field(
+    occurred: DateTime = Field(
         default_factory=lambda: pendulum.now("UTC"),
         description="When the event happened from the sender's perspective",
     )
@@ -154,7 +132,8 @@ class Event(PrefectBaseModel):
             resources[related.role].append(related)
         return resources
 
-    @validator("related")
+    @field_validator("related")
+    @classmethod
     def enforce_maximum_related_resources(cls, value: List[RelatedResource]):
         if len(value) > PREFECT_EVENTS_MAXIMUM_RELATED_RESOURCES.value():
             raise ValueError(
@@ -181,10 +160,9 @@ class ReceivedEvent(Event):
     """The server-side view of an event that has happened to a Resource after it has
     been received by the server"""
 
-    class Config:
-        orm_mode = True
+    model_config = ConfigDict(from_attributes=True)
 
-    received: DateTimeTZ = Field(
+    received: DateTime = Field(
         ...,
         description="When the event was received by Prefect Cloud",
     )
@@ -210,35 +188,26 @@ def matches(expected: str, value: Optional[str]) -> bool:
     return match if positive else not match
 
 
-class ResourceSpecification(PrefectBaseModel):
-    """A specification that may match zero, one, or many resources, used to target or
-    select a set of resources in a query or automation.  A resource must match at least
-    one value of all of the provided labels"""
-
-    __root__: Dict[str, Union[str, List[str]]]
-
+class ResourceSpecification(RootModel[Dict[str, Union[str, List[str]]]]):
     def matches_every_resource(self) -> bool:
-        return len(self) == 0
+        return len(self.root) == 0
 
     def matches_every_resource_of_kind(self, prefix: str) -> bool:
         if self.matches_every_resource():
             return True
-
-        if len(self.__root__) == 1:
-            if resource_id := self.__root__.get("prefect.resource.id"):
+        if len(self.root) == 1:
+            resource_id = self.root.get("prefect.resource.id")
+            if resource_id:
                 values = [resource_id] if isinstance(resource_id, str) else resource_id
                 return any(value == f"{prefix}.*" for value in values)
-
         return False
 
     def includes(self, candidates: Iterable[Resource]) -> bool:
         if self.matches_every_resource():
             return True
-
         for candidate in candidates:
             if self.matches(candidate):
                 return True
-
         return False
 
     def matches(self, resource: Resource) -> bool:
@@ -251,14 +220,14 @@ class ResourceSpecification(PrefectBaseModel):
     def items(self) -> Iterable[Tuple[str, List[str]]]:
         return [
             (label, [value] if isinstance(value, str) else value)
-            for label, value in self.__root__.items()
+            for label, value in self.root.items()
         ]
 
     def __contains__(self, key: str) -> bool:
-        return self.__root__.__contains__(key)
+        return key in self.root
 
     def __getitem__(self, key: str) -> List[str]:
-        value = self.__root__[key]
+        value = self.root[key]
         if not value:
             return []
         if not isinstance(value, list):
@@ -268,7 +237,7 @@ class ResourceSpecification(PrefectBaseModel):
     def pop(
         self, key: str, default: Optional[Union[str, List[str]]] = None
     ) -> Optional[List[str]]:
-        value = self.__root__.pop(key, default)
+        value = self.root.pop(key, default)
         if not value:
             return []
         if not isinstance(value, list):
@@ -278,7 +247,7 @@ class ResourceSpecification(PrefectBaseModel):
     def get(
         self, key: str, default: Optional[Union[str, List[str]]] = None
     ) -> Optional[List[str]]:
-        value = self.__root__.get(key, default)
+        value = self.root.get(key, default)
         if not value:
             return []
         if not isinstance(value, list):
@@ -286,7 +255,7 @@ class ResourceSpecification(PrefectBaseModel):
         return value
 
     def __len__(self) -> int:
-        return len(self.__root__)
+        return len(self.root)
 
     def deepcopy(self) -> "ResourceSpecification":
-        return ResourceSpecification.parse_obj(copy.deepcopy(self.__root__))
+        return ResourceSpecification(root=copy.deepcopy(self.root))

prefect/events/schemas/labelling.py

@@ -1,6 +1,6 @@
 from typing import Dict, Iterable, Iterator, List, Optional, Tuple
 
-from prefect._internal.schemas.bases import PrefectBaseModel
+from pydantic import RootModel
 
 
 class LabelDiver:
@@ -71,36 +71,32 @@ class LabelDiver:
             raise AttributeError
 
 
-class Labelled(PrefectBaseModel, extra="ignore"):  # type: ignore[call-arg]
-    """An object defined by string labels and values"""
-
-    __root__: Dict[str, str]
-
+class Labelled(RootModel[Dict[str, str]]):
     def keys(self) -> Iterable[str]:
-        return self.__root__.keys()
+        return self.root.keys()
 
     def items(self) -> Iterable[Tuple[str, str]]:
-        return self.__root__.items()
+        return self.root.items()
 
     def __getitem__(self, label: str) -> str:
-        return self.__root__[label]
+        return self.root[label]
 
     def __setitem__(self, label: str, value: str) -> str:
-        self.__root__[label] = value
+        self.root[label] = value
         return value
 
     def __contains__(self, key: str) -> bool:
-        return key in self.__root__
+        return key in self.root
 
     def get(self, label: str, default: Optional[str] = None) -> Optional[str]:
-        return self.__root__.get(label, default)
+        return self.root.get(label, default)
 
     def as_label_value_array(self) -> List[Dict[str, str]]:
         return [{"label": label, "value": value} for label, value in self.items()]
 
     @property
     def labels(self) -> LabelDiver:
-        return LabelDiver(self.__root__)
+        return LabelDiver(self.root)
 
     def has_all_labels(self, labels: Dict[str, str]) -> bool:
-        return all(self.__root__.get(label) == value for label, value in labels.items())
+        return all(self.root.get(label) == value for label, value in labels.items())

prefect/events/utilities.py

@@ -3,8 +3,7 @@ from typing import Any, Dict, List, Optional, Union
 from uuid import UUID
 
 import pendulum
-
-from prefect._internal.schemas.fields import DateTimeTZ
+from pydantic_extra_types.pendulum_dt import DateTime
 
 from .clients import (
     AssertingEventsClient,
@@ -21,7 +20,7 @@ TIGHT_TIMING = timedelta(minutes=5)
 def emit_event(
     event: str,
     resource: Dict[str, str],
-    occurred: Optional[DateTimeTZ] = None,
+    occurred: Optional[DateTime] = None,
     related: Optional[Union[List[Dict[str, str]], List[RelatedResource]]] = None,
     payload: Optional[Dict[str, Any]] = None,
     id: Optional[UUID] = None,

prefect/events/worker.py

@@ -10,7 +10,6 @@ from prefect.settings import (
     PREFECT_API_KEY,
     PREFECT_API_URL,
     PREFECT_CLOUD_API_URL,
-    PREFECT_EXPERIMENTAL_EVENTS,
 )
 from prefect.utilities.context import temporary_context
 
@@ -42,11 +41,11 @@ def emit_events_to_cloud() -> bool:
 
 def should_emit_events_to_running_server() -> bool:
     api_url = PREFECT_API_URL.value()
-    return isinstance(api_url, str) and PREFECT_EXPERIMENTAL_EVENTS.value()
+    return isinstance(api_url, str)
 
 
 def should_emit_events_to_ephemeral_server() -> bool:
-    return PREFECT_API_KEY.value() is None and PREFECT_EXPERIMENTAL_EVENTS.value()
+    return PREFECT_API_KEY.value() is None
 
 
 class EventsWorker(QueueService[Event]):