prefect-client 3.0.0rc2__py3-none-any.whl → 3.0.0rc4__py3-none-any.whl

prefect/__init__.py

@@ -43,7 +43,6 @@ import prefect.runtime
 
 # Import modules that register types
 import prefect.serializers
-import prefect.blocks.kubernetes
 import prefect.blocks.notifications
 import prefect.blocks.system
 

prefect/_internal/compatibility/migration.py

@@ -0,0 +1,124 @@
+"""
+This module provides a function to handle imports for moved or removed objects in Prefect 3.0 upgrade.
+
+The `getattr_migration` function is used to handle imports for moved or removed objects in Prefect 3.0 upgrade.
+It is used in the `__getattr__` attribute of modules that have moved or removed objects.
+
+Usage:
+```python
+from prefect._internal.compatibility.migration import getattr_migration
+
+__getattr__ = getattr_migration(__name__)
+```
+"""
+
+import sys
+from typing import Any, Callable, Dict
+
+from pydantic_core import PydanticCustomError
+
+from prefect.exceptions import PrefectImportError
+
+MOVED_IN_V3 = {
+    "prefect.deployments.deployments:load_flow_from_flow_run": "prefect.flows:load_flow_from_flow_run",
+    "prefect.deployments:load_flow_from_flow_run": "prefect.flows:load_flow_from_flow_run",
+    "prefect.variables:get": "prefect.variables:Variable.get",
+    "prefect.engine:pause_flow_run": "prefect.flow_runs:pause_flow_run",
+    "prefect.engine:resume_flow_run": "prefect.flow_runs:resume_flow_run",
+    "prefect.engine:suspend_flow_run": "prefect.flow_runs:suspend_flow_run",
+    "prefect.engine:_in_process_pause": "prefect.flow_runs:_in_process_pause",
+}
+
+REMOVED_IN_V3 = {
+    "prefect.deployments.deployments:Deployment": "Use 'flow.serve()' or `prefect deploy` instead.",
+    "prefect.deployments:Deployment": "Use 'flow.serve()' or `prefect deploy` instead.",
+    "prefect.filesystems:GCS": "Use 'prefect_gcp' instead.",
+    "prefect.filesystems:Azure": "Use 'prefect_azure' instead.",
+    "prefect.filesystems:S3": "Use 'prefect_aws' instead.",
+    "prefect.engine:_out_of_process_pause": "Use 'prefect.flow_runs.pause_flow_run' instead.",
+}
+
+# IMPORTANT FOR USAGE: When adding new modules to MOVED_IN_V3 or REMOVED_IN_V3, include the following lines at the bottom of that module:
+# from prefect._internal.compatibility.migration import getattr_migration
+# __getattr__ = getattr_migration(__name__)
+# See src/prefect/filesystems.py for an example
+
+
+def import_string_class_method(new_location: str) -> Callable:
+    """
+    Handle moved class methods.
+
+    `import_string` does not account for moved class methods. This function handles cases where a method has been
+    moved to a class. For example, if `new_location` is 'prefect.variables:Variable.get', `import_string(new_location)`
+    will raise an error because it does not handle class methods. This function will import the class and get the
+    method from the class.
+
+    Args:
+        new_location (str): The new location of the method.
+
+    Returns:
+        method: The resolved method from the class.
+
+    Raises:
+        PrefectImportError: If the method is not found in the class.
+    """
+    from pydantic._internal._validators import import_string
+
+    class_name, method_name = new_location.rsplit(".", 1)
+
+    cls = import_string(class_name)
+    method = getattr(cls, method_name, None)
+
+    if method is not None and callable(method):
+        return method
+
+    raise PrefectImportError(f"Unable to import {new_location!r}")
+
+
+def getattr_migration(module_name: str) -> Callable[[str], Any]:
+    """
+    Handle imports for moved or removed objects in Prefect 3.0 upgrade
+
+    Args:
+        module_name (str): The name of the module to handle imports for.
+    """
+
+    def wrapper(name: str) -> object:
+        """
+        Raise a PrefectImportError if the object is not found, moved, or removed.
+        """
+
+        if name == "__path__":
+            raise AttributeError(f"{module_name!r} object has no attribute {name!r}")
+        import warnings
+
+        from pydantic._internal._validators import import_string
+
+        import_path = f"{module_name}:{name}"
+
+        # Check if the attribute name corresponds to a moved or removed class or module
+        if import_path in MOVED_IN_V3.keys():
+            new_location = MOVED_IN_V3[import_path]
+            warnings.warn(
+                f"{import_path!r} has been moved to {new_location!r}. Importing from {new_location!r} instead. This warning will raise an error in a future release.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            try:
+                return import_string(new_location)
+            except PydanticCustomError:
+                return import_string_class_method(new_location)
+
+        if import_path in REMOVED_IN_V3.keys():
+            error_message = REMOVED_IN_V3[import_path]
+            raise PrefectImportError(
+                f"{import_path!r} has been removed. {error_message}"
+            )
+
+        globals: Dict[str, Any] = sys.modules[module_name].__dict__
+        if name in globals:
+            return globals[name]
+
+        raise AttributeError(f"module {module_name!r} has no attribute {name!r}")
+
+    return wrapper

prefect/_internal/concurrency/__init__.py

@@ -5,7 +5,7 @@ both asynchronous and synchronous calls.
 Much of the complexity managed here arises from ensuring that a thread of execution is
 not blocked.
 
-The main data structure is a `Call` which is created from a function call capturing 
+The main data structure is a `Call` which is created from a function call capturing
 local context variables. The call is then submitted to run somewhere via a `Portal`.
 The primary portal used is the `WorkerThread`, which executes work on a thread running
 concurrently to the one that created the call. A singleton `EventLoopThread` portal
@@ -13,7 +13,7 @@ is also used to schedule work on a dedicated event loop.
 
 The result of the call can be retrieved asynchronously using `Call.result()`. Behind
 the scenes, a `Future` is used to report the result of the call. Retrieving the result
-of a call is a blocking operation. 
+of a call is a blocking operation.
 
 Sometimes, it is important not to block the current thread while retrieving the result
 of a call. For this purpose, there is the `Waiter`. Waiters attach to a call and provide

prefect/_internal/concurrency/primitives.py

@@ -1,6 +1,7 @@
 """
 Thread-safe async synchronization primitives.
 """
+
 import asyncio
 import collections
 import threading

prefect/_internal/pydantic/annotations/pendulum.py

@@ -1,6 +1,6 @@
 """
-This file contains compat code to handle pendulum.DateTime objects during jsonschema 
-generation and validation. 
+This file contains compat code to handle pendulum.DateTime objects during jsonschema
+generation and validation.
 """
 
 import typing as t

prefect/_internal/pytz.py

@@ -1,5 +1,5 @@
 """
-This is a compatibility module that allows us to drop our dependency on pytz in the minimal prefect-client. 
+This is a compatibility module that allows us to drop our dependency on pytz in the minimal prefect-client.
 
 All values here are taken from:
 

prefect/blocks/core.py

@@ -1122,7 +1122,7 @@ class Block(BaseModel, ABC):
         cls,
         by_alias: bool = True,
         ref_template: str = "#/definitions/{model}",
-        schema_generator: type[GenerateJsonSchema] = GenerateJsonSchema,
+        schema_generator: Type[GenerateJsonSchema] = GenerateJsonSchema,
         mode: Literal["validation", "serialization"] = "validation",
     ) -> Dict[str, Any]:
         """TODO: stop overriding this method - use GenerateSchema in ConfigDict instead?"""

prefect/client/orchestration.py

@@ -270,8 +270,8 @@ class PrefectClient:
         self,
         api: Union[str, ASGIApp],
         *,
-        api_key: str = None,
-        api_version: str = None,
+        api_key: Optional[str] = None,
+        api_version: Optional[str] = None,
         httpx_settings: Optional[Dict[str, Any]] = None,
     ) -> None:
         httpx_settings = httpx_settings.copy() if httpx_settings else {}
@@ -506,7 +506,7 @@ class PrefectClient:
         work_pool_filter: WorkPoolFilter = None,
         work_queue_filter: WorkQueueFilter = None,
         sort: FlowSort = None,
-        limit: int = None,
+        limit: Optional[int] = None,
         offset: int = 0,
     ) -> List[Flow]:
         """
@@ -576,12 +576,12 @@ class PrefectClient:
         *,
         parameters: Optional[Dict[str, Any]] = None,
         context: Optional[Dict[str, Any]] = None,
-        state: prefect.states.State = None,
-        name: str = None,
-        tags: Iterable[str] = None,
-        idempotency_key: str = None,
-        parent_task_run_id: UUID = None,
-        work_queue_name: str = None,
+        state: Optional[prefect.states.State] = None,
+        name: Optional[str] = None,
+        tags: Optional[Iterable[str]] = None,
+        idempotency_key: Optional[str] = None,
+        parent_task_run_id: Optional[UUID] = None,
+        work_queue_name: Optional[str] = None,
         job_variables: Optional[Dict[str, Any]] = None,
     ) -> FlowRun:
         """
@@ -1710,7 +1710,7 @@ class PrefectClient:
         self,
         deployment: Deployment,
         schedule: SCHEDULE_TYPES = None,
-        is_schedule_active: bool = None,
+        is_schedule_active: Optional[bool] = None,
     ):
         deployment_update = DeploymentUpdate(
             version=deployment.version,
@@ -2060,7 +2060,7 @@ class PrefectClient:
         work_pool_filter: WorkPoolFilter = None,
         work_queue_filter: WorkQueueFilter = None,
         sort: FlowRunSort = None,
-        limit: int = None,
+        limit: Optional[int] = None,
         offset: int = 0,
     ) -> List[FlowRun]:
         """
@@ -2133,7 +2133,6 @@ class PrefectClient:
         state_create = state.to_state_create()
         state_create.state_details.flow_run_id = flow_run_id
         state_create.state_details.transition_id = uuid4()
-        print(repr(state_create))
         try:
             response = await self._client.post(
                 f"/flow_runs/{flow_run_id}/set_state",
@@ -2268,7 +2267,7 @@ class PrefectClient:
         task_run_filter: TaskRunFilter = None,
         deployment_filter: DeploymentFilter = None,
         sort: TaskRunSort = None,
-        limit: int = None,
+        limit: Optional[int] = None,
         offset: int = 0,
     ) -> List[TaskRun]:
         """
@@ -2532,8 +2531,8 @@ class PrefectClient:
     async def read_logs(
         self,
         log_filter: LogFilter = None,
-        limit: int = None,
-        offset: int = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
         sort: LogSort = LogSort.TIMESTAMP_ASC,
     ) -> List[Log]:
         """
@@ -2864,7 +2863,7 @@ class PrefectClient:
         flow_run_filter: FlowRunFilter = None,
         task_run_filter: TaskRunFilter = None,
         sort: ArtifactSort = None,
-        limit: int = None,
+        limit: Optional[int] = None,
         offset: int = 0,
     ) -> List[Artifact]:
         """
@@ -2904,7 +2903,7 @@ class PrefectClient:
         flow_run_filter: FlowRunFilter = None,
         task_run_filter: TaskRunFilter = None,
         sort: ArtifactCollectionSort = None,
-        limit: int = None,
+        limit: Optional[int] = None,
         offset: int = 0,
     ) -> List[ArtifactCollection]:
         """
@@ -3004,7 +3003,7 @@ class PrefectClient:
             else:
                 raise
 
-    async def read_variables(self, limit: int = None) -> List[Variable]:
+    async def read_variables(self, limit: Optional[int] = None) -> List[Variable]:
         """Reads all variables."""
         response = await self._client.post("/variables/filter", json={"limit": limit})
         return pydantic.TypeAdapter(List[Variable]).validate_python(response.json())
@@ -3371,8 +3370,8 @@ class SyncPrefectClient:
         self,
         api: Union[str, ASGIApp],
         *,
-        api_key: str = None,
-        api_version: str = None,
+        api_key: Optional[str] = None,
+        api_version: Optional[str] = None,
         httpx_settings: Optional[Dict[str, Any]] = None,
     ) -> None:
         httpx_settings = httpx_settings.copy() if httpx_settings else {}
@@ -3669,6 +3668,61 @@ class SyncPrefectClient:
 
         return flow_run
 
+    def update_flow_run(
+        self,
+        flow_run_id: UUID,
+        flow_version: Optional[str] = None,
+        parameters: Optional[dict] = None,
+        name: Optional[str] = None,
+        tags: Optional[Iterable[str]] = None,
+        empirical_policy: Optional[FlowRunPolicy] = None,
+        infrastructure_pid: Optional[str] = None,
+        job_variables: Optional[dict] = None,
+    ) -> httpx.Response:
+        """
+        Update a flow run's details.
+
+        Args:
+            flow_run_id: The identifier for the flow run to update.
+            flow_version: A new version string for the flow run.
+            parameters: A dictionary of parameter values for the flow run. This will not
+                be merged with any existing parameters.
+            name: A new name for the flow run.
+            empirical_policy: A new flow run orchestration policy. This will not be
+                merged with any existing policy.
+            tags: An iterable of new tags for the flow run. These will not be merged with
+                any existing tags.
+            infrastructure_pid: The id of flow run as returned by an
+                infrastructure block.
+
+        Returns:
+            an `httpx.Response` object from the PATCH request
+        """
+        params = {}
+        if flow_version is not None:
+            params["flow_version"] = flow_version
+        if parameters is not None:
+            params["parameters"] = parameters
+        if name is not None:
+            params["name"] = name
+        if tags is not None:
+            params["tags"] = tags
+        if empirical_policy is not None:
+            params["empirical_policy"] = empirical_policy.model_dump(
+                mode="json", exclude_unset=True
+            )
+        if infrastructure_pid:
+            params["infrastructure_pid"] = infrastructure_pid
+        if job_variables is not None:
+            params["job_variables"] = job_variables
+
+        flow_run_data = FlowRunUpdate(**params)
+
+        return self._client.patch(
+            f"/flow_runs/{flow_run_id}",
+            json=flow_run_data.model_dump(mode="json", exclude_unset=True),
+        )
+
     def read_flow_run(self, flow_run_id: UUID) -> FlowRun:
         """
         Query the Prefect API for a flow run by id.
@@ -3698,7 +3752,7 @@ class SyncPrefectClient:
         work_pool_filter: WorkPoolFilter = None,
         work_queue_filter: WorkQueueFilter = None,
         sort: FlowRunSort = None,
-        limit: int = None,
+        limit: Optional[int] = None,
         offset: int = 0,
     ) -> List[FlowRun]:
         """
@@ -3890,7 +3944,7 @@ class SyncPrefectClient:
         task_run_filter: TaskRunFilter = None,
         deployment_filter: DeploymentFilter = None,
         sort: TaskRunSort = None,
-        limit: int = None,
+        limit: Optional[int] = None,
         offset: int = 0,
     ) -> List[TaskRun]:
         """
@@ -3994,3 +4048,23 @@ class SyncPrefectClient:
             else:
                 raise
         return DeploymentResponse.model_validate(response.json())
+
+    def create_artifact(
+        self,
+        artifact: ArtifactCreate,
+    ) -> Artifact:
+        """
+        Creates an artifact with the provided configuration.
+
+        Args:
+            artifact: Desired configuration for the new artifact.
+        Returns:
+            Information about the newly created artifact.
+        """
+
+        response = self._client.post(
+            "/artifacts/",
+            json=artifact.model_dump_json(exclude_unset=True),
+        )
+
+        return Artifact.model_validate(response.json())

prefect/client/schemas/actions.py

@@ -788,6 +788,6 @@ class GlobalConcurrencyLimitUpdate(ActionBaseModel):
 
     name: Optional[Name] = Field(None)
     limit: Optional[NonNegativeInteger] = Field(None)
-    active: Optional[NonNegativeInteger] = Field(None)
+    active: Optional[bool] = Field(None)
     active_slots: Optional[NonNegativeInteger] = Field(None)
     slot_decay_per_second: Optional[NonNegativeFloat] = Field(None)

prefect/client/schemas/filters.py

@@ -166,12 +166,18 @@ class FlowRunFilterStateType(PrefectBaseModel):
     any_: Optional[List[StateType]] = Field(
         default=None, description="A list of flow run state types to include"
     )
+    not_any_: Optional[List[StateType]] = Field(
+        default=None, description="A list of flow run state types to exclude"
+    )
 
 
 class FlowRunFilterStateName(PrefectBaseModel):
     any_: Optional[List[str]] = Field(
         default=None, description="A list of flow run state names to include"
     )
+    not_any_: Optional[List[str]] = Field(
+        default=None, description="A list of flow run state names to exclude"
+    )
 
 
 class FlowRunFilterState(PrefectBaseModel, OperatorMixin):

prefect/client/schemas/objects.py

@@ -422,8 +422,11 @@ class FlowRunPolicy(PrefectBaseModel):
     )
 
     @model_validator(mode="before")
-    def populate_deprecated_fields(cls, values):
-        return set_run_policy_deprecated_fields(values)
+    @classmethod
+    def populate_deprecated_fields(cls, values: Any):
+        if isinstance(values, dict):
+            return set_run_policy_deprecated_fields(values)
+        return values
 
 
 class FlowRun(ObjectBaseModel):
@@ -915,6 +918,7 @@ class BlockDocument(ObjectBaseModel):
     _validate_name_format = field_validator("name")(validate_block_document_name)
 
     @model_validator(mode="before")
+    @classmethod
     def validate_name_is_present_if_not_anonymous(cls, values):
         return validate_name_present_on_nonanonymous_blocks(values)
 
@@ -1146,8 +1150,11 @@ class BlockDocumentReference(ObjectBaseModel):
     )
 
     @model_validator(mode="before")
+    @classmethod
     def validate_parent_and_ref_are_different(cls, values):
-        return validate_parent_and_ref_diff(values)
+        if isinstance(values, dict):
+            return validate_parent_and_ref_diff(values)
+        return values
 
 
 class Configuration(ObjectBaseModel):

prefect/client/subscriptions.py

@@ -1,5 +1,5 @@
 import asyncio
-from typing import Any, Dict, Generic, List, Optional, Type, TypeVar
+from typing import Any, Dict, Generic, Iterable, Optional, Type, TypeVar
 
 import orjson
 import websockets
@@ -9,7 +9,7 @@ from typing_extensions import Self
 
 from prefect._internal.schemas.bases import IDBaseModel
 from prefect.logging import get_logger
-from prefect.settings import PREFECT_API_KEY, PREFECT_API_URL
+from prefect.settings import PREFECT_API_KEY
 
 logger = get_logger(__name__)
 
@@ -21,15 +21,16 @@ class Subscription(Generic[S]):
         self,
         model: Type[S],
         path: str,
-        keys: List[str],
+        keys: Iterable[str],
         client_id: Optional[str] = None,
+        base_url: Optional[str] = None,
     ):
         self.model = model
         self.client_id = client_id
-        base_url = PREFECT_API_URL.value().replace("http", "ws", 1)
+        base_url = base_url.replace("http", "ws", 1)
         self.subscription_url = f"{base_url}{path}"
 
-        self.keys = keys
+        self.keys = list(keys)
 
         self._connect = websockets.connect(
             self.subscription_url,

prefect/context.py

@@ -29,13 +29,9 @@ from typing import (
     Union,
 )
 
-import anyio
-import anyio._backends._asyncio
-import anyio.abc
 import pendulum
 from pydantic import BaseModel, ConfigDict, Field, PrivateAttr
 from pydantic_extra_types.pendulum_dt import DateTime
-from sniffio import AsyncLibraryNotFoundError
 from typing_extensions import Self
 
 import prefect.logging
@@ -45,7 +41,6 @@ from prefect.client.orchestration import PrefectClient, SyncPrefectClient, get_c
 from prefect.client.schemas import FlowRun, TaskRun
 from prefect.events.worker import EventsWorker
 from prefect.exceptions import MissingContextError
-from prefect.futures import PrefectFuture
 from prefect.results import ResultFactory
 from prefect.settings import PREFECT_HOME, Profile, Settings
 from prefect.states import State
@@ -94,19 +89,12 @@ def hydrated_context(
             if settings_context := serialized_context.get("settings_context"):
                 stack.enter_context(SettingsContext(**settings_context))
             # Set up parent flow run context
-            # TODO: This task group isn't necessary in the new engine. Remove the background tasks
-            # attribute from FlowRunContext.
             client = client or get_client(sync_client=True)
             if flow_run_context := serialized_context.get("flow_run_context"):
-                try:
-                    task_group = anyio.create_task_group()
-                except AsyncLibraryNotFoundError:
-                    task_group = anyio._backends._asyncio.TaskGroup()
                 flow = flow_run_context["flow"]
                 flow_run_context = FlowRunContext(
                     **flow_run_context,
                     client=client,
-                    background_tasks=task_group,
                     result_factory=run_coro_as_sync(ResultFactory.from_flow(flow)),
                     task_runner=flow.task_runner.duplicate(),
                     detached=True,
@@ -367,13 +355,10 @@ class EngineContext(RunContext):
         task_run_states: A list of states for task runs created within this flow run
         task_run_results: A mapping of result ids to task run states for this flow run
         flow_run_states: A list of states for flow runs created within this flow run
-        sync_portal: A blocking portal for sync task/flow runs in an async flow
-        timeout_scope: The cancellation scope for flow level timeouts
     """
 
     flow: Optional["Flow"] = None
     flow_run: Optional[FlowRun] = None
-    autonomous_task_run: Optional[TaskRun] = None
     task_runner: TaskRunner
     log_prints: bool = False
     parameters: Optional[Dict[str, Any]] = None
@@ -391,19 +376,8 @@ class EngineContext(RunContext):
     # Counter for flow pauses
     observed_flow_pauses: Dict[str, int] = Field(default_factory=dict)
 
-    # Tracking for objects created by this flow run
-    task_run_futures: List[PrefectFuture] = Field(default_factory=list)
-    task_run_states: List[State] = Field(default_factory=list)
+    # Tracking for result from task runs in this flow run
     task_run_results: Dict[int, State] = Field(default_factory=dict)
-    flow_run_states: List[State] = Field(default_factory=list)
-
-    # The synchronous portal is only created for async flows for creating engine calls
-    # from synchronous task and subflow calls
-    sync_portal: Optional[anyio.abc.BlockingPortal] = None
-    timeout_scope: Optional[anyio.abc.CancelScope] = None
-
-    # Task group that can be used for background tasks during the flow run
-    background_tasks: anyio.abc.TaskGroup
 
     # Events worker to emit events to Prefect Cloud
     events: Optional[EventsWorker] = None

prefect/deployments/__init__.py

@@ -1,3 +1,4 @@
+from prefect._internal.compatibility.migration import getattr_migration
 import prefect.deployments.base
 import prefect.deployments.steps
 from prefect.deployments.base import (
@@ -15,3 +16,5 @@ from prefect.deployments.runner import (
 from prefect.deployments.flow_runs import (
     run_deployment,
 )
+
+__getattr__ = getattr_migration(__name__)

prefect/deployments/base.py

@@ -29,7 +29,7 @@ from prefect.utilities.templating import apply_values
 
 
 def create_default_prefect_yaml(
-    path: str, name: str = None, contents: Optional[Dict[str, Any]] = None
+    path: str, name: Optional[str] = None, contents: Optional[Dict[str, Any]] = None
 ) -> bool:
     """
     Creates default `prefect.yaml` file in the provided path if one does not already exist;
@@ -176,7 +176,9 @@ def _get_git_branch() -> Optional[str]:
 
 
 def initialize_project(
-    name: str = None, recipe: str = None, inputs: Optional[Dict[str, Any]] = None
+    name: Optional[str] = None,
+    recipe: Optional[str] = None,
+    inputs: Optional[Dict[str, Any]] = None,
 ) -> List[str]:
     """
     Initializes a basic project structure with base files.  If no name is provided, the name

prefect/deployments/deployments.py

@@ -0,0 +1,3 @@
+from .._internal.compatibility.migration import getattr_migration
+
+__getattr__ = getattr_migration(__name__)

prefect/deployments/steps/pull.py

@@ -1,6 +1,7 @@
 """
 Core set of steps for specifying a Prefect project pull step.
 """
+
 import os
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Optional

prefect/deployments/steps/utility.py

@@ -4,7 +4,7 @@ Utility project steps that are useful for managing a project's deployment lifecy
 Steps within this module can be used within a `build`, `push`, or `pull` deployment action.
 
 Example:
-    Use the `run_shell_script` setp to retrieve the short Git commit hash of the current 
+    Use the `run_shell_script` setp to retrieve the short Git commit hash of the current
         repository and use it as a Docker image tag:
     ```yaml
     build:
@@ -19,6 +19,7 @@ Example:
             dockerfile: auto
     ```
 """
+
 import io
 import os
 import shlex

prefect/engine.py

@@ -2,6 +2,7 @@ import os
 import sys
 from uuid import UUID
 
+from prefect._internal.compatibility.migration import getattr_migration
 from prefect.exceptions import (
     Abort,
     Pause,
@@ -70,3 +71,5 @@ if __name__ == "__main__":
         )
         # Let the exit code be determined by the base exception type
         raise
+
+__getattr__ = getattr_migration(__name__)

prefect/events/cli/automations.py

@@ -23,7 +23,7 @@ from prefect.exceptions import PrefectHTTPStatusError
 
 automations_app = PrefectTyper(
     name="automation",
-    help="Commands for managing automations.",
+    help="Manage automations.",
 )
 app.add_typer(automations_app, aliases=["automations"])