prefect-client 2.18.0__py3-none-any.whl → 2.18.1__py3-none-any.whl

prefect/events/schemas/automations.py

@@ -10,23 +10,24 @@ from typing import (
     Optional,
     Set,
     Union,
+    cast,
 )
 from uuid import UUID
 
 from typing_extensions import TypeAlias
 
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
-from prefect._internal.schemas.validators import validate_trigger_within
 
 if HAS_PYDANTIC_V2:
-    from pydantic.v1 import Field, root_validator, validator
+    from pydantic.v1 import Field, PrivateAttr, root_validator, validator
     from pydantic.v1.fields import ModelField
 else:
-    from pydantic import Field, root_validator, validator
-    from pydantic.fields import ModelField
+    from pydantic import Field, PrivateAttr, root_validator, validator  # type: ignore
+    from pydantic.fields import ModelField  # type: ignore
 
 from prefect._internal.schemas.bases import PrefectBaseModel
-from prefect.events.actions import ActionTypes
+from prefect._internal.schemas.validators import validate_trigger_within
+from prefect.events.actions import ActionTypes, RunDeployment
 from prefect.utilities.collections import AutoEnum
 
 from .events import ResourceSpecification
@@ -50,6 +51,50 @@ class Trigger(PrefectBaseModel, abc.ABC, extra="ignore"):
     def describe_for_cli(self, indent: int = 0) -> str:
         """Return a human-readable description of this trigger for the CLI"""
 
+    # The following allows the regular Trigger class to be used when serving or
+    # deploying flows, analogous to how the Deployment*Trigger classes work
+
+    _deployment_id: Optional[UUID] = PrivateAttr(default=None)
+
+    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=getattr(self, "parameters", None),
+                job_variables=getattr(self, "job_variables", None),
+            )
+        ]
+
+    def as_automation(self) -> "AutomationCore":
+        assert self._deployment_id
+
+        trigger: TriggerTypes = cast(TriggerTypes, self)
+
+        # 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())
+
+        return AutomationCore(
+            name=(
+                getattr(self, "name", None)
+                or f"Automation for deployment {self._deployment_id}"
+            ),
+            description="",
+            enabled=getattr(self, "enabled", True),
+            trigger=trigger,
+            actions=self.actions(),
+            owner_resource=self.owner_resource(),
+        )
+
 
 class ResourceTrigger(Trigger, abc.ABC):
     """

prefect/events/schemas/deployment_triggers.py

@@ -16,7 +16,6 @@ from typing import (
     Any,
     Dict,
     List,
-    Literal,
     Optional,
     Set,
     Union,
@@ -25,19 +24,16 @@ from uuid import UUID
 
 from typing_extensions import TypeAlias
 
-from prefect._internal.compatibility.deprecated import deprecated_class
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
-from prefect._internal.schemas.validators import validate_trigger_within
 
 if HAS_PYDANTIC_V2:
-    from pydantic.v1 import Field, PrivateAttr, root_validator, validator
-    from pydantic.v1.fields import ModelField
+    from pydantic.v1 import Field, PrivateAttr
 else:
-    from pydantic import Field, PrivateAttr, root_validator, validator
-    from pydantic.fields import ModelField
+    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 RunDeployment
+from prefect.events.actions import ActionTypes, RunDeployment
 
 from .automations import (
     AutomationCore,
@@ -47,7 +43,6 @@ from .automations import (
     MetricTriggerQuery,
     Posture,
     SequenceTrigger,
-    Trigger,
     TriggerTypes,
 )
 from .events import ResourceSpecification
@@ -67,11 +62,7 @@ class BaseDeploymentTrigger(PrefectBaseModel, abc.ABC, extra="ignore"):
     description: str = Field("", description="A longer description of this automation")
     enabled: bool = Field(True, description="Whether this automation will be evaluated")
 
-    # Fields from Trigger
-
-    type: str
-
-    # Fields from Deployment
+    # Fields from the RunDeployment action
 
     parameters: Optional[Dict[str, Any]] = Field(
         None,
@@ -87,60 +78,9 @@ class BaseDeploymentTrigger(PrefectBaseModel, abc.ABC, extra="ignore"):
             "deployment's default job variables"
         ),
     )
-    _deployment_id: Optional[UUID] = PrivateAttr(default=None)
-
-    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[RunDeployment]:
-        assert self._deployment_id
-        return [
-            RunDeployment(
-                parameters=self.parameters,
-                deployment_id=self._deployment_id,
-                job_variables=self.job_variables,
-            )
-        ]
-
-    def as_automation(self) -> AutomationCore:
-        if not self.name:
-            raise ValueError("name is required")
-
-        return AutomationCore(
-            name=self.name,
-            description=self.description,
-            enabled=self.enabled,
-            trigger=self.as_trigger(),
-            actions=self.actions(),
-            owner_resource=self.owner_resource(),
-        )
-
-    @abc.abstractmethod
-    def as_trigger(self) -> Trigger:
-        ...
 
 
-class DeploymentResourceTrigger(BaseDeploymentTrigger, abc.ABC):
-    """
-    Base class for triggers that may filter by the labels of resources.
-    """
-
-    type: str
-
-    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.",
-    )
-
-
-class DeploymentEventTrigger(DeploymentResourceTrigger):
+class DeploymentEventTrigger(BaseDeploymentTrigger, EventTrigger):
     """
     A trigger that fires based on the presence or absence of events within a given
     period of time.
@@ -148,184 +88,28 @@ class DeploymentEventTrigger(DeploymentResourceTrigger):
 
     trigger_type = EventTrigger
 
-    type: Literal["event"] = "event"
 
-    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."
-        ),
-    )
-    posture: Literal[Posture.Reactive, Posture.Proactive] = Field(  # type: ignore[valid-type]
-        Posture.Reactive,
-        description=(
-            "The posture of this trigger, either Reactive or Proactive.  Reactive "
-            "triggers respond to the _presence_ of the expected events, while "
-            "Proactive triggers respond to the _absence_ of those expected events."
-        ),
-    )
-    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"
-        ),
-    )
-
-    @validator("within")
-    def enforce_minimum_within(
-        cls, value: timedelta, values, config, field: ModelField
-    ):
-        return validate_trigger_within(value, field)
-
-    @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")
-
-        if posture == Posture.Proactive:
-            if not within or within == timedelta(0):
-                values["within"] = timedelta(seconds=10.0)
-            elif within < timedelta(seconds=10.0):
-                raise ValueError(
-                    "The minimum within for Proactive triggers is 10 seconds"
-                )
-
-        return values
-
-    def as_trigger(self) -> Trigger:
-        return self.trigger_type(
-            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,
-        )
-
-
-class DeploymentMetricTrigger(DeploymentResourceTrigger):
+class DeploymentMetricTrigger(BaseDeploymentTrigger, MetricTrigger):
     """
     A trigger that fires based on the results of a metric query.
     """
 
     trigger_type = MetricTrigger
 
-    type: Literal["metric"] = "metric"
-
-    posture: Literal[Posture.Metric] = Field(  # type: ignore[valid-type]
-        Posture.Metric,
-        description="Periodically evaluate the configured metric query.",
-    )
-
-    metric: MetricTriggerQuery = Field(
-        ...,
-        description="The metric query to evaluate for this trigger. ",
-    )
-
-    def as_trigger(self) -> Trigger:
-        return self.trigger_type(
-            match=self.match,
-            match_related=self.match_related,
-            posture=self.posture,
-            metric=self.metric,
-            job_variables=self.job_variables,
-        )
-
-
-class DeploymentCompositeTrigger(BaseDeploymentTrigger, abc.ABC):
-    """
-    Requires some number of triggers to have fired within the given time period.
-    """
-
-    type: Literal["compound", "sequence"]
-    triggers: List["TriggerTypes"]
-    within: Optional[timedelta]
 
-
-class DeploymentCompoundTrigger(DeploymentCompositeTrigger):
+class DeploymentCompoundTrigger(BaseDeploymentTrigger, CompoundTrigger):
     """A composite trigger that requires some number of triggers to have
     fired within the given time period"""
 
     trigger_type = CompoundTrigger
 
-    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"]):
-                raise ValueError(
-                    "required must be less than or equal to the number of triggers"
-                )
-
-        return values
-
-    def as_trigger(self) -> Trigger:
-        return self.trigger_type(
-            require=self.require,
-            triggers=self.triggers,
-            within=self.within,
-            job_variables=self.job_variables,
-        )
 
-
-class DeploymentSequenceTrigger(DeploymentCompositeTrigger):
+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
 
-    type: Literal["sequence"] = "sequence"
-
-    def as_trigger(self) -> Trigger:
-        return self.trigger_type(
-            triggers=self.triggers,
-            within=self.within,
-            job_variables=self.job_variables,
-        )
-
 
 # Concrete deployment trigger types
 DeploymentTriggerTypes: TypeAlias = Union[
@@ -461,7 +245,10 @@ class DeploymentTrigger(PrefectBaseModel):
     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,
@@ -496,12 +283,13 @@ class DeploymentTrigger(PrefectBaseModel):
     def owner_resource(self) -> Optional[str]:
         return f"prefect.deployment.{self._deployment_id}"
 
-    def actions(self) -> List[RunDeployment]:
+    def actions(self) -> List[ActionTypes]:
         assert self._deployment_id
         return [
             RunDeployment(
-                parameters=self.parameters,
+                source="selected",
                 deployment_id=self._deployment_id,
+                parameters=self.parameters,
                 job_variables=self.job_variables,
             )
         ]

prefect/events/schemas/events.py

@@ -15,9 +15,14 @@ from typing import (
 from uuid import UUID, uuid4
 
 import pendulum
-from pydantic import Field, root_validator, validator
 
 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 prefect._internal.schemas.bases import PrefectBaseModel
 from prefect._internal.schemas.fields import DateTimeTZ
 from prefect.logging import get_logger
@@ -26,11 +31,6 @@ from prefect.settings import (
     PREFECT_EVENTS_MAXIMUM_RELATED_RESOURCES,
 )
 
-if HAS_PYDANTIC_V2:
-    from pydantic.v1 import Field, root_validator, validator
-else:
-    from pydantic import Field, root_validator, validator
-
 from .labelling import Labelled
 
 logger = get_logger(__name__)
@@ -128,7 +128,7 @@ class Event(PrefectBaseModel):
         description="The client-provided identifier of this event",
     )
     follows: Optional[UUID] = Field(
-        None,
+        default=None,
         description=(
             "The ID of an event that is known to have occurred prior to this one. "
             "If set, this may be used to establish a more precise ordering of causally-"

prefect/events/utilities.py

@@ -61,7 +61,7 @@ def emit_event(
     if worker_instance.client_type not in operational_clients:
         return None
 
-    event_kwargs = {
+    event_kwargs: Dict[str, Any] = {
         "event": event,
         "resource": resource,
     }

prefect/events/worker.py

@@ -1,6 +1,7 @@
 from contextlib import asynccontextmanager
 from contextvars import Context, copy_context
-from typing import Any, Optional, Tuple, Type
+from typing import Any, Dict, Optional, Tuple, Type
+from uuid import UUID
 
 from typing_extensions import Self
 
@@ -41,11 +42,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
+    return isinstance(api_url, str) and PREFECT_EXPERIMENTAL_EVENTS.value()
 
 
 def should_emit_events_to_ephemeral_server() -> bool:
-    return PREFECT_API_KEY.value() is None and PREFECT_EXPERIMENTAL_EVENTS
+    return PREFECT_API_KEY.value() is None and PREFECT_EXPERIMENTAL_EVENTS.value()
 
 
 class EventsWorker(QueueService[Event]):
@@ -56,6 +57,7 @@ class EventsWorker(QueueService[Event]):
         self.client_type = client_type
         self.client_options = client_options
         self._client: EventsClient
+        self._context_cache: Dict[UUID, Context] = {}
 
     @asynccontextmanager
     async def _lifespan(self):
@@ -64,11 +66,12 @@ class EventsWorker(QueueService[Event]):
         async with self._client:
             yield
 
-    def _prepare_item(self, event: Event) -> Tuple[Event, Context]:
-        return (event, copy_context())
+    def _prepare_item(self, event: Event) -> Event:
+        self._context_cache[event.id] = copy_context()
+        return event
 
-    async def _handle(self, event_and_context: Tuple[Event, Context]):
-        event, context = event_and_context
+    async def _handle(self, event: Event):
+        context = self._context_cache.pop(event.id)
         with temporary_context(context=context):
             await self.attach_related_resources_from_context(event)
 

prefect/flows.py

@@ -34,20 +34,10 @@ from typing import (
 )
 from uuid import UUID
 
-from prefect._vendor.fastapi.encoders import jsonable_encoder
-from typing_extensions import Self
+from rich.console import Console
+from typing_extensions import Literal, ParamSpec, Self
 
-from prefect._internal.compatibility.deprecated import deprecated_parameter
-from prefect._internal.concurrency.api import create_call, from_async
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
-from prefect.client.orchestration import get_client
-from prefect.deployments.runner import DeploymentImage, EntrypointType, deploy
-from prefect.filesystems import ReadableDeploymentStorage
-from prefect.runner.storage import (
-    BlockStorageAdapter,
-    RunnerStorage,
-    create_storage_from_url,
-)
 
 if HAS_PYDANTIC_V2:
     import pydantic.v1 as pydantic
@@ -67,26 +57,36 @@ else:
 
     V2ValidationError = None
 
-from rich.console import Console
-from typing_extensions import Literal, ParamSpec
+from prefect._vendor.fastapi.encoders import jsonable_encoder
 
+from prefect._internal.compatibility.deprecated import deprecated_parameter
+from prefect._internal.concurrency.api import create_call, from_async
 from prefect._internal.schemas.validators import raise_on_name_with_banned_characters
+from prefect.client.orchestration import get_client
 from prefect.client.schemas.objects import Flow as FlowSchema
 from prefect.client.schemas.objects import FlowRun, MinimalDeploymentSchedule
 from prefect.client.schemas.schedules import SCHEDULE_TYPES
 from prefect.context import PrefectObjectRegistry, registry_from_script
-from prefect.events import DeploymentTriggerTypes
+from prefect.deployments.runner import DeploymentImage, EntrypointType, deploy
+from prefect.events import DeploymentTriggerTypes, TriggerTypes
 from prefect.exceptions import (
     MissingFlowError,
     ObjectNotFound,
     ParameterTypeError,
     UnspecifiedFlowError,
 )
+from prefect.filesystems import ReadableDeploymentStorage
 from prefect.futures import PrefectFuture
 from prefect.logging import get_logger
 from prefect.results import ResultSerializer, ResultStorage
+from prefect.runner.storage import (
+    BlockStorageAdapter,
+    RunnerStorage,
+    create_storage_from_url,
+)
 from prefect.settings import (
     PREFECT_DEFAULT_WORK_POOL_NAME,
+    PREFECT_EXPERIMENTAL_ENABLE_NEW_ENGINE,
     PREFECT_FLOW_DEFAULT_RETRIES,
     PREFECT_FLOW_DEFAULT_RETRY_DELAY_SECONDS,
     PREFECT_UI_URL,
@@ -618,7 +618,7 @@ class Flow(Generic[P, R]):
         schedule: Optional[SCHEDULE_TYPES] = None,
         is_schedule_active: Optional[bool] = None,
         parameters: Optional[dict] = None,
-        triggers: Optional[List[DeploymentTriggerTypes]] = None,
+        triggers: Optional[List[Union[DeploymentTriggerTypes, TriggerTypes]]] = None,
         description: Optional[str] = None,
         tags: Optional[List[str]] = None,
         version: Optional[str] = None,
@@ -748,7 +748,7 @@ class Flow(Generic[P, R]):
         schedules: Optional[List["FlexibleScheduleList"]] = None,
         schedule: Optional[SCHEDULE_TYPES] = None,
         is_schedule_active: Optional[bool] = None,
-        triggers: Optional[List[DeploymentTriggerTypes]] = None,
+        triggers: Optional[List[Union[DeploymentTriggerTypes, TriggerTypes]]] = None,
         parameters: Optional[dict] = None,
         description: Optional[str] = None,
         tags: Optional[List[str]] = None,
@@ -962,7 +962,7 @@ class Flow(Generic[P, R]):
         schedules: Optional[List[MinimalDeploymentSchedule]] = None,
         schedule: Optional[SCHEDULE_TYPES] = None,
         is_schedule_active: Optional[bool] = None,
-        triggers: Optional[List[DeploymentTriggerTypes]] = None,
+        triggers: Optional[List[Union[DeploymentTriggerTypes, TriggerTypes]]] = None,
         parameters: Optional[dict] = None,
         description: Optional[str] = None,
         tags: Optional[List[str]] = None,
@@ -1225,6 +1225,21 @@ class Flow(Generic[P, R]):
             # we can add support for exploring subflows for tasks in the future.
             return track_viz_task(self.isasync, self.name, parameters)
 
+        if PREFECT_EXPERIMENTAL_ENABLE_NEW_ENGINE.value():
+            from prefect.new_flow_engine import run_flow
+            from prefect.utilities.asyncutils import run_sync
+
+            awaitable = run_flow(
+                flow=self,
+                parameters=parameters,
+                wait_for=wait_for,
+                return_type=return_type,
+            )
+            if self.isasync:
+                return awaitable
+            else:
+                return run_sync(awaitable)
+
         return enter_flow_run_engine_from_flow_call(
             self,
             parameters,

prefect/input/actions.py

@@ -5,7 +5,7 @@ import orjson
 import pydantic
 
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
-from prefect.client.utilities import inject_client
+from prefect.client.utilities import client_injector
 from prefect.context import FlowRunContext
 from prefect.exceptions import PrefectHTTPStatusError
 from prefect.utilities.asyncutils import sync_compatible
@@ -52,13 +52,13 @@ async def create_flow_run_input_from_model(
 
 
 @sync_compatible
-@inject_client
+@client_injector
 async def create_flow_run_input(
+    client: "PrefectClient",
     key: str,
     value: Any,
     flow_run_id: Optional[UUID] = None,
     sender: Optional[str] = None,
-    client: "PrefectClient" = None,
 ):
     """
     Create a new flow run input. The given `value` will be serialized to JSON
@@ -81,13 +81,13 @@ async def create_flow_run_input(
 
 
 @sync_compatible
-@inject_client
+@client_injector
 async def filter_flow_run_input(
+    client: "PrefectClient",
     key_prefix: str,
     limit: int = 1,
     exclude_keys: Optional[Set[str]] = None,
     flow_run_id: Optional[UUID] = None,
-    client: "PrefectClient" = None,
 ):
     if exclude_keys is None:
         exclude_keys = set()
@@ -103,9 +103,9 @@ async def filter_flow_run_input(
 
 
 @sync_compatible
-@inject_client
+@client_injector
 async def read_flow_run_input(
-    key: str, flow_run_id: Optional[UUID] = None, client: "PrefectClient" = None
+    client: "PrefectClient", key: str, flow_run_id: Optional[UUID] = None
 ) -> Any:
     """Read a flow run input.
 
@@ -126,9 +126,9 @@ async def read_flow_run_input(
 
 
 @sync_compatible
-@inject_client
+@client_injector
 async def delete_flow_run_input(
-    key: str, flow_run_id: Optional[UUID] = None, client: "PrefectClient" = None
+    client: "PrefectClient", key: str, flow_run_id: Optional[UUID] = None
 ):
     """Delete a flow run input.