prefect-client 2.18.1__tar.gz → 2.18.3__tar.gz

{prefect-client-2.18.1/src/prefect_client.egg-info → prefect-client-2.18.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prefect-client
-Version: 2.18.1
+Version: 2.18.3
 Summary: Workflow orchestration and management.
 Home-page: https://www.prefect.io
 Author: Prefect Technologies, Inc.

{prefect-client-2.18.1 → prefect-client-2.18.3}/setup.cfg

@@ -56,10 +56,8 @@ filterwarnings =
 [mypy]
 plugins = 
 	pydantic.mypy
-files = 
-	src/prefect/concurrency/,
-	src/prefect/events/,
-	src/prefect/input/
+ignore_missing_imports = True
+follow_imports = skip
 
 [mypy-ruamel]
 ignore_missing_imports = True

prefect-client-2.18.3/src/prefect/automations.py

@@ -0,0 +1,162 @@
+from typing import Optional
+from uuid import UUID
+
+from pydantic import Field
+from typing_extensions import Self
+
+from prefect.client.utilities import get_or_create_client
+from prefect.events.schemas.automations import (
+    AutomationCore,
+    CompositeTrigger,
+    CompoundTrigger,
+    EventTrigger,
+    MetricTrigger,
+    MetricTriggerOperator,
+    MetricTriggerQuery,
+    Posture,
+    PrefectMetric,
+    ResourceSpecification,
+    ResourceTrigger,
+    SequenceTrigger,
+    Trigger,
+)
+from prefect.exceptions import PrefectHTTPStatusError
+from prefect.utilities.asyncutils import sync_compatible
+
+__all__ = [
+    "AutomationCore",
+    "EventTrigger",
+    "ResourceTrigger",
+    "Posture",
+    "Trigger",
+    "ResourceSpecification",
+    "MetricTriggerOperator",
+    "MetricTrigger",
+    "PrefectMetric",
+    "CompositeTrigger",
+    "SequenceTrigger",
+    "CompoundTrigger",
+    "MetricTriggerQuery",
+]
+
+
+class Automation(AutomationCore):
+    id: Optional[UUID] = Field(default=None, description="The ID of this automation")
+
+    @sync_compatible
+    async def create(self: Self) -> Self:
+        """
+        Create a new automation.
+
+        auto_to_create = Automation(
+            name="woodchonk",
+            trigger=EventTrigger(
+                expect={"animal.walked"},
+                match={
+                    "genus": "Marmota",
+                    "species": "monax",
+                },
+                posture="Reactive",
+                threshold=3,
+                within=timedelta(seconds=10),
+            ),
+            actions=[CancelFlowRun()]
+        )
+        created_automation = auto_to_create.create()
+        """
+        client, _ = get_or_create_client()
+        automation = AutomationCore(**self.dict(exclude={"id"}))
+        self.id = await client.create_automation(automation=automation)
+        return self
+
+    @sync_compatible
+    async def update(self: Self):
+        """
+        Updates an existing automation.
+        auto = Automation.read(id=123)
+        auto.name = "new name"
+        auto.update()
+        """
+
+        client, _ = get_or_create_client()
+        automation = AutomationCore(**self.dict(exclude={"id", "owner_resource"}))
+        await client.update_automation(automation_id=self.id, automation=automation)
+
+    @classmethod
+    @sync_compatible
+    async def read(
+        cls: Self, id: Optional[UUID] = None, name: Optional[str] = None
+    ) -> Self:
+        """
+        Read an automation by ID or name.
+        automation = Automation.read(name="woodchonk")
+
+        or
+
+        automation = Automation.read(id=UUID("b3514963-02b1-47a5-93d1-6eeb131041cb"))
+        """
+        if id and name:
+            raise ValueError("Only one of id or name can be provided")
+        if not id and not name:
+            raise ValueError("One of id or name must be provided")
+        client, _ = get_or_create_client()
+        if id:
+            try:
+                automation = await client.read_automation(automation_id=id)
+            except PrefectHTTPStatusError as exc:
+                if exc.response.status_code == 404:
+                    raise ValueError(f"Automation with ID {id!r} not found")
+            return Automation(**automation.dict())
+        else:
+            automation = await client.read_automations_by_name(name=name)
+            if len(automation) > 0:
+                return Automation(**automation[0].dict()) if automation else None
+            else:
+                raise ValueError(f"Automation with name {name!r} not found")
+
+    @sync_compatible
+    async def delete(self: Self) -> bool:
+        """
+        auto = Automation.read(id = 123)
+        auto.delete()
+        """
+        try:
+            client, _ = get_or_create_client()
+            await client.delete_automation(self.id)
+            return True
+        except PrefectHTTPStatusError as exc:
+            if exc.response.status_code == 404:
+                return False
+            raise
+
+    @sync_compatible
+    async def disable(self: Self) -> bool:
+        """
+        Disable an automation.
+        auto = Automation.read(id = 123)
+        auto.disable()
+        """
+        try:
+            client, _ = get_or_create_client()
+            await client.pause_automation(self.id)
+            return True
+        except PrefectHTTPStatusError as exc:
+            if exc.response.status_code == 404:
+                return False
+            raise
+
+    @sync_compatible
+    async def enable(self: Self) -> bool:
+        """
+        Enable an automation.
+        auto = Automation.read(id = 123)
+        auto.enable()
+        """
+        try:
+            client, _ = get_or_create_client()
+            await client.resume_automation("asd")
+            return True
+        except PrefectHTTPStatusError as exc:
+            if exc.response.status_code == 404:
+                return False
+            raise

{prefect-client-2.18.1 → prefect-client-2.18.3}/src/prefect/client/orchestration.py

@@ -623,12 +623,12 @@ class PrefectClient:
     async def create_flow_run(
         self,
         flow: "FlowObject",
-        name: str = None,
+        name: Optional[str] = None,
         parameters: Optional[Dict[str, Any]] = None,
         context: Optional[Dict[str, Any]] = None,
-        tags: Iterable[str] = None,
-        parent_task_run_id: UUID = None,
-        state: "prefect.states.State" = None,
+        tags: Optional[Iterable[str]] = None,
+        parent_task_run_id: Optional[UUID] = None,
+        state: Optional["prefect.states.State"] = None,
     ) -> FlowRun:
         """
         Create a flow run for a flow.
@@ -3161,6 +3161,16 @@ class PrefectClient:
 
         return UUID(response.json()["id"])
 
+    async def update_automation(self, automation_id: UUID, automation: AutomationCore):
+        """Updates an automation in Prefect Cloud."""
+        if not self.server_type.supports_automations():
+            self._raise_for_unsupported_automations()
+        response = await self._client.put(
+            f"/automations/{automation_id}",
+            json=automation.dict(json_compatible=True, exclude_unset=True),
+        )
+        response.raise_for_status
+
     async def read_automations(self) -> List[Automation]:
         if not self.server_type.supports_automations():
             self._raise_for_unsupported_automations()
@@ -3169,16 +3179,24 @@ class PrefectClient:
         response.raise_for_status()
         return pydantic.parse_obj_as(List[Automation], response.json())
 
-    async def find_automation(self, id_or_name: str) -> Optional[Automation]:
-        try:
-            id = UUID(id_or_name)
-        except ValueError:
-            id = None
+    async def find_automation(
+        self, id_or_name: Union[str, UUID], exit_if_not_found: bool = True
+    ) -> Optional[Automation]:
+        if isinstance(id_or_name, str):
+            try:
+                id = UUID(id_or_name)
+            except ValueError:
+                id = None
+        elif isinstance(id_or_name, UUID):
+            id = id_or_name
 
         if id:
-            automation = await self.read_automation(id)
-            if automation:
+            try:
+                automation = await self.read_automation(id)
                 return automation
+            except prefect.exceptions.HTTPStatusError as e:
+                if e.response.status_code == status.HTTP_404_NOT_FOUND:
+                    raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
 
         automations = await self.read_automations()
 

{prefect-client-2.18.1 → prefect-client-2.18.3}/src/prefect/client/schemas/objects.py

@@ -53,6 +53,7 @@ if TYPE_CHECKING:
     from prefect.deprecated.data_documents import DataDocument
     from prefect.results import BaseResult
 
+
 R = TypeVar("R")
 
 
@@ -120,20 +121,20 @@ class WorkQueueStatus(AutoEnum):
 
 
 class StateDetails(PrefectBaseModel):
-    flow_run_id: UUID = None
-    task_run_id: UUID = None
+    flow_run_id: Optional[UUID] = None
+    task_run_id: Optional[UUID] = None
     # for task runs that represent subflows, the subflow's run ID
-    child_flow_run_id: UUID = None
+    child_flow_run_id: Optional[UUID] = None
     scheduled_time: DateTimeTZ = None
-    cache_key: str = None
+    cache_key: Optional[str] = None
     cache_expiration: DateTimeTZ = None
     untrackable_result: bool = False
     pause_timeout: DateTimeTZ = None
     pause_reschedule: bool = False
-    pause_key: str = None
+    pause_key: Optional[str] = None
     run_input_keyset: Optional[Dict[str, str]] = None
-    refresh_cache: bool = None
-    retriable: bool = None
+    refresh_cache: Optional[bool] = None
+    retriable: Optional[bool] = None
     transition_id: Optional[UUID] = None
     task_parameters_id: Optional[UUID] = None
 
@@ -160,7 +161,9 @@ class State(ObjectBaseModel, Generic[R]):
     def result(self: "State[R]", raise_on_failure: bool = False) -> Union[R, Exception]:
         ...
 
-    def result(self, raise_on_failure: bool = True, fetch: Optional[bool] = None):
+    def result(
+        self, raise_on_failure: bool = True, fetch: Optional[bool] = None
+    ) -> Union[R, Exception]:
         """
         Retrieve the result attached to this state.
 

{prefect-client-2.18.1 → prefect-client-2.18.3}/src/prefect/engine.py

@@ -163,6 +163,7 @@ from prefect.logging.loggers import (
 from prefect.results import ResultFactory, UnknownResult
 from prefect.settings import (
     PREFECT_DEBUG_MODE,
+    PREFECT_EXPERIMENTAL_ENABLE_NEW_ENGINE,
     PREFECT_TASK_INTROSPECTION_WARN_THRESHOLD,
     PREFECT_TASKS_REFRESH_CACHE,
     PREFECT_UI_URL,
@@ -189,6 +190,7 @@ from prefect.utilities.annotations import allow_failure, quote, unmapped
 from prefect.utilities.asyncutils import (
     gather,
     is_async_fn,
+    run_sync,
     sync_compatible,
 )
 from prefect.utilities.callables import (
@@ -2433,7 +2435,21 @@ if __name__ == "__main__":
         exit(1)
 
     try:
-        enter_flow_run_engine_from_subprocess(flow_run_id)
+        if PREFECT_EXPERIMENTAL_ENABLE_NEW_ENGINE.value():
+            from prefect.new_flow_engine import (
+                load_flow_and_flow_run,
+                run_flow,
+                run_flow_sync,
+            )
+
+            flow_run, flow = run_sync(load_flow_and_flow_run)
+            # run the flow
+            if flow.isasync:
+                run_sync(run_flow(flow, flow_run=flow_run))
+            else:
+                run_flow_sync(flow, flow_run=flow_run)
+        else:
+            enter_flow_run_engine_from_subprocess(flow_run_id)
     except Abort as exc:
         engine_logger.info(
             f"Engine execution of flow run '{flow_run_id}' aborted by orchestrator:"

prefect-client-2.18.3/src/prefect/events/cli/automations.py

@@ -0,0 +1,324 @@
+"""
+Command line interface for working with automations.
+"""
+
+import functools
+from typing import Optional
+from uuid import UUID
+
+import orjson
+import typer
+import yaml as pyyaml
+from rich.pretty import Pretty
+from rich.table import Table
+from rich.text import Text
+
+from prefect.cli._types import PrefectTyper
+from prefect.cli._utilities import exit_with_error, exit_with_success
+from prefect.cli.root import app
+from prefect.client.orchestration import get_client
+from prefect.events.schemas.automations import Automation
+from prefect.exceptions import PrefectHTTPStatusError
+
+automations_app = PrefectTyper(
+    name="automation",
+    help="Commands for managing automations.",
+)
+app.add_typer(automations_app, aliases=["automations"])
+
+
+def requires_automations(func):
+    @functools.wraps(func)
+    async def wrapper(*args, **kwargs):
+        try:
+            return await func(*args, **kwargs)
+        except RuntimeError as exc:
+            if "Enable experimental" in str(exc):
+                exit_with_error(str(exc))
+            raise
+
+    return wrapper
+
+
+@automations_app.command()
+@requires_automations
+async def ls():
+    """List all automations."""
+    async with get_client() as client:
+        automations = await client.read_automations()
+
+    table = Table(title="Automations", show_lines=True)
+
+    table.add_column("Automation")
+    table.add_column("Enabled")
+    table.add_column("Trigger")
+    table.add_column("Actions")
+
+    for automation in automations:
+        identifier_column = Text()
+
+        identifier_column.append(automation.name, style="white bold")
+        identifier_column.append("\n")
+
+        identifier_column.append(str(automation.id), style="cyan")
+        identifier_column.append("\n")
+
+        if automation.description:
+            identifier_column.append(automation.description, style="white")
+            identifier_column.append("\n")
+
+        if automation.actions_on_trigger or automation.actions_on_resolve:
+            actions = (
+                [
+                    f"(trigger) {action.describe_for_cli()}"
+                    for action in automation.actions
+                ]
+                + [
+                    f"(trigger) {action.describe_for_cli()}"
+                    for action in automation.actions_on_trigger
+                ]
+                + [
+                    f"(resolve) {action.describe_for_cli()}"
+                    for action in automation.actions
+                ]
+                + [
+                    f"(resolve) {action.describe_for_cli()}"
+                    for action in automation.actions_on_resolve
+                ]
+            )
+        else:
+            actions = [action.describe_for_cli() for action in automation.actions]
+
+        table.add_row(
+            identifier_column,
+            str(automation.enabled),
+            automation.trigger.describe_for_cli(),
+            "\n".join(actions),
+        )
+
+    app.console.print(table)
+
+
+@automations_app.command()
+@requires_automations
+async def inspect(
+    name: Optional[str] = typer.Argument(None, help="An automation's name"),
+    id: Optional[str] = typer.Option(None, "--id", help="An automation's id"),
+    yaml: bool = typer.Option(False, "--yaml", help="Output as YAML"),
+    json: bool = typer.Option(False, "--json", help="Output as JSON"),
+):
+    """
+    Inspect an automation.
+
+    Arguments:
+
+        name: the name of the automation to inspect
+
+        id: the id of the automation to inspect
+
+        yaml: output as YAML
+
+        json: output as JSON
+
+    Examples:
+
+        $ prefect automation inspect "my-automation"
+
+        $ prefect automation inspect --id "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+
+        $ prefect automation inspect "my-automation" --yaml
+
+        $ prefect automation inspect "my-automation" --json
+    """
+    if not id and not name:
+        exit_with_error("Please provide either a name or an id.")
+
+    if name:
+        async with get_client() as client:
+            automation = await client.read_automations_by_name(name=name)
+            if not automation:
+                exit_with_error(f"Automation {name!r} not found.")
+
+    elif id:
+        async with get_client() as client:
+            try:
+                uuid_id = UUID(id)
+                automation = await client.read_automation(uuid_id)
+            except (PrefectHTTPStatusError, ValueError):
+                exit_with_error(f"Automation with id {id!r} not found.")
+
+    if yaml or json:
+        if isinstance(automation, list):
+            automation = [a.dict(json_compatible=True) for a in automation]
+        elif isinstance(automation, Automation):
+            automation = automation.dict(json_compatible=True)
+        if yaml:
+            app.console.print(pyyaml.dump(automation, sort_keys=False))
+        elif json:
+            app.console.print(
+                orjson.dumps(automation, option=orjson.OPT_INDENT_2).decode()
+            )
+    else:
+        app.console.print(Pretty(automation))
+
+
+@automations_app.command(aliases=["enable"])
+@requires_automations
+async def resume(
+    name: Optional[str] = typer.Argument(None, help="An automation's name"),
+    id: Optional[str] = typer.Option(None, "--id", help="An automation's id"),
+):
+    """
+    Resume an automation.
+
+    Arguments:
+
+            name: the name of the automation to resume
+
+            id: the id of the automation to resume
+
+    Examples:
+
+            $ prefect automation resume "my-automation"
+
+            $ prefect automation resume --id "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+    """
+    if not id and not name:
+        exit_with_error("Please provide either a name or an id.")
+
+    if name:
+        async with get_client() as client:
+            automation = await client.read_automations_by_name(name=name)
+            if not automation:
+                exit_with_error(
+                    f"Automation with name {name!r} not found. You can also specify an id with the `--id` flag."
+                )
+            if len(automation) > 1:
+                if not typer.confirm(
+                    f"Multiple automations found with name {name!r}. Do you want to resume all of them?",
+                    default=False,
+                ):
+                    exit_with_error("Resume aborted.")
+
+            for a in automation:
+                await client.resume_automation(a.id)
+            exit_with_success(
+                f"Resumed automation(s) with name {name!r} and id(s) {', '.join([repr(str(a.id)) for a in automation])}."
+            )
+
+    elif id:
+        async with get_client() as client:
+            try:
+                uuid_id = UUID(id)
+                automation = await client.read_automation(uuid_id)
+            except (PrefectHTTPStatusError, ValueError):
+                exit_with_error(f"Automation with id {id!r} not found.")
+            await client.resume_automation(automation.id)
+            exit_with_success(f"Resumed automation with id {str(automation.id)!r}.")
+
+
+@automations_app.command(aliases=["disable"])
+@requires_automations
+async def pause(
+    name: Optional[str] = typer.Argument(None, help="An automation's name"),
+    id: Optional[str] = typer.Option(None, "--id", help="An automation's id"),
+):
+    """
+    Pause an automation.
+
+    Arguments:
+
+            name: the name of the automation to pause
+
+            id: the id of the automation to pause
+
+    Examples:
+
+        $ prefect automation pause "my-automation"
+
+        $ prefect automation pause --id "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+    """
+    if not id and not name:
+        exit_with_error("Please provide either a name or an id.")
+
+    if name:
+        async with get_client() as client:
+            automation = await client.read_automations_by_name(name=name)
+            if not automation:
+                exit_with_error(
+                    f"Automation with name {name!r} not found. You can also specify an id with the `--id` flag."
+                )
+            if len(automation) > 1:
+                if not typer.confirm(
+                    f"Multiple automations found with name {name!r}. Do you want to pause all of them?",
+                    default=False,
+                ):
+                    exit_with_error("Pause aborted.")
+
+            for a in automation:
+                await client.pause_automation(a.id)
+            exit_with_success(
+                f"Paused automation(s) with name {name!r} and id(s) {', '.join([repr(str(a.id)) for a in automation])}."
+            )
+
+    elif id:
+        async with get_client() as client:
+            try:
+                uuid_id = UUID(id)
+                automation = await client.read_automation(uuid_id)
+            except (PrefectHTTPStatusError, ValueError):
+                exit_with_error(f"Automation with id {id!r} not found.")
+            await client.pause_automation(automation.id)
+            exit_with_success(f"Paused automation with id {str(automation.id)!r}.")
+
+
+@automations_app.command()
+@requires_automations
+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.
+
+    Arguments:
+        name: the name of the automation to delete
+        id: the id of the automation to delete
+
+    Examples:
+        $ prefect automation delete "my-automation"
+        $ prefect automation delete --id "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+    """
+
+    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-client-2.18.1 → prefect-client-2.18.3}/src/prefect/events/clients.py

@@ -11,6 +11,7 @@ from typing import (
     Optional,
     Tuple,
     Type,
+    cast,
 )
 from uuid import UUID
 
@@ -377,7 +378,7 @@ SEEN_EVENTS_TTL = 120
 
 class PrefectEventSubscriber:
     """
-    Subscribes to a Prefect Cloud event stream, yielding events as they occur.
+    Subscribes to a Prefect event stream, yielding events as they occur.
 
     Example:
 
@@ -412,7 +413,7 @@ class PrefectEventSubscriber:
                 the client should attempt to reconnect
         """
         if not api_url:
-            api_url = PREFECT_API_URL.value()
+            api_url = cast(str, PREFECT_API_URL.value())
             self._api_key = None
 
         from prefect.events.filters import EventFilter

{prefect-client-2.18.1 → prefect-client-2.18.3}/src/prefect/events/filters.py

@@ -43,7 +43,7 @@ class AutomationFilter(PrefectBaseModel):
     )
 
 
-class EventDataFilter(PrefectBaseModel, extra="forbid"):
+class EventDataFilter(PrefectBaseModel, extra="forbid"):  # type: ignore[call-arg]
     """A base class for filtering event data."""
 
     _top_level_filter: "EventFilter | None" = PrivateAttr(None)