prefect-client 3.3.8.dev4__py3-none-any.whl → 3.4.1__py3-none-any.whl

prefect/deployments/runner.py

@@ -35,7 +35,15 @@ import importlib
 import tempfile
 from datetime import datetime, timedelta
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, ClassVar, Iterable, List, Optional, Union
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    ClassVar,
+    Iterable,
+    List,
+    Optional,
+    Union,
+)
 from uuid import UUID
 
 from pydantic import (
@@ -58,6 +66,7 @@ from prefect._internal.schemas.validators import (
     reconcile_paused_deployment,
     reconcile_schedules_runner,
 )
+from prefect._versioning import VersionType, get_inferred_version_info
 from prefect.client.base import ServerType
 from prefect.client.orchestration import PrefectClient, get_client
 from prefect.client.schemas.actions import DeploymentScheduleCreate, DeploymentUpdate
@@ -154,6 +163,13 @@ class RunnerDeployment(BaseModel):
     version: Optional[str] = Field(
         default=None, description="An optional version for the deployment."
     )
+    version_type: Optional[VersionType] = Field(
+        default=None,
+        description=(
+            "The type of version information to use for the deployment. The version type"
+            " will be inferred if not provided."
+        ),
+    )
     tags: ListOfNonEmptyStrings = Field(
         default_factory=list,
         description="One of more tags to apply to this deployment.",
@@ -219,6 +235,7 @@ class RunnerDeployment(BaseModel):
             " a built runner."
         ),
     )
+
     # (Experimental) SLA configuration for the deployment. May be removed or modified at any time. Currently only supported on Prefect Cloud.
     _sla: Optional[Union[SlaTypes, list[SlaTypes]]] = PrivateAttr(
         default=None,
@@ -232,6 +249,9 @@ class RunnerDeployment(BaseModel):
     _parameter_openapi_schema: ParameterSchema = PrivateAttr(
         default_factory=ParameterSchema,
     )
+    _version_from_flow: bool = PrivateAttr(
+        default=False,
+    )
 
     @property
     def entrypoint_type(self) -> EntrypointType:
@@ -241,6 +261,20 @@ class RunnerDeployment(BaseModel):
     def full_name(self) -> str:
         return f"{self.flow_name}/{self.name}"
 
+    def _get_deployment_version_info(
+        self, version_type: Optional[VersionType] = None
+    ) -> VersionInfo:
+        if inferred_version := run_coro_as_sync(
+            get_inferred_version_info(version_type)
+        ):
+            if not self.version or self._version_from_flow:
+                self.version = inferred_version.version  # TODO: maybe reconsider
+
+            inferred_version.version = self.version
+            return inferred_version
+
+        return VersionInfo(version=self.version or "", type="prefect:simple")
+
     @field_validator("name", mode="before")
     @classmethod
     def validate_name(cls, value: str) -> str:
@@ -387,7 +421,7 @@ class RunnerDeployment(BaseModel):
         update_payload = self.model_dump(
             mode="json",
             exclude_unset=True,
-            exclude={"storage", "name", "flow_name", "triggers"},
+            exclude={"storage", "name", "flow_name", "triggers", "version_type"},
         )
 
         if self.storage:
@@ -444,7 +478,7 @@ class RunnerDeployment(BaseModel):
         self,
         work_pool_name: Optional[str] = None,
         image: Optional[str] = None,
-        version_info: VersionInfo | None = None,
+        version_info: Optional[VersionInfo] = None,
     ) -> UUID:
         """
         Registers this deployment with the API and returns the deployment's ID.
@@ -455,11 +489,15 @@ class RunnerDeployment(BaseModel):
             image: The registry, name, and tag of the Docker image to
                 use for this deployment. Only used when the deployment is
                 deployed to a work pool.
-            version_info: Version information for the deployment.
+            version_info: The version information to use for the deployment.
         Returns:
             The ID of the created deployment.
         """
 
+        version_info = version_info or self._get_deployment_version_info(
+            self.version_type
+        )
+
         async with get_client() as client:
             try:
                 deployment = await client.read_deployment_by_name(self.full_name)
@@ -570,6 +608,7 @@ class RunnerDeployment(BaseModel):
 
         if not self.version:
             self.version = flow.version
+            self._version_from_flow = True
         if not self.description:
             self.description = flow.description
 
@@ -592,6 +631,7 @@ class RunnerDeployment(BaseModel):
         description: Optional[str] = None,
         tags: Optional[List[str]] = None,
         version: Optional[str] = None,
+        version_type: Optional[VersionType] = None,
         enforce_parameter_schema: bool = True,
         work_pool_name: Optional[str] = None,
         work_queue_name: Optional[str] = None,
@@ -622,6 +662,7 @@ class RunnerDeployment(BaseModel):
             tags: A list of tags to associate with the created deployment for organizational
                 purposes.
             version: A version for the created deployment. Defaults to the flow's version.
+            version_type: The type of version information to use for the deployment.
             enforce_parameter_schema: Whether or not the Prefect API should enforce the
                 parameter schema for this deployment.
             work_pool_name: The name of the work pool to use for this deployment.
@@ -662,6 +703,7 @@ class RunnerDeployment(BaseModel):
             parameters=parameters or {},
             description=description,
             version=version,
+            version_type=version_type,
             enforce_parameter_schema=enforce_parameter_schema,
             work_pool_name=work_pool_name,
             work_queue_name=work_queue_name,
@@ -837,6 +879,7 @@ class RunnerDeployment(BaseModel):
         description: Optional[str] = None,
         tags: Optional[List[str]] = None,
         version: Optional[str] = None,
+        version_type: Optional[VersionType] = None,
         enforce_parameter_schema: bool = True,
         work_pool_name: Optional[str] = None,
         work_queue_name: Optional[str] = None,
@@ -870,6 +913,8 @@ class RunnerDeployment(BaseModel):
             tags: A list of tags to associate with the created deployment for organizational
                 purposes.
             version: A version for the created deployment. Defaults to the flow's version.
+            version_type: The type of version information to use for the deployment. The version type
+                will be inferred if not provided.
             enforce_parameter_schema: Whether or not the Prefect API should enforce the
                 parameter schema for this deployment.
             work_pool_name: The name of the work pool to use for this deployment.
@@ -921,6 +966,7 @@ class RunnerDeployment(BaseModel):
             parameters=parameters or {},
             description=description,
             version=version,
+            version_type=version_type,
             entrypoint=entrypoint,
             enforce_parameter_schema=enforce_parameter_schema,
             storage=storage,
@@ -959,6 +1005,7 @@ class RunnerDeployment(BaseModel):
         description: Optional[str] = None,
         tags: Optional[List[str]] = None,
         version: Optional[str] = None,
+        version_type: Optional[VersionType] = None,
         enforce_parameter_schema: bool = True,
         work_pool_name: Optional[str] = None,
         work_queue_name: Optional[str] = None,
@@ -992,6 +1039,8 @@ class RunnerDeployment(BaseModel):
             tags: A list of tags to associate with the created deployment for organizational
                 purposes.
             version: A version for the created deployment. Defaults to the flow's version.
+            version_type: The type of version information to use for the deployment. The version type
+                will be inferred if not provided.
             enforce_parameter_schema: Whether or not the Prefect API should enforce the
                 parameter schema for this deployment.
             work_pool_name: The name of the work pool to use for this deployment.
@@ -1041,6 +1090,7 @@ class RunnerDeployment(BaseModel):
             parameters=parameters or {},
             description=description,
             version=version,
+            version_type=version_type,
             entrypoint=entrypoint,
             enforce_parameter_schema=enforce_parameter_schema,
             storage=storage,

prefect/events/clients.py

@@ -251,8 +251,8 @@ class EventsClient(abc.ABC):
 
     async def __aexit__(
         self,
-        exc_type: Optional[Type[Exception]],
-        exc_val: Optional[Exception],
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
         exc_tb: Optional[TracebackType],
     ) -> None:
         del self._in_context
@@ -360,8 +360,8 @@ class PrefectEventsClient(EventsClient):
 
     async def __aexit__(
         self,
-        exc_type: Optional[Type[Exception]],
-        exc_val: Optional[Exception],
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
         exc_tb: Optional[TracebackType],
     ) -> None:
         self._websocket = None
@@ -684,8 +684,8 @@ class PrefectEventSubscriber:
 
     async def __aexit__(
         self,
-        exc_type: Optional[Type[Exception]],
-        exc_val: Optional[Exception],
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
         exc_tb: Optional[TracebackType],
     ) -> None:
         self._websocket = None

prefect/events/filters.py

@@ -1,5 +1,7 @@
+from __future__ import annotations
+
 import datetime
-from typing import Optional
+from typing import Optional, Union
 from uuid import UUID
 
 from pydantic import Field
@@ -43,11 +45,21 @@ class EventDataFilter(PrefectBaseModel, extra="forbid"):  # type: ignore[call-ar
     """A base class for filtering event data."""
 
     def get_filters(self) -> list["EventDataFilter"]:
-        filters: list["EventDataFilter"] = [
-            filter
-            for filter in [getattr(self, name) for name in type(self).model_fields]
-            if isinstance(filter, EventDataFilter)
-        ]
+        filters: list[EventDataFilter] = []
+        for filter in [
+            getattr(self, name) for name in self.__class__.model_fields.keys()
+        ]:
+            # Any embedded list of filters are flattened and thus ANDed together
+            subfilters: list[EventDataFilter] = (
+                filter if isinstance(filter, list) else [filter]
+            )
+
+            for subfilter in subfilters:
+                if not isinstance(subfilter, EventDataFilter):
+                    continue
+
+                filters.append(subfilter)
+
         return filters
 
     def includes(self, event: Event) -> bool:
@@ -233,18 +245,20 @@ class EventFilter(EventDataFilter):
         default=None,
         description="Filter criteria for the event name",
     )
-    any_resource: Optional[EventAnyResourceFilter] = Field(
-        default=None,
-        description="Filter criteria for any resource involved in the event",
-    )
     resource: Optional[EventResourceFilter] = Field(
         default=None,
         description="Filter criteria for the resource of the event",
     )
-    related: Optional[EventRelatedFilter] = Field(
+    related: Optional[Union[EventRelatedFilter, list[EventRelatedFilter]]] = Field(
         default=None,
         description="Filter criteria for the related resources of the event",
     )
+    any_resource: Optional[
+        Union[EventAnyResourceFilter, list[EventAnyResourceFilter]]
+    ] = Field(
+        default=None,
+        description="Filter criteria for any resource involved in the event",
+    )
     id: EventIDFilter = Field(
         default_factory=lambda: EventIDFilter(id=[]),
         description="Filter criteria for the events' ID",

prefect/events/schemas/automations.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import abc
 import textwrap
 from datetime import timedelta
@@ -103,7 +105,7 @@ class ResourceTrigger(Trigger, abc.ABC):
         default_factory=lambda: ResourceSpecification.model_validate({}),
         description="Labels for resources which this trigger will match.",
     )
-    match_related: ResourceSpecification = Field(
+    match_related: Union[ResourceSpecification, list[ResourceSpecification]] = Field(
         default_factory=lambda: ResourceSpecification.model_validate({}),
         description="Labels for related resources which this trigger will match.",
     )

prefect/events/schemas/events.py

@@ -13,7 +13,7 @@ from typing import (
     Tuple,
     Union,
 )
-from uuid import UUID, uuid4
+from uuid import UUID
 
 from pydantic import (
     AfterValidator,
@@ -26,6 +26,7 @@ from typing_extensions import Annotated, Self
 
 import prefect.types._datetime
 from prefect._internal.schemas.bases import PrefectBaseModel
+from prefect._internal.uuid7 import uuid7
 from prefect.logging import get_logger
 from prefect.settings import (
     PREFECT_EVENTS_MAXIMUM_LABELS_PER_RESOURCE,
@@ -135,7 +136,7 @@ class Event(PrefectBaseModel):
         description="An open-ended set of data describing what happened",
     )
     id: UUID = Field(
-        default_factory=uuid4,
+        default_factory=uuid7,
         description="The client-provided identifier of this event",
     )
     follows: Optional[UUID] = Field(

prefect/flows.py

@@ -27,6 +27,7 @@ from typing import (
     Coroutine,
     Generic,
     Iterable,
+    List,
     NoReturn,
     Optional,
     Protocol,
@@ -49,6 +50,7 @@ from typing_extensions import Literal, ParamSpec
 
 from prefect._experimental.sla.objects import SlaTypes
 from prefect._internal.concurrency.api import create_call, from_async
+from prefect._versioning import VersionType
 from prefect.blocks.core import Block
 from prefect.client.schemas.filters import WorkerFilter, WorkerFilterStatus
 from prefect.client.schemas.objects import ConcurrencyLimitConfig, FlowRun
@@ -704,6 +706,7 @@ class Flow(Generic[P, R]):
         description: Optional[str] = None,
         tags: Optional[list[str]] = None,
         version: Optional[str] = None,
+        version_type: Optional[VersionType] = None,
         enforce_parameter_schema: bool = True,
         work_pool_name: Optional[str] = None,
         work_queue_name: Optional[str] = None,
@@ -733,6 +736,8 @@ class Flow(Generic[P, R]):
             tags: A list of tags to associate with the created deployment for organizational
                 purposes.
             version: A version for the created deployment. Defaults to the flow's version.
+            version_type: The type of version to use for the created deployment. The version type
+                will be inferred if not provided.
             enforce_parameter_schema: Whether or not the Prefect API should enforce the
                 parameter schema for the created deployment.
             work_pool_name: The name of the work pool to use for this deployment.
@@ -787,6 +792,7 @@ class Flow(Generic[P, R]):
                 parameters=parameters or {},
                 description=description,
                 version=version,
+                version_type=version_type,
                 enforce_parameter_schema=enforce_parameter_schema,
                 work_pool_name=work_pool_name,
                 work_queue_name=work_queue_name,
@@ -809,6 +815,7 @@ class Flow(Generic[P, R]):
                 parameters=parameters or {},
                 description=description,
                 version=version,
+                version_type=version_type,
                 enforce_parameter_schema=enforce_parameter_schema,
                 work_pool_name=work_pool_name,
                 work_queue_name=work_queue_name,
@@ -840,6 +847,7 @@ class Flow(Generic[P, R]):
         description: Optional[str] = None,
         tags: Optional[list[str]] = None,
         version: Optional[str] = None,
+        version_type: Optional[VersionType] = None,
         enforce_parameter_schema: bool = True,
         work_pool_name: Optional[str] = None,
         work_queue_name: Optional[str] = None,
@@ -869,6 +877,8 @@ class Flow(Generic[P, R]):
             tags: A list of tags to associate with the created deployment for organizational
                 purposes.
             version: A version for the created deployment. Defaults to the flow's version.
+            version_type: The type of version to use for the created deployment. The version type
+                will be inferred if not provided.
             enforce_parameter_schema: Whether or not the Prefect API should enforce the
                 parameter schema for the created deployment.
             work_pool_name: The name of the work pool to use for this deployment.
@@ -925,6 +935,7 @@ class Flow(Generic[P, R]):
                     parameters=parameters or {},
                     description=description,
                     version=version,
+                    version_type=version_type,
                     enforce_parameter_schema=enforce_parameter_schema,
                     work_pool_name=work_pool_name,
                     work_queue_name=work_queue_name,
@@ -949,6 +960,7 @@ class Flow(Generic[P, R]):
                 parameters=parameters or {},
                 description=description,
                 version=version,
+                version_type=version_type,
                 enforce_parameter_schema=enforce_parameter_schema,
                 work_pool_name=work_pool_name,
                 work_queue_name=work_queue_name,
@@ -1375,6 +1387,7 @@ class Flow(Generic[P, R]):
         description: Optional[str] = None,
         tags: Optional[list[str]] = None,
         version: Optional[str] = None,
+        version_type: Optional[VersionType] = None,
         enforce_parameter_schema: bool = True,
         entrypoint_type: EntrypointType = EntrypointType.FILE_PATH,
         print_next_steps: bool = True,
@@ -1426,6 +1439,8 @@ class Flow(Generic[P, R]):
             tags: A list of tags to associate with the created deployment for organizational
                 purposes.
             version: A version for the created deployment. Defaults to the flow's version.
+            version_type: The type of version to use for the created deployment. The version type
+                will be inferred if not provided.
             enforce_parameter_schema: Whether or not the Prefect API should enforce the
                 parameter schema for the created deployment.
             entrypoint_type: Type of entrypoint to use for the deployment. When using a module path
@@ -1510,6 +1525,7 @@ class Flow(Generic[P, R]):
             description=description,
             tags=tags,
             version=version,
+            version_type=version_type,
             enforce_parameter_schema=enforce_parameter_schema,
             work_queue_name=work_queue_name,
             job_variables=job_variables,
@@ -2294,8 +2310,9 @@ def load_flow_from_entrypoint(
     Extract a flow object from a script at an entrypoint by running all of the code in the file.
 
     Args:
-        entrypoint: a string in the format `<path_to_script>:<flow_func_name>` or a module path
-            to a flow function
+        entrypoint: a string in the format `<path_to_script>:<flow_func_name>`
+            or a string in the format `<path_to_script>:<class_name>.<flow_method_name>`
+            or a module path to a flow function
         use_placeholder_flow: if True, use a placeholder Flow object if the actual flow object
             cannot be loaded from the entrypoint (e.g. dependencies are missing)
 
@@ -2685,26 +2702,55 @@ def load_placeholder_flow(entrypoint: str, raises: Exception) -> Flow[P, Any]:
 
 def safe_load_flow_from_entrypoint(entrypoint: str) -> Optional[Flow[P, Any]]:
     """
-    Load a flow from an entrypoint and return None if an exception is raised.
+    Safely load a Prefect flow from an entrypoint string. Returns None if loading fails.
 
     Args:
-        entrypoint: a string in the format `<path_to_script>:<flow_func_name>`
-          or a module path to a flow function
+        entrypoint (str): A string identifying the flow to load. Can be in one of the following formats:
+            - `<path_to_script>:<flow_func_name>`
+            - `<path_to_script>:<class_name>.<flow_method_name>`
+            - `<module_path>.<flow_func_name>`
+
+    Returns:
+        Optional[Flow]: The loaded Prefect flow object, or None if loading fails due to errors
+        (e.g. unresolved dependencies, syntax errors, or missing objects).
     """
-    func_def, source_code = _entrypoint_definition_and_source(entrypoint)
-    path = None
-    if ":" in entrypoint:
-        path = entrypoint.rsplit(":")[0]
+    func_or_cls_def, source_code, parts = _entrypoint_definition_and_source(entrypoint)
+
+    path = entrypoint.rsplit(":", maxsplit=1)[0] if ":" in entrypoint else None
     namespace = safe_load_namespace(source_code, filepath=path)
-    if func_def.name in namespace:
-        return namespace[func_def.name]
-    else:
-        # If the function is not in the namespace, if may be due to missing dependencies
-        # for the function. We will attempt to compile each annotation and default value
-        # and remove them from the function definition to see if the function can be
-        # compiled without them.
 
-        return _sanitize_and_load_flow(func_def, namespace)
+    if parts[0] not in namespace:
+        # If the object is not in the namespace, it may be due to missing dependencies
+        # in annotations or default values. We will attempt to sanitize them by removing
+        # anything that cannot be compiled, and then recompile the function or class.
+        if isinstance(func_or_cls_def, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            return _sanitize_and_load_flow(func_or_cls_def, namespace)
+        elif (
+            isinstance(func_or_cls_def, ast.ClassDef)
+            and len(parts) >= 2
+            and func_or_cls_def.name == parts[0]
+        ):
+            method_name = parts[1]
+            method_def = next(
+                (
+                    stmt
+                    for stmt in func_or_cls_def.body
+                    if isinstance(stmt, (ast.FunctionDef, ast.AsyncFunctionDef))
+                    and stmt.name == method_name
+                ),
+                None,
+            )
+            if method_def is not None:
+                return _sanitize_and_load_flow(method_def, namespace)
+        else:
+            return None
+
+    obj = namespace.get(parts[0])
+    for part in parts[1:]:
+        obj = getattr(obj, part, None)
+        if obj is None:
+            return None
+    return obj
 
 
 def _sanitize_and_load_flow(
@@ -2838,7 +2884,7 @@ def load_flow_arguments_from_entrypoint(
           or a module path to a flow function
     """
 
-    func_def, source_code = _entrypoint_definition_and_source(entrypoint)
+    func_def, source_code, _ = _entrypoint_definition_and_source(entrypoint)
     path = None
     if ":" in entrypoint:
         path = entrypoint.rsplit(":")[0]
@@ -2915,26 +2961,45 @@ def is_entrypoint_async(entrypoint: str) -> bool:
     Returns:
         True if the function is asynchronous, False otherwise.
     """
-    func_def, _ = _entrypoint_definition_and_source(entrypoint)
+    func_def, _, _ = _entrypoint_definition_and_source(entrypoint)
     return isinstance(func_def, ast.AsyncFunctionDef)
 
 
 def _entrypoint_definition_and_source(
     entrypoint: str,
-) -> Tuple[Union[ast.FunctionDef, ast.AsyncFunctionDef], str]:
+) -> Tuple[Union[ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef], str, List[str]]:
+    """
+    Resolves and parses the source definition of a given entrypoint.
+
+    The entrypoint can be provided in one of the following formats:
+        - '<path_to_script>:<flow_func_name>'
+        - '<path_to_script>:<class_name>.<flow_method_name>'
+        - '<module_path.to.flow_function>'
+
+    Returns:
+        A tuple containing:
+        - The AST node (FunctionDef, AsyncFunctionDef, or ClassDef) of the base object.
+        - The full source code of the file or module as a string.
+        - A list of attribute access parts from the object path (e.g., ['MyFlowClass', 'run']).
+
+    Raises:
+        ValueError: If the module or target object cannot be found.
+    """
     if ":" in entrypoint:
-        # Split by the last colon once to handle Windows paths with drive letters i.e C:\path\to\file.py:do_stuff
-        path, func_name = entrypoint.rsplit(":", maxsplit=1)
+        path, object_path = entrypoint.rsplit(":", maxsplit=1)
         source_code = Path(path).read_text()
     else:
-        path, func_name = entrypoint.rsplit(".", maxsplit=1)
+        path, object_path = entrypoint.rsplit(".", maxsplit=1)
         spec = importlib.util.find_spec(path)
         if not spec or not spec.origin:
             raise ValueError(f"Could not find module {path!r}")
         source_code = Path(spec.origin).read_text()
 
     parsed_code = ast.parse(source_code)
-    func_def = next(
+    parts = object_path.split(".")
+    base_name = parts[0]
+
+    base_def = next(
         (
             node
             for node in ast.walk(parsed_code)
@@ -2943,14 +3008,15 @@ def _entrypoint_definition_and_source(
                 (
                     ast.FunctionDef,
                     ast.AsyncFunctionDef,
+                    ast.ClassDef,  # flow can be staticmethod/classmethod
                 ),
             )
-            and node.name == func_name
+            and node.name == base_name
         ),
         None,
     )
 
-    if not func_def:
-        raise ValueError(f"Could not find flow {func_name!r} in {path!r}")
+    if not base_def:
+        raise ValueError(f"Could not find object {base_name!r} in {path!r}")
 
-    return func_def, source_code
+    return base_def, source_code, parts

prefect/infrastructure/provisioners/cloud_run.py

@@ -133,6 +133,7 @@ class CloudRunPushProvisioner:
             await self._run_command(
                 f"gcloud iam service-accounts create {self._service_account_name}"
                 ' --display-name "Prefect Cloud Run Service Account"'
+                f" --project={self._project}"
             )
         except subprocess.CalledProcessError as e:
             if "already exists" not in e.output.decode("utf-8"):

prefect/runner/_observers.py

@@ -0,0 +1,60 @@
+import asyncio
+import uuid
+from contextlib import AsyncExitStack
+from typing import Any, Protocol
+
+from prefect.events.clients import PrefectEventSubscriber, get_events_subscriber
+from prefect.events.filters import EventFilter, EventNameFilter
+from prefect.logging.loggers import get_logger
+
+
+class OnCancellingCallback(Protocol):
+    def __call__(self, flow_run_id: uuid.UUID) -> None: ...
+
+
+class FlowRunCancellingObserver:
+    def __init__(self, on_cancelling: OnCancellingCallback):
+        self.logger = get_logger("FlowRunCancellingObserver")
+        self.on_cancelling = on_cancelling
+        self._events_subscriber: PrefectEventSubscriber | None
+        self._exit_stack = AsyncExitStack()
+
+    async def _consume_events(self):
+        if self._events_subscriber is None:
+            raise RuntimeError(
+                "Events subscriber not initialized. Please use `async with` to initialize the observer."
+            )
+        async for event in self._events_subscriber:
+            try:
+                flow_run_id = uuid.UUID(
+                    event.resource["prefect.resource.id"].replace(
+                        "prefect.flow-run.", ""
+                    )
+                )
+                self.on_cancelling(flow_run_id)
+            except ValueError:
+                self.logger.debug(
+                    "Received event with invalid flow run ID: %s",
+                    event.resource["prefect.resource.id"],
+                )
+
+    async def __aenter__(self):
+        self._events_subscriber = await self._exit_stack.enter_async_context(
+            get_events_subscriber(
+                filter=EventFilter(
+                    event=EventNameFilter(name=["prefect.flow-run.Cancelling"])
+                )
+            )
+        )
+        self._consumer_task = asyncio.create_task(self._consume_events())
+        return self
+
+    async def __aexit__(self, *exc_info: Any):
+        await self._exit_stack.__aexit__(*exc_info)
+        self._consumer_task.cancel()
+        try:
+            await self._consumer_task
+        except asyncio.CancelledError:
+            pass
+        except Exception:
+            self.logger.exception("Error consuming events")