prefect-client 2.20.4__py3-none-any.whl → 3.0.0__py3-none-any.whl

prefect/events/related.py

@@ -21,6 +21,7 @@ from .schemas.events import RelatedResource
 
 if TYPE_CHECKING:
     from prefect._internal.schemas.bases import ObjectBaseModel
+    from prefect.client.orchestration import PrefectClient
 
 ResourceCacheEntry = Dict[str, Union[str, "ObjectBaseModel", None]]
 RelatedResourceCache = Dict[str, Tuple[ResourceCacheEntry, DateTime]]
@@ -31,7 +32,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 +45,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,
@@ -54,9 +55,9 @@ def object_as_related_resource(kind: str, role: str, object: Any) -> RelatedReso
 
 
 async def related_resources_from_run_context(
+    client: "PrefectClient",
     exclude: Optional[Set[str]] = None,
 ) -> List[RelatedResource]:
-    from prefect.client.orchestration import get_client
     from prefect.client.schemas.objects import FlowRun
     from prefect.context import FlowRunContext, TaskRunContext
 
@@ -77,86 +78,84 @@ async def related_resources_from_run_context(
 
     related_objects: List[ResourceCacheEntry] = []
 
-    async with get_client() as client:
+    async def dummy_read():
+        return {}
 
-        async def dummy_read():
-            return {}
-
-        if flow_run_context:
-            related_objects.append(
-                {
-                    "kind": "flow-run",
-                    "role": "flow-run",
-                    "object": flow_run_context.flow_run,
-                },
-            )
-        else:
-            related_objects.append(
-                await _get_and_cache_related_object(
-                    kind="flow-run",
-                    role="flow-run",
-                    client_method=client.read_flow_run,
-                    obj_id=flow_run_id,
-                    cache=RESOURCE_CACHE,
-                )
+    if flow_run_context:
+        related_objects.append(
+            {
+                "kind": "flow-run",
+                "role": "flow-run",
+                "object": flow_run_context.flow_run,
+            },
+        )
+    else:
+        related_objects.append(
+            await _get_and_cache_related_object(
+                kind="flow-run",
+                role="flow-run",
+                client_method=client.read_flow_run,
+                obj_id=flow_run_id,
+                cache=RESOURCE_CACHE,
             )
+        )
 
-        if task_run_context:
-            related_objects.append(
-                {
-                    "kind": "task-run",
-                    "role": "task-run",
-                    "object": task_run_context.task_run,
-                },
-            )
+    if task_run_context:
+        related_objects.append(
+            {
+                "kind": "task-run",
+                "role": "task-run",
+                "object": task_run_context.task_run,
+            },
+        )
 
-        flow_run = related_objects[0]["object"]
+    flow_run = related_objects[0]["object"]
 
-        if isinstance(flow_run, FlowRun):
-            related_objects += list(
-                await asyncio.gather(
+    if isinstance(flow_run, FlowRun):
+        related_objects += list(
+            await asyncio.gather(
+                _get_and_cache_related_object(
+                    kind="flow",
+                    role="flow",
+                    client_method=client.read_flow,
+                    obj_id=flow_run.flow_id,
+                    cache=RESOURCE_CACHE,
+                ),
+                (
+                    _get_and_cache_related_object(
+                        kind="deployment",
+                        role="deployment",
+                        client_method=client.read_deployment,
+                        obj_id=flow_run.deployment_id,
+                        cache=RESOURCE_CACHE,
+                    )
+                    if flow_run.deployment_id
+                    else dummy_read()
+                ),
+                (
+                    _get_and_cache_related_object(
+                        kind="work-queue",
+                        role="work-queue",
+                        client_method=client.read_work_queue,
+                        obj_id=flow_run.work_queue_id,
+                        cache=RESOURCE_CACHE,
+                    )
+                    if flow_run.work_queue_id
+                    else dummy_read()
+                ),
+                (
                     _get_and_cache_related_object(
-                        kind="flow",
-                        role="flow",
-                        client_method=client.read_flow,
-                        obj_id=flow_run.flow_id,
+                        kind="work-pool",
+                        role="work-pool",
+                        client_method=client.read_work_pool,
+                        obj_id=flow_run.work_pool_name,
                         cache=RESOURCE_CACHE,
-                    ),
-                    (
-                        _get_and_cache_related_object(
-                            kind="deployment",
-                            role="deployment",
-                            client_method=client.read_deployment,
-                            obj_id=flow_run.deployment_id,
-                            cache=RESOURCE_CACHE,
-                        )
-                        if flow_run.deployment_id
-                        else dummy_read()
-                    ),
-                    (
-                        _get_and_cache_related_object(
-                            kind="work-queue",
-                            role="work-queue",
-                            client_method=client.read_work_queue,
-                            obj_id=flow_run.work_queue_id,
-                            cache=RESOURCE_CACHE,
-                        )
-                        if flow_run.work_queue_id
-                        else dummy_read()
-                    ),
-                    (
-                        _get_and_cache_related_object(
-                            kind="work-pool",
-                            role="work-pool",
-                            client_method=client.read_work_pool,
-                            obj_id=flow_run.work_pool_name,
-                            cache=RESOURCE_CACHE,
-                        )
-                        if flow_run.work_pool_name
-                        else dummy_read()
-                    ),
-                )
+                    )
+                    if flow_run.work_pool_name
+                    else dummy_read()
+                ),
             )
+        )
 
     related = []
     tags = set()

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)):
+            within = timedelta(seconds=within)
 
         if posture == Posture.Proactive:
             if not within or within == timedelta(0):
-                values["within"] = timedelta(seconds=10.0)
+                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 | {"within": within} if within else 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]

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,
-            )
-        ]