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

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
-
-        labels = cast(Dict[str, str], labels)
+        return self
 
-        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:
@@ -76,26 +60,30 @@ class Resource(Labelled):
     def name(self) -> Optional[str]:
         return self.get("prefect.resource.name")
 
+    def prefect_object_id(self, kind: str) -> UUID:
+        """Extracts the UUID from an event's resource ID if it's the expected kind
+        of prefect resource"""
+        prefix = f"{kind}." if not kind.endswith(".") else kind
 
-class RelatedResource(Resource):
-    """A Resource with a specific role in an Event"""
+        if not self.id.startswith(prefix):
+            raise ValueError(f"Resource ID {self.id} does not start with {prefix}")
 
-    @root_validator(pre=True)
-    def requires_resource_role(cls, values: Dict[str, Any]):
-        labels = values.get("__root__")
-        if not isinstance(labels, dict):
-            return values
+        return UUID(self.id[len(prefix) :])
 
-        labels = cast(Dict[str, str], labels)
 
-        if "prefect.resource.role" not in labels:
+class RelatedResource(Resource):
+    """A Resource with a specific role in an Event"""
+
+    @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 +93,9 @@ class RelatedResource(Resource):
 class Event(PrefectBaseModel):
     """The client-side view of an event that has happened to a Resource"""
 
-    occurred: DateTimeTZ = Field(
+    model_config = ConfigDict(extra="ignore")
+
+    occurred: DateTime = Field(
         default_factory=lambda: pendulum.now("UTC"),
         description="When the event happened from the sender's perspective",
     )
@@ -154,7 +144,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 +172,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 +200,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 +232,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 +249,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 +259,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 +267,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,13 +3,12 @@ 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,
+    AssertingPassthroughEventsClient,
     PrefectCloudEventsClient,
-    PrefectEphemeralEventsClient,
     PrefectEventsClient,
 )
 from .schemas.events import Event, RelatedResource
@@ -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,
@@ -51,10 +50,10 @@ def emit_event(
         return None
 
     operational_clients = [
+        AssertingPassthroughEventsClient,
         AssertingEventsClient,
         PrefectCloudEventsClient,
         PrefectEventsClient,
-        PrefectEphemeralEventsClient,
     ]
     worker_instance = EventsWorker.instance()
 

prefect/events/worker.py

@@ -1,6 +1,6 @@
 from contextlib import asynccontextmanager
 from contextvars import Context, copy_context
-from typing import Any, Dict, Optional, Tuple, Type
+from typing import TYPE_CHECKING, Any, Dict, Optional, Tuple, Type
 from uuid import UUID
 
 from typing_extensions import Self
@@ -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
 
@@ -18,12 +17,14 @@ from .clients import (
     EventsClient,
     NullEventsClient,
     PrefectCloudEventsClient,
-    PrefectEphemeralEventsClient,
     PrefectEventsClient,
 )
 from .related import related_resources_from_run_context
 from .schemas.events import Event
 
+if TYPE_CHECKING:
+    from prefect.client.orchestration import PrefectClient
+
 
 def should_emit_events() -> bool:
     return (
@@ -42,11 +43,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]):
@@ -57,14 +58,18 @@ class EventsWorker(QueueService[Event]):
         self.client_type = client_type
         self.client_options = client_options
         self._client: EventsClient
+        self._orchestration_client: "PrefectClient"
         self._context_cache: Dict[UUID, Context] = {}
 
     @asynccontextmanager
     async def _lifespan(self):
         self._client = self.client_type(**{k: v for k, v in self.client_options})
+        from prefect.client.orchestration import get_client
 
+        self._orchestration_client = get_client()
         async with self._client:
-            yield
+            async with self._orchestration_client:
+                yield
 
     def _prepare_item(self, event: Event) -> Event:
         self._context_cache[event.id] = copy_context()
@@ -79,7 +84,9 @@ class EventsWorker(QueueService[Event]):
 
     async def attach_related_resources_from_context(self, event: Event):
         exclude = {resource.id for resource in event.involved_resources}
-        event.related += await related_resources_from_run_context(exclude=exclude)
+        event.related += await related_resources_from_run_context(
+            client=self._orchestration_client, exclude=exclude
+        )
 
     @classmethod
     def instance(
@@ -98,7 +105,15 @@ class EventsWorker(QueueService[Event]):
             elif should_emit_events_to_running_server():
                 client_type = PrefectEventsClient
             elif should_emit_events_to_ephemeral_server():
-                client_type = PrefectEphemeralEventsClient
+                # create an ephemeral API if none was provided
+                from prefect.server.api.server import SubprocessASGIServer
+
+                server = SubprocessASGIServer()
+                server.start()
+                assert server.server_process is not None, "Server process did not start"
+
+                client_kwargs = {"api_url": server.api_url}
+                client_type = PrefectEventsClient
             else:
                 client_type = NullEventsClient
 

prefect/exceptions.py

@@ -403,3 +403,18 @@ class FlowPauseTimeout(PrefectException):
 
 class FlowRunWaitTimeout(PrefectException):
     """Raised when a flow run takes longer than a given timeout"""
+
+
+class PrefectImportError(ImportError):
+    """
+    An error raised when a Prefect object cannot be imported due to a move or removal.
+    """
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
+class SerializationError(PrefectException):
+    """
+    Raised when an object cannot be serialized.
+    """