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

prefect/_internal/schemas/fields.py

@@ -3,6 +3,7 @@ from typing import Optional
 from uuid import UUID
 
 import pendulum
+from typing_extensions import TypeAlias
 
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
 
@@ -12,19 +13,37 @@ else:
     from pydantic import BaseModel, Field
 
 
-class DateTimeTZ(pendulum.DateTime):
-    @classmethod
-    def __get_validators__(cls):
-        yield cls.validate
+# Rather than subclassing pendulum.DateTime to add our pydantic-specific validation,
+# which will lead to a lot of funky typing issues, we'll just monkeypatch the pydantic
+# validators onto the class.  Retaining this type alias means that we can still use it
+# as we have been in class definitions, also guaranteeing that we'll be applying these
+# validators by importing this module.
 
-    @classmethod
-    def validate(cls, v):
-        if isinstance(v, str):
-            return pendulum.parse(v)
-        elif isinstance(v, datetime.datetime):
-            return pendulum.instance(v)
-        else:
-            raise ValueError("Unrecognized datetime.")
+DateTimeTZ: TypeAlias = pendulum.DateTime
+
+
+def _datetime_patched_classmethod(function):
+    if hasattr(DateTimeTZ, function.__name__):
+        return function
+    setattr(DateTimeTZ, function.__name__, classmethod(function))
+    return function
+
+
+@_datetime_patched_classmethod
+def __get_validators__(cls):
+    yield getattr(cls, "validate")
+
+
+@_datetime_patched_classmethod
+def validate(cls, v) -> pendulum.DateTime:
+    if isinstance(v, str):
+        parsed = pendulum.parse(v)
+        assert isinstance(parsed, pendulum.DateTime)
+        return parsed
+    elif isinstance(v, datetime.datetime):
+        return pendulum.instance(v)
+    else:
+        raise ValueError("Unrecognized datetime.")
 
 
 class CreatedBy(BaseModel):

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/blocks/core.py

@@ -996,7 +996,7 @@ class Block(BaseModel, ABC):
         return self._block_document_id
 
     @sync_compatible
-    @instrument_instance_method_call()
+    @instrument_instance_method_call
     async def save(
         self,
         name: Optional[str] = None,

prefect/blocks/notifications.py

@@ -62,7 +62,7 @@ class AbstractAppriseNotificationBlock(NotificationBlock, ABC):
         self._start_apprise_client(self.url)
 
     @sync_compatible
-    @instrument_instance_method_call()
+    @instrument_instance_method_call
     async def notify(
         self,
         body: str,
@@ -717,7 +717,7 @@ class CustomWebhookNotificationBlock(NotificationBlock):
                     raise KeyError(f"{name}/{placeholder}")
 
     @sync_compatible
-    @instrument_instance_method_call()
+    @instrument_instance_method_call
     async def notify(self, body: str, subject: Optional[str] = None):
         import httpx
 

prefect/blocks/system.py

@@ -1,7 +1,5 @@
 from typing import Any
 
-import pendulum
-
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
 
 if HAS_PYDANTIC_V2:
@@ -9,6 +7,7 @@ if HAS_PYDANTIC_V2:
 else:
     from pydantic import Field, SecretStr
 
+from prefect._internal.schemas.fields import DateTimeTZ
 from prefect.blocks.core import Block
 
 
@@ -76,7 +75,7 @@ class DateTime(Block):
     _logo_url = "https://cdn.sanity.io/images/3ugk85nk/production/8b3da9a6621e92108b8e6a75b82e15374e170ff7-48x48.png"
     _documentation_url = "https://docs.prefect.io/api-ref/prefect/blocks/system/#prefect.blocks.system.DateTime"
 
-    value: pendulum.DateTime = Field(
+    value: DateTimeTZ = Field(
         default=...,
         description="An ISO 8601-compatible datetime value.",
     )