prefect-client 3.1.11__tar.gz → 3.1.12__tar.gz

{prefect-client-3.1.11/src/prefect_client.egg-info → prefect-client-3.1.12}/PKG-INFO

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

{prefect-client-3.1.11 → prefect-client-3.1.12}/requirements-client.txt

@@ -3,7 +3,7 @@ asgi-lifespan >= 1.0, < 3.0
 cachetools >= 5.3, < 6.0
 cloudpickle >= 2.0, < 4.0
 coolname >= 1.0.4, < 3.0.0
-croniter >= 1.0.12, < 6.0.0
+croniter >= 1.0.12, < 7.0.0
 exceptiongroup >= 1.0.0
 fastapi >= 0.111.0, < 1.0.0
 fsspec >= 2022.5.0

prefect-client-3.1.12/src/prefect/_experimental/sla/client.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from prefect.client.orchestration.base import BaseAsyncClient, BaseClient
+
+if TYPE_CHECKING:
+    from uuid import UUID
+
+    from prefect._experimental.sla.objects import SlaTypes
+
+
+class SlaClient(BaseClient):
+    def create_sla(self, sla: "SlaTypes") -> "UUID":
+        """
+        Creates a service level agreement.
+        Args:
+            sla: The SLA to create. Must have a deployment ID set.
+        Raises:
+            httpx.RequestError: if the SLA was not created for any reason
+        Returns:
+            the ID of the SLA in the backend
+        """
+        if not sla.owner_resource:
+            raise ValueError(
+                "Deployment ID is not set. Please set using `set_deployment_id`."
+            )
+
+        response = self.request(
+            "POST",
+            "/slas/",
+            json=sla.model_dump(mode="json", exclude_unset=True),
+        )
+        response.raise_for_status()
+
+        from uuid import UUID
+
+        return UUID(response.json().get("id"))
+
+
+class SlaAsyncClient(BaseAsyncClient):
+    async def create_sla(self, sla: "SlaTypes") -> "UUID":
+        """
+        Creates a service level agreement.
+        Args:
+            sla: The SLA to create. Must have a deployment ID set.
+        Raises:
+            httpx.RequestError: if the SLA was not created for any reason
+        Returns:
+            the ID of the SLA in the backend
+        """
+        if not sla.owner_resource:
+            raise ValueError(
+                "Deployment ID is not set. Please set using `set_deployment_id`."
+            )
+
+        response = await self.request(
+            "POST",
+            "/slas/",
+            json=sla.model_dump(mode="json", exclude_unset=True),
+        )
+        response.raise_for_status()
+
+        from uuid import UUID
+
+        return UUID(response.json().get("id"))

prefect-client-3.1.12/src/prefect/_experimental/sla/objects.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import abc
+from typing import Literal, Optional, Union
+from uuid import UUID
+
+from pydantic import Field, PrivateAttr, computed_field
+from typing_extensions import TypeAlias
+
+from prefect._internal.schemas.bases import PrefectBaseModel
+
+
+class ServiceLevelAgreement(PrefectBaseModel, abc.ABC):
+    """An ORM representation of a Service Level Agreement."""
+
+    _deployment_id: Optional[UUID] = PrivateAttr(default=None)
+
+    name: str = Field(
+        default=...,
+        description="The name of the SLA. Names must be unique on a per-deployment basis.",
+    )
+    severity: Literal["minor", "low", "moderate", "high", "critical"] = Field(
+        default="moderate",
+        description="The severity of the SLA.",
+    )
+    enabled: Optional[bool] = Field(
+        default=True,
+        description="Whether the SLA is enabled.",
+    )
+
+    def set_deployment_id(self, deployment_id: UUID):
+        self._deployment_id = deployment_id
+        return self
+
+    @computed_field
+    @property
+    def owner_resource(self) -> Union[str, None]:
+        if self._deployment_id:
+            return f"prefect.deployment.{self._deployment_id}"
+        return None
+
+
+class TimeToCompletionSla(ServiceLevelAgreement):
+    """An SLA that triggers when a flow run takes longer than the specified duration."""
+
+    duration: int = Field(
+        default=...,
+        description="The maximum flow run duration allowed before the SLA is violated, expressed in seconds.",
+    )
+
+
+# Concrete SLA types
+SlaTypes: TypeAlias = Union[TimeToCompletionSla]

{prefect-client-3.1.11 → prefect-client-3.1.12}/src/prefect/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-01-02T13:11:17-0600",
+ "date": "2025-01-09T10:09:15-0800",
  "dirty": true,
  "error": null,
- "full-revisionid": "e448bd3462d7c2580427624f426d81cf6e9a7ff1",
- "version": "3.1.11"
+ "full-revisionid": "e299e5a781867735d62685e7c190b5d100a28b62",
+ "version": "3.1.12"
 }
 '''  # END VERSION_JSON
 

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

@@ -0,0 +1,429 @@
+from typing import TYPE_CHECKING, Optional, overload
+from uuid import UUID
+
+from pydantic import Field
+from typing_extensions import Self
+
+from prefect._internal.compatibility.async_dispatch import async_dispatch
+from prefect.client.orchestration import get_client
+from prefect.events.actions import (
+    CallWebhook,
+    CancelFlowRun,
+    ChangeFlowRunState,
+    DeclareIncident,
+    DoNothing,
+    PauseAutomation,
+    PauseDeployment,
+    PauseWorkPool,
+    PauseWorkQueue,
+    ResumeAutomation,
+    ResumeDeployment,
+    ResumeWorkPool,
+    ResumeWorkQueue,
+    RunDeployment,
+    SendNotification,
+    SuspendFlowRun,
+)
+from prefect.events.schemas.automations import (
+    AutomationCore,
+    CompositeTrigger,
+    CompoundTrigger,
+    EventTrigger,
+    MetricTrigger,
+    MetricTriggerOperator,
+    MetricTriggerQuery,
+    Posture,
+    PrefectMetric,
+    ResourceSpecification,
+    ResourceTrigger,
+    SequenceTrigger,
+    Trigger,
+)
+from prefect.exceptions import PrefectHTTPStatusError
+
+__all__ = [
+    "AutomationCore",
+    "EventTrigger",
+    "ResourceTrigger",
+    "Posture",
+    "Trigger",
+    "ResourceSpecification",
+    "MetricTriggerOperator",
+    "MetricTrigger",
+    "PrefectMetric",
+    "CompositeTrigger",
+    "SequenceTrigger",
+    "CompoundTrigger",
+    "MetricTriggerQuery",
+    # action types
+    "DoNothing",
+    "RunDeployment",
+    "PauseDeployment",
+    "ResumeDeployment",
+    "CancelFlowRun",
+    "ChangeFlowRunState",
+    "PauseWorkQueue",
+    "ResumeWorkQueue",
+    "SendNotification",
+    "CallWebhook",
+    "PauseAutomation",
+    "ResumeAutomation",
+    "SuspendFlowRun",
+    "PauseWorkPool",
+    "ResumeWorkPool",
+    "DeclareIncident",
+]
+
+
+class Automation(AutomationCore):
+    id: Optional[UUID] = Field(default=None, description="The ID of this automation")
+
+    async def acreate(self: Self) -> Self:
+        """
+        Asynchronously create a new automation.
+
+        Examples:
+
+        ```python
+        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 = await auto_to_create.acreate()
+        ```
+        """
+        async with get_client() as client:
+            automation = AutomationCore(**self.model_dump(exclude={"id"}))
+            self.id = await client.create_automation(automation=automation)
+            return self
+
+    @async_dispatch(acreate)
+    def create(self: Self) -> Self:
+        """
+        Create a new automation.
+
+        Examples:
+
+        ```python
+        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()
+        ```
+        """
+        with get_client(sync_client=True) as client:
+            automation = AutomationCore(**self.model_dump(exclude={"id"}))
+            self.id = client.create_automation(automation=automation)
+            return self
+
+    async def aupdate(self: Self):
+        """
+        Updates an existing automation.
+
+        Examples:
+
+        ```python
+        auto = Automation.read(id=123)
+        auto.name = "new name"
+        auto.update()
+        ```
+        """
+        assert self.id is not None
+        async with get_client() as client:
+            automation = AutomationCore(
+                **self.model_dump(exclude={"id", "owner_resource"})
+            )
+            await client.update_automation(automation_id=self.id, automation=automation)
+
+    @async_dispatch(aupdate)
+    def update(self: Self):
+        """
+        Updates an existing automation.
+
+        Examples:
+
+
+        ```python
+        auto = Automation.read(id=123)
+        auto.name = "new name"
+        auto.update()
+        ```
+        """
+        assert self.id is not None
+        with get_client(sync_client=True) as client:
+            automation = AutomationCore(
+                **self.model_dump(exclude={"id", "owner_resource"})
+            )
+            client.update_automation(automation_id=self.id, automation=automation)
+
+    @overload
+    @classmethod
+    async def aread(cls, id: UUID, name: Optional[str] = ...) -> Self:
+        ...
+
+    @overload
+    @classmethod
+    async def aread(cls, id: None = None, name: str = ...) -> Self:
+        ...
+
+    @classmethod
+    async def aread(cls, id: Optional[UUID] = None, name: Optional[str] = None) -> Self:
+        """
+        Asynchronously read an automation by ID or name.
+
+        Examples:
+
+        ```python
+        automation = await Automation.aread(name="woodchonk")
+        ```
+
+        ```python
+        automation = await Automation.aread(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")
+        async with get_client() as 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")
+                    raise
+                if automation is None:
+                    raise ValueError(f"Automation with ID {id!r} not found")
+                return cls(**automation.model_dump())
+            else:
+                if TYPE_CHECKING:
+                    assert name is not None
+                automation = await client.read_automations_by_name(name=name)
+                if len(automation) > 0:
+                    return cls(**automation[0].model_dump())
+                raise ValueError(f"Automation with name {name!r} not found")
+
+    @overload
+    @classmethod
+    async def read(cls, id: UUID, name: Optional[str] = ...) -> Self:
+        ...
+
+    @overload
+    @classmethod
+    async def read(cls, id: None = None, name: str = ...) -> Self:
+        ...
+
+    @classmethod
+    @async_dispatch(aread)
+    def read(cls, id: Optional[UUID] = None, name: Optional[str] = None) -> Self:
+        """
+        Read an automation by ID or name.
+
+        Examples:
+
+        ```python
+        automation = Automation.read(name="woodchonk")
+        ```
+
+        ```python
+        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")
+        with get_client(sync_client=True) as client:
+            if id:
+                try:
+                    automation = 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")
+                    raise
+                if automation is None:
+                    raise ValueError(f"Automation with ID {id!r} not found")
+                return cls(**automation.model_dump())
+            else:
+                if TYPE_CHECKING:
+                    assert name is not None
+                automation = client.read_automations_by_name(name=name)
+                if len(automation) > 0:
+                    return cls(**automation[0].model_dump())
+                raise ValueError(f"Automation with name {name!r} not found")
+
+    async def adelete(self: Self) -> bool:
+        """
+        Asynchronously delete an automation.
+
+        Examples:
+
+        ```python
+        auto = Automation.read(id = 123)
+        await auto.adelete()
+        ```
+        """
+        if self.id is None:
+            raise ValueError("Can't delete an automation without an id")
+
+        async with get_client() as client:
+            try:
+                await client.delete_automation(self.id)
+                return True
+            except PrefectHTTPStatusError as exc:
+                if exc.response.status_code == 404:
+                    return False
+                raise
+
+    @async_dispatch(adelete)
+    def delete(self: Self) -> bool:
+        """
+        Delete an automation.
+
+        Examples:
+
+        ```python
+        auto = Automation.read(id = 123)
+        auto.delete()
+        ```
+        """
+        if self.id is None:
+            raise ValueError("Can't delete an automation without an id")
+
+        with get_client(sync_client=True) as client:
+            try:
+                client.delete_automation(self.id)
+                return True
+            except PrefectHTTPStatusError as exc:
+                if exc.response.status_code == 404:
+                    return False
+                raise
+
+    async def adisable(self: Self) -> bool:
+        """
+        Asynchronously disable an automation.
+
+        Raises:
+            ValueError: If the automation does not have an id
+            PrefectHTTPStatusError: If the automation cannot be disabled
+
+        Example:
+        ```python
+        auto = await Automation.aread(id = 123)
+        await auto.adisable()
+        ```
+        """
+        if self.id is None:
+            raise ValueError("Can't disable an automation without an id")
+
+        async with get_client() as client:
+            try:
+                await client.pause_automation(self.id)
+                return True
+            except PrefectHTTPStatusError as exc:
+                if exc.response.status_code == 404:
+                    return False
+                raise
+
+    @async_dispatch(adisable)
+    def disable(self: Self) -> bool:
+        """
+        Disable an automation.
+
+
+        Raises:
+            ValueError: If the automation does not have an id
+            PrefectHTTPStatusError: If the automation cannot be disabled
+
+        Example:
+        ```python
+        auto = Automation.read(id = 123)
+        auto.disable()
+        ```
+        """
+        if self.id is None:
+            raise ValueError("Can't disable an automation without an id")
+
+        with get_client(sync_client=True) as client:
+            try:
+                client.pause_automation(self.id)
+                return True
+            except PrefectHTTPStatusError as exc:
+                if exc.response.status_code == 404:
+                    return False
+                raise
+
+    async def aenable(self: Self) -> bool:
+        """
+        Asynchronously enable an automation.
+
+        Raises:
+            ValueError: If the automation does not have an id
+            PrefectHTTPStatusError: If the automation cannot be enabled
+
+        Example:
+        ```python
+        auto = await Automation.aread(id = 123)
+        await auto.aenable()
+        ```
+        """
+        if self.id is None:
+            raise ValueError("Can't enable an automation without an id")
+
+        async with get_client() as client:
+            try:
+                await client.resume_automation(self.id)
+                return True
+            except PrefectHTTPStatusError as exc:
+                if exc.response.status_code == 404:
+                    return False
+                raise
+
+    @async_dispatch(aenable)
+    def enable(self: Self) -> bool:
+        """
+        Enable an automation.
+
+        Raises:
+            ValueError: If the automation does not have an id
+            PrefectHTTPStatusError: If the automation cannot be enabled
+
+        Example:
+        ```python
+        auto = Automation.read(id = 123)
+        auto.enable()
+        ```
+        """
+        if self.id is None:
+            raise ValueError("Can't enable an automation without an id")
+
+        with get_client(sync_client=True) as client:
+            try:
+                client.resume_automation(self.id)
+                return True
+            except PrefectHTTPStatusError as exc:
+                if exc.response.status_code == 404:
+                    return False
+                raise

prefect-client-3.1.12/src/prefect/blocks/__init__.py

@@ -0,0 +1,7 @@
+# ensure core blocks are registered
+
+import prefect.blocks.notifications as notifications
+import prefect.blocks.system as system
+import prefect.blocks.webhook as webhook
+
+__all__ = ["notifications", "system", "webhook"]