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

prefect/deployments/deployments.py

@@ -16,6 +16,13 @@ import anyio
 import pendulum
 import yaml
 
+from prefect._internal.pydantic import HAS_PYDANTIC_V2
+
+if HAS_PYDANTIC_V2:
+    from pydantic.v1 import BaseModel, Field, parse_obj_as, root_validator, validator
+else:
+    from pydantic import BaseModel, Field, parse_obj_as, root_validator, validator
+
 from prefect._internal.compatibility.deprecated import (
     DeprecatedInfraOverridesField,
     deprecated_callable,
@@ -23,7 +30,6 @@ from prefect._internal.compatibility.deprecated import (
     deprecated_parameter,
     handle_deprecated_infra_overrides_parameter,
 )
-from prefect._internal.pydantic import HAS_PYDANTIC_V2
 from prefect._internal.schemas.validators import (
     handle_openapi_schema,
     infrastructure_must_have_capabilities,
@@ -32,16 +38,10 @@ from prefect._internal.schemas.validators import (
     validate_automation_names,
     validate_deprecated_schedule_fields,
 )
-from prefect.client.schemas.actions import DeploymentScheduleCreate
-
-if HAS_PYDANTIC_V2:
-    from pydantic.v1 import BaseModel, Field, parse_obj_as, root_validator, validator
-else:
-    from pydantic import BaseModel, Field, parse_obj_as, root_validator, validator
-
 from prefect.blocks.core import Block
 from prefect.blocks.fields import SecretDict
 from prefect.client.orchestration import PrefectClient, get_client
+from prefect.client.schemas.actions import DeploymentScheduleCreate
 from prefect.client.schemas.objects import (
     FlowRun,
     MinimalDeploymentSchedule,
@@ -53,11 +53,12 @@ from prefect.deployments.schedules import (
     FlexibleScheduleList,
 )
 from prefect.deployments.steps.core import run_steps
-from prefect.events import DeploymentTriggerTypes
+from prefect.events import DeploymentTriggerTypes, TriggerTypes
 from prefect.exceptions import (
     BlockMissingCapabilities,
     ObjectAlreadyExists,
     ObjectNotFound,
+    PrefectHTTPStatusError,
 )
 from prefect.filesystems import LocalFileSystem
 from prefect.flows import Flow, load_flow_from_entrypoint
@@ -609,7 +610,7 @@ class Deployment(DeprecatedInfraOverridesField, BaseModel):
         description="The parameter schema of the flow, including defaults.",
     )
     timestamp: datetime = Field(default_factory=partial(pendulum.now, "UTC"))
-    triggers: List[DeploymentTriggerTypes] = Field(
+    triggers: List[Union[DeploymentTriggerTypes, TriggerTypes]] = Field(
         default_factory=list,
         description="The triggers that should cause this deployment to run.",
     )
@@ -902,14 +903,22 @@ class Deployment(DeprecatedInfraOverridesField, BaseModel):
             )
 
             if client.server_type.supports_automations():
-                # The triggers defined in the deployment spec are, essentially,
-                # anonymous and attempting truly sync them with cloud is not
-                # feasible. Instead, we remove all automations that are owned
-                # by the deployment, meaning that they were created via this
-                # mechanism below, and then recreate them.
-                await client.delete_resource_owned_automations(
-                    f"prefect.deployment.{deployment_id}"
-                )
+                try:
+                    # The triggers defined in the deployment spec are, essentially,
+                    # anonymous and attempting truly sync them with cloud is not
+                    # feasible. Instead, we remove all automations that are owned
+                    # by the deployment, meaning that they were created via this
+                    # mechanism below, and then recreate them.
+                    await client.delete_resource_owned_automations(
+                        f"prefect.deployment.{deployment_id}"
+                    )
+                except PrefectHTTPStatusError as e:
+                    if e.response.status_code == 404:
+                        # This Prefect server does not support automations, so we can safely
+                        # ignore this 404 and move on.
+                        return deployment_id
+                    raise e
+
                 for trigger in self.triggers:
                     trigger.set_deployment_id(deployment_id)
                     await client.create_automation(trigger.as_automation())

prefect/deployments/runner.py

@@ -42,26 +42,19 @@ from rich.console import Console
 from rich.progress import Progress, SpinnerColumn, TextColumn, track
 from rich.table import Table
 
-from prefect._internal.concurrency.api import create_call, from_async
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
-from prefect._internal.schemas.validators import (
-    reconcile_paused_deployment,
-    reconcile_schedules_runner,
-    validate_automation_names,
-)
-from prefect.runner.storage import RunnerStorage
-from prefect.settings import (
-    PREFECT_DEFAULT_DOCKER_BUILD_NAMESPACE,
-    PREFECT_DEFAULT_WORK_POOL_NAME,
-    PREFECT_UI_URL,
-)
-from prefect.utilities.collections import get_from_dict, isiterable
 
 if HAS_PYDANTIC_V2:
     from pydantic.v1 import BaseModel, Field, PrivateAttr, root_validator, validator
 else:
     from pydantic import BaseModel, Field, PrivateAttr, root_validator, validator
 
+from prefect._internal.concurrency.api import create_call, from_async
+from prefect._internal.schemas.validators import (
+    reconcile_paused_deployment,
+    reconcile_schedules_runner,
+    validate_automation_names,
+)
 from prefect.client.orchestration import get_client
 from prefect.client.schemas.objects import MinimalDeploymentSchedule
 from prefect.client.schemas.schedules import (
@@ -72,13 +65,20 @@ from prefect.deployments.schedules import (
     FlexibleScheduleList,
     create_minimal_deployment_schedule,
 )
-from prefect.events import DeploymentTriggerTypes
+from prefect.events import DeploymentTriggerTypes, TriggerTypes
 from prefect.exceptions import (
     ObjectNotFound,
     PrefectHTTPStatusError,
 )
+from prefect.runner.storage import RunnerStorage
+from prefect.settings import (
+    PREFECT_DEFAULT_DOCKER_BUILD_NAMESPACE,
+    PREFECT_DEFAULT_WORK_POOL_NAME,
+    PREFECT_UI_URL,
+)
 from prefect.utilities.asyncutils import sync_compatible
 from prefect.utilities.callables import ParameterSchema, parameter_schema
+from prefect.utilities.collections import get_from_dict, isiterable
 from prefect.utilities.dockerutils import (
     PushError,
     build_image,
@@ -179,7 +179,7 @@ class RunnerDeployment(BaseModel):
             "The path to the entrypoint for the workflow, relative to the `path`."
         ),
     )
-    triggers: List[DeploymentTriggerTypes] = Field(
+    triggers: List[Union[DeploymentTriggerTypes, TriggerTypes]] = Field(
         default_factory=list,
         description="The triggers that should cause this deployment to run.",
     )
@@ -326,14 +326,22 @@ class RunnerDeployment(BaseModel):
                 ) from exc
 
             if client.server_type.supports_automations():
-                # The triggers defined in the deployment spec are, essentially,
-                # anonymous and attempting truly sync them with cloud is not
-                # feasible. Instead, we remove all automations that are owned
-                # by the deployment, meaning that they were created via this
-                # mechanism below, and then recreate them.
-                await client.delete_resource_owned_automations(
-                    f"prefect.deployment.{deployment_id}"
-                )
+                try:
+                    # The triggers defined in the deployment spec are, essentially,
+                    # anonymous and attempting truly sync them with cloud is not
+                    # feasible. Instead, we remove all automations that are owned
+                    # by the deployment, meaning that they were created via this
+                    # mechanism below, and then recreate them.
+                    await client.delete_resource_owned_automations(
+                        f"prefect.deployment.{deployment_id}"
+                    )
+                except PrefectHTTPStatusError as e:
+                    if e.response.status_code == 404:
+                        # This Prefect server does not support automations, so we can safely
+                        # ignore this 404 and move on.
+                        return deployment_id
+                    raise e
+
                 for trigger in self.triggers:
                     trigger.set_deployment_id(deployment_id)
                     await client.create_automation(trigger.as_automation())
@@ -446,7 +454,7 @@ class RunnerDeployment(BaseModel):
         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,
@@ -582,7 +590,7 @@ class RunnerDeployment(BaseModel):
         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,
@@ -680,7 +688,7 @@ class RunnerDeployment(BaseModel):
         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,

prefect/engine.py

@@ -1410,7 +1410,9 @@ def enter_task_run_engine(
         task_runner=task_runner,
     )
 
-    if task.isasync and flow_run_context.flow.isasync:
+    if task.isasync and (
+        flow_run_context.flow is None or flow_run_context.flow.isasync
+    ):
         # return a coro for the user to await if an async task in an async flow
         return from_async.wait_for_call_in_loop_thread(begin_run)
     else:

prefect/events/actions.py

@@ -9,7 +9,8 @@ from prefect._internal.pydantic import HAS_PYDANTIC_V2
 if HAS_PYDANTIC_V2:
     from pydantic.v1 import Field, root_validator
 else:
-    from pydantic import Field, root_validator
+    from pydantic import Field, root_validator  # type: ignore
+
 from prefect._internal.schemas.bases import PrefectBaseModel
 from prefect.client.schemas.objects import StateType
 

prefect/events/cli/automations.py

@@ -3,8 +3,10 @@ Command line interface for working with automations.
 """
 
 import functools
+from typing import Optional
 
 import orjson
+import typer
 import yaml as pyyaml
 from rich.pretty import Pretty
 from rich.table import Table
@@ -149,15 +151,51 @@ async def pause(id_or_name: str):
 
 @automations_app.command()
 @requires_automations
-async def delete(id_or_name: str):
-    """Delete an automation."""
-    async with get_client() as client:
-        automation = await client.find_automation(id_or_name)
+async def delete(
+    name: Optional[str] = typer.Argument(None, help="An automation's name"),
+    id: Optional[str] = typer.Option(None, "--id", help="An automation's id"),
+):
+    """Delete an automation.
 
-    if not automation:
-        exit_with_success(f"Automation {id_or_name!r} not found.")
+    Arguments:
+        name: the name of the automation to delete
+        id: the id of the automation to delete
 
-    async with get_client() as client:
-        await client.delete_automation(automation.id)
+    Examples:
+        $ prefect automation delete "my-automation"
+        $ prefect automation delete --id "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+    """
 
-    exit_with_success(f"Deleted automation {automation.name!r} ({automation.id})")
+    async with get_client() as client:
+        if not id and not name:
+            exit_with_error("Please provide either a name or an id.")
+
+        if id:
+            automation = await client.read_automation(id)
+            if not automation:
+                exit_with_error(f"Automation with id {id!r} not found.")
+            if not typer.confirm(
+                (f"Are you sure you want to delete automation with id {id!r}?"),
+                default=False,
+            ):
+                exit_with_error("Deletion aborted.")
+            await client.delete_automation(id)
+            exit_with_success(f"Deleted automation with id {id!r}")
+
+        elif name:
+            automation = await client.read_automations_by_name(name=name)
+            if not automation:
+                exit_with_error(
+                    f"Automation {name!r} not found. You can also specify an id with the `--id` flag."
+                )
+            elif len(automation) > 1:
+                exit_with_error(
+                    f"Multiple automations found with name {name!r}. Please specify an id with the `--id` flag instead."
+                )
+            if not typer.confirm(
+                (f"Are you sure you want to delete automation with name {name!r}?"),
+                default=False,
+            ):
+                exit_with_error("Deletion aborted.")
+            await client.delete_automation(automation[0].id)
+            exit_with_success(f"Deleted automation with name {name!r}")

prefect/events/clients.py

@@ -7,7 +7,7 @@ from typing import (
     ClassVar,
     Dict,
     List,
-    Mapping,
+    MutableMapping,
     Optional,
     Tuple,
     Type,
@@ -19,6 +19,7 @@ import orjson
 import pendulum
 from cachetools import TTLCache
 from typing_extensions import Self
+from websockets import Subprotocol
 from websockets.client import WebSocketClientProtocol, connect
 from websockets.exceptions import (
     ConnectionClosed,
@@ -69,7 +70,7 @@ def get_events_client(
 
 
 def get_events_subscriber(
-    filter: "EventFilter" = None,
+    filter: Optional["EventFilter"] = None,
     reconnection_attempts: int = 10,
 ) -> "PrefectEventSubscriber":
     api_url = PREFECT_API_URL.value()
@@ -105,7 +106,7 @@ class EventsClient(abc.ABC):
     async def _emit(self, event: Event) -> None:  # pragma: no cover
         ...
 
-    async def __aenter__(self) -> "EventsClient":
+    async def __aenter__(self) -> Self:
         self._in_context = True
         return self
 
@@ -153,7 +154,7 @@ class AssertingEventsClient(EventsClient):
     async def _emit(self, event: Event) -> None:
         self.events.append(event)
 
-    async def __aenter__(self) -> "AssertingEventsClient":
+    async def __aenter__(self) -> Self:
         await super().__aenter__()
         self.events = []
         return self
@@ -227,7 +228,7 @@ class PrefectEventsClient(EventsClient):
 
     def __init__(
         self,
-        api_url: str = None,
+        api_url: Optional[str] = None,
         reconnection_attempts: int = 10,
         checkpoint_every: int = 20,
     ):
@@ -343,8 +344,8 @@ class PrefectCloudEventsClient(PrefectEventsClient):
 
     def __init__(
         self,
-        api_url: str = None,
-        api_key: str = None,
+        api_url: Optional[str] = None,
+        api_key: Optional[str] = None,
         reconnection_attempts: int = 10,
         checkpoint_every: int = 20,
     ):
@@ -393,12 +394,14 @@ class PrefectEventSubscriber:
 
     _websocket: Optional[WebSocketClientProtocol]
     _filter: "EventFilter"
-    _seen_events: Mapping[UUID, bool]
+    _seen_events: MutableMapping[UUID, bool]
+
+    _api_key: Optional[str]
 
     def __init__(
         self,
-        api_url: str = None,
-        filter: "EventFilter" = None,
+        api_url: Optional[str] = None,
+        filter: Optional["EventFilter"] = None,
         reconnection_attempts: int = 10,
     ):
         """
@@ -414,7 +417,7 @@ class PrefectEventSubscriber:
 
         from prefect.events.filters import EventFilter
 
-        self._filter = filter or EventFilter()
+        self._filter = filter or EventFilter()  # type: ignore[call-arg]
         self._seen_events = TTLCache(maxsize=SEEN_EVENTS_SIZE, ttl=SEEN_EVENTS_TTL)
 
         socket_url = (
@@ -427,14 +430,14 @@ class PrefectEventSubscriber:
 
         self._connect = connect(
             socket_url,
-            subprotocols=["prefect"],
+            subprotocols=[Subprotocol("prefect")],
         )
         self._websocket = None
         self._reconnection_attempts = reconnection_attempts
         if self._reconnection_attempts < 0:
             raise ValueError("reconnection_attempts must be a non-negative integer")
 
-    async def __aenter__(self) -> "PrefectCloudEventSubscriber":
+    async def __aenter__(self) -> Self:
         # Don't handle any errors in the initial connection, because these are most
         # likely a permission or configuration issue that should propagate
         await self._reconnect()
@@ -498,7 +501,7 @@ class PrefectEventSubscriber:
         self._websocket = None
         await self._connect.__aexit__(exc_type, exc_val, exc_tb)
 
-    def __aiter__(self) -> "PrefectCloudEventSubscriber":
+    def __aiter__(self) -> Self:
         return self
 
     async def __anext__(self) -> Event:
@@ -516,7 +519,7 @@ class PrefectEventSubscriber:
 
                 while True:
                     message = orjson.loads(await self._websocket.recv())
-                    event = Event.parse_obj(message["event"])
+                    event: Event = Event.parse_obj(message["event"])
 
                     if event.id in self._seen_events:
                         continue
@@ -541,14 +544,15 @@ class PrefectEventSubscriber:
                     # a standard load balancer timeout, but after that, just take a
                     # beat to let things come back around.
                     await asyncio.sleep(1)
+        raise StopAsyncIteration
 
 
 class PrefectCloudEventSubscriber(PrefectEventSubscriber):
     def __init__(
         self,
-        api_url: str = None,
-        api_key: str = None,
-        filter: "EventFilter" = None,
+        api_url: Optional[str] = None,
+        api_key: Optional[str] = None,
+        filter: Optional["EventFilter"] = None,
         reconnection_attempts: int = 10,
     ):
         """
@@ -567,3 +571,31 @@ class PrefectCloudEventSubscriber(PrefectEventSubscriber):
         )
 
         self._api_key = api_key
+
+
+class PrefectCloudAccountEventSubscriber(PrefectCloudEventSubscriber):
+    def __init__(
+        self,
+        api_url: Optional[str] = None,
+        api_key: Optional[str] = None,
+        filter: Optional["EventFilter"] = None,
+        reconnection_attempts: int = 10,
+    ):
+        """
+        Args:
+            api_url: The base URL for a Prefect Cloud workspace
+            api_key: The API of an actor with the manage_events scope
+            reconnection_attempts: When the client is disconnected, how many times
+                the client should attempt to reconnect
+        """
+        api_url, api_key = _get_api_url_and_key(api_url, api_key)
+
+        account_api_url, _, _ = api_url.partition("/workspaces/")
+
+        super().__init__(
+            api_url=account_api_url,
+            filter=filter,
+            reconnection_attempts=reconnection_attempts,
+        )
+
+        self._api_key = api_key

prefect/events/filters.py

@@ -13,7 +13,34 @@ from .schemas.events import Event, Resource, ResourceSpecification
 if HAS_PYDANTIC_V2:
     from pydantic.v1 import Field, PrivateAttr
 else:
-    from pydantic import Field, PrivateAttr
+    from pydantic import Field, PrivateAttr  # type: ignore
+
+
+class AutomationFilterCreated(PrefectBaseModel):
+    """Filter by `Automation.created`."""
+
+    before_: Optional[DateTimeTZ] = Field(
+        default=None,
+        description="Only include automations created before this datetime",
+    )
+
+
+class AutomationFilterName(PrefectBaseModel):
+    """Filter by `Automation.created`."""
+
+    any_: Optional[List[str]] = Field(
+        default=None,
+        description="Only include automations with names that match any of these strings",
+    )
+
+
+class AutomationFilter(PrefectBaseModel):
+    name: Optional[AutomationFilterName] = Field(
+        default=None, description="Filter criteria for `Automation.name`"
+    )
+    created: Optional[AutomationFilterCreated] = Field(
+        default=None, description="Filter criteria for `Automation.created`"
+    )
 
 
 class EventDataFilter(PrefectBaseModel, extra="forbid"):
@@ -203,7 +230,7 @@ class EventOrder(AutoEnum):
 
 class EventFilter(EventDataFilter):
     occurred: EventOccurredFilter = Field(
-        default_factory=EventOccurredFilter,
+        default_factory=lambda: EventOccurredFilter(),
         description="Filter criteria for when the events occurred",
     )
     event: Optional[EventNameFilter] = Field(
@@ -220,7 +247,7 @@ class EventFilter(EventDataFilter):
         None, description="Filter criteria for the related resources of the event"
     )
     id: EventIDFilter = Field(
-        default_factory=EventIDFilter,
+        default_factory=lambda: EventIDFilter(id=[]),
         description="Filter criteria for the events' ID",
     )
 

prefect/events/instrument.py

@@ -10,7 +10,9 @@ from typing import (
     Set,
     Tuple,
     Type,
+    TypeVar,
     Union,
+    cast,
 )
 
 from prefect.events import emit_event
@@ -41,45 +43,45 @@ def emit_instance_method_called_event(
     )
 
 
-def instrument_instance_method_call():
-    def instrument(function):
-        if is_instrumented(function):
-            return function
+F = TypeVar("F", bound=Callable)
 
-        if inspect.iscoroutinefunction(function):
 
-            @functools.wraps(function)
-            async def inner(self, *args, **kwargs):
-                success = True
-                try:
-                    return await function(self, *args, **kwargs)
-                except Exception as exc:
-                    success = False
-                    raise exc
-                finally:
-                    emit_instance_method_called_event(
-                        instance=self, method_name=function.__name__, successful=success
-                    )
+def instrument_instance_method_call(function: F) -> F:
+    if is_instrumented(function):
+        return function
 
-        else:
+    if inspect.iscoroutinefunction(function):
 
-            @functools.wraps(function)
-            def inner(self, *args, **kwargs):
-                success = True
-                try:
-                    return function(self, *args, **kwargs)
-                except Exception as exc:
-                    success = False
-                    raise exc
-                finally:
-                    emit_instance_method_called_event(
-                        instance=self, method_name=function.__name__, successful=success
-                    )
+        @functools.wraps(function)
+        async def inner(self, *args, **kwargs):
+            success = True
+            try:
+                return await function(self, *args, **kwargs)
+            except Exception as exc:
+                success = False
+                raise exc
+            finally:
+                emit_instance_method_called_event(
+                    instance=self, method_name=function.__name__, successful=success
+                )
 
-        setattr(inner, "__events_instrumented__", True)
-        return inner
+    else:
 
-    return instrument
+        @functools.wraps(function)
+        def inner(self, *args, **kwargs):
+            success = True
+            try:
+                return function(self, *args, **kwargs)
+            except Exception as exc:
+                success = False
+                raise exc
+            finally:
+                emit_instance_method_called_event(
+                    instance=self, method_name=function.__name__, successful=success
+                )
+
+    setattr(inner, "__events_instrumented__", True)
+    return cast(F, inner)
 
 
 def is_instrumented(function: Callable) -> bool:
@@ -119,17 +121,15 @@ def instrument_method_calls_on_class_instances(cls: Type) -> Type:
     """
 
     required_events_methods = ["_event_kind", "_event_method_called_resources"]
-    for method in required_events_methods:
-        if not hasattr(cls, method):
+    for method_name in required_events_methods:
+        if not hasattr(cls, method_name):
             raise RuntimeError(
-                f"Unable to instrument class {cls}. Class must define {method!r}."
+                f"Unable to instrument class {cls}. Class must define {method_name!r}."
             )
 
-    decorator = instrument_instance_method_call()
-
-    for name, method in instrumentable_methods(
+    for method_name, method in instrumentable_methods(
         cls,
         exclude_methods=getattr(cls, "_events_excluded_methods", []),
     ):
-        setattr(cls, name, decorator(method))
+        setattr(cls, method_name, instrument_instance_method_call(method))
     return cls

prefect/events/related.py

@@ -57,6 +57,7 @@ async def related_resources_from_run_context(
     exclude: Optional[Set[str]] = None,
 ) -> List[RelatedResource]:
     from prefect.client.orchestration import get_client
+    from prefect.client.schemas.objects import FlowRun
     from prefect.context import FlowRunContext, TaskRunContext
 
     if exclude is None:
@@ -111,7 +112,7 @@ async def related_resources_from_run_context(
 
         flow_run = related_objects[0]["object"]
 
-        if flow_run:
+        if isinstance(flow_run, FlowRun):
             related_objects += list(
                 await asyncio.gather(
                     _get_and_cache_related_object(