prefect-client 2.14.11__py3-none-any.whl → 2.14.13__py3-none-any.whl

prefect/client/orchestration.py

@@ -92,6 +92,7 @@ from prefect.client.schemas.objects import (
     Worker,
     WorkPool,
     WorkQueue,
+    WorkQueueStatusDetail,
 )
 from prefect.client.schemas.responses import (
     DeploymentResponse,
@@ -1036,6 +1037,32 @@ class PrefectClient:
                 raise
         return WorkQueue.parse_obj(response.json())
 
+    async def read_work_queue_status(
+        self,
+        id: UUID,
+    ) -> WorkQueueStatusDetail:
+        """
+        Read a work queue status.
+
+        Args:
+            id: the id of the work queue to load
+
+        Raises:
+            prefect.exceptions.ObjectNotFound: If request returns 404
+            httpx.RequestError: If request fails
+
+        Returns:
+            WorkQueueStatus: an instantiated WorkQueueStatus object
+        """
+        try:
+            response = await self._client.get(f"/work_queues/{id}/status")
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == status.HTTP_404_NOT_FOUND:
+                raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
+            else:
+                raise
+        return WorkQueueStatusDetail.parse_obj(response.json())
+
     async def match_work_queues(
         self,
         prefixes: List[str],

prefect/client/schemas/objects.py

@@ -30,7 +30,7 @@ from prefect._internal.schemas.validators import (
     raise_on_name_with_banned_characters,
 )
 from prefect.client.schemas.schedules import SCHEDULE_TYPES
-from prefect.settings import PREFECT_CLOUD_API_URL
+from prefect.settings import PREFECT_CLOUD_API_URL, PREFECT_CLOUD_UI_URL
 from prefect.utilities.collections import AutoEnum, listrepr
 from prefect.utilities.names import generate_slug
 
@@ -110,6 +110,7 @@ class StateDetails(PrefectBaseModel):
     pause_key: str = None
     run_input_keyset: Optional[Dict[str, str]] = None
     refresh_cache: bool = None
+    retriable: bool = None
 
 
 class State(ObjectBaseModel, Generic[R]):
@@ -777,6 +778,16 @@ class Workspace(PrefectBaseModel):
             f"/workspaces/{self.workspace_id}"
         )
 
+    def ui_url(self) -> str:
+        """
+        Generate the UI URL for accessing this workspace
+        """
+        return (
+            f"{PREFECT_CLOUD_UI_URL.value()}"
+            f"/account/{self.account_id}"
+            f"/workspace/{self.workspace_id}"
+        )
+
     def __hash__(self):
         return hash(self.handle)
 

prefect/engine.py

@@ -952,7 +952,7 @@ async def orchestrate_flow_run(
 async def pause_flow_run(
     wait_for_input: None = None,
     flow_run_id: UUID = None,
-    timeout: int = 300,
+    timeout: int = 3600,
     poll_interval: int = 10,
     reschedule: bool = False,
     key: str = None,
@@ -964,7 +964,7 @@ async def pause_flow_run(
 async def pause_flow_run(
     wait_for_input: Type[T],
     flow_run_id: UUID = None,
-    timeout: int = 300,
+    timeout: int = 3600,
     poll_interval: int = 10,
     reschedule: bool = False,
     key: str = None,
@@ -988,7 +988,7 @@ async def pause_flow_run(
 async def pause_flow_run(
     wait_for_input: Optional[Type[T]] = None,
     flow_run_id: UUID = None,
-    timeout: int = 300,
+    timeout: int = 3600,
     poll_interval: int = 10,
     reschedule: bool = False,
     key: str = None,
@@ -1011,7 +1011,7 @@ async def pause_flow_run(
             have an associated deployment and results need to be configured with the
             `persist_results` option.
         timeout: the number of seconds to wait for the flow to be resumed before
-            failing. Defaults to 5 minutes (300 seconds). If the pause timeout exceeds
+            failing. Defaults to 1 hour (3600 seconds). If the pause timeout exceeds
             any configured flow-level timeout, the flow might fail even after resuming.
         poll_interval: The number of seconds between checking whether the flow has been
             resumed. Defaults to 10 seconds.
@@ -1028,6 +1028,24 @@ async def pause_flow_run(
             resumed without providing the input, the flow will fail. If the flow is
             resumed with the input, the flow will resume and the input will be loaded
             and returned from this function.
+
+    Example:
+    ```python
+    @task
+    def task_one():
+        for i in range(3):
+            sleep(1)
+
+    @flow
+    def my_flow():
+        terminal_state = task_one.submit(return_state=True)
+        if terminal_state.type == StateType.COMPLETED:
+            print("Task one succeeded! Pausing flow run..")
+            pause_flow_run(timeout=2)
+        else:
+            print("Task one failed. Skipping pause flow run..")
+    ```
+
     """
     if flow_run_id:
         if wait_for_input is not None:
@@ -1050,11 +1068,8 @@ async def pause_flow_run(
 
 
 @inject_client
-@experimental_parameter(
-    "wait_for_input", group="flow_run_input", when=lambda y: y is not None
-)
 async def _in_process_pause(
-    timeout: int = 300,
+    timeout: int = 3600,
     poll_interval: int = 10,
     reschedule=False,
     key: str = None,
@@ -1149,7 +1164,7 @@ async def _in_process_pause(
 @inject_client
 async def _out_of_process_pause(
     flow_run_id: UUID,
-    timeout: int = 300,
+    timeout: int = 3600,
     reschedule: bool = True,
     key: str = None,
     client=None,
@@ -1172,7 +1187,7 @@ async def _out_of_process_pause(
 async def suspend_flow_run(
     wait_for_input: None = None,
     flow_run_id: Optional[UUID] = None,
-    timeout: Optional[int] = 300,
+    timeout: Optional[int] = 3600,
     key: Optional[str] = None,
     client: PrefectClient = None,
 ) -> None:
@@ -1183,7 +1198,7 @@ async def suspend_flow_run(
 async def suspend_flow_run(
     wait_for_input: Type[T],
     flow_run_id: Optional[UUID] = None,
-    timeout: Optional[int] = 300,
+    timeout: Optional[int] = 3600,
     key: Optional[str] = None,
     client: PrefectClient = None,
 ) -> T:
@@ -1192,10 +1207,13 @@ async def suspend_flow_run(
 
 @sync_compatible
 @inject_client
+@experimental_parameter(
+    "wait_for_input", group="flow_run_input", when=lambda y: y is not None
+)
 async def suspend_flow_run(
     wait_for_input: Optional[Type[T]] = None,
     flow_run_id: Optional[UUID] = None,
-    timeout: Optional[int] = 300,
+    timeout: Optional[int] = 3600,
     key: Optional[str] = None,
     client: PrefectClient = None,
 ):
@@ -1214,7 +1232,7 @@ async def suspend_flow_run(
             suspend the specified flow run. If not supplied will attempt to
             suspend the current flow run.
         timeout: the number of seconds to wait for the flow to be resumed before
-            failing. Defaults to 5 minutes (300 seconds). If the pause timeout
+            failing. Defaults to 1 hour (3600 seconds). If the pause timeout
             exceeds any configured flow-level timeout, the flow might fail even
             after resuming.
         key: An optional key to prevent calling suspend more than once. This
@@ -2075,7 +2093,13 @@ async def orchestrate_task_run(
                     )
                     terminal_state.state_details.cache_key = cache_key
 
+            if terminal_state.is_failed():
+                # Defer to user to decide whether failure is retriable
+                terminal_state.state_details.retriable = (
+                    await _check_task_failure_retriable(task, task_run, terminal_state)
+                )
             state = await propose_state(client, terminal_state, task_run_id=task_run.id)
+
             last_event = _emit_task_run_state_change_event(
                 task_run=task_run,
                 initial_state=last_state,
@@ -2672,6 +2696,48 @@ async def _run_task_hooks(task: Task, task_run: TaskRun, state: State) -> None:
                 logger.info(f"Hook {hook_name!r} finished running successfully")
 
 
+async def _check_task_failure_retriable(
+    task: Task, task_run: TaskRun, state: State
+) -> bool:
+    """Run the `retry_condition_fn` callable for a task, making sure to catch and log any errors
+    that occur. If None, return True. If not callable, logs an error and returns False.
+    """
+    if task.retry_condition_fn is None:
+        return True
+
+    logger = task_run_logger(task_run)
+
+    try:
+        logger.debug(
+            f"Running `retry_condition_fn` check {task.retry_condition_fn!r} for task"
+            f" {task.name!r}"
+        )
+        if is_async_fn(task.retry_condition_fn):
+            return bool(
+                await task.retry_condition_fn(task=task, task_run=task_run, state=state)
+            )
+        else:
+            return bool(
+                await from_async.call_in_new_thread(
+                    create_call(
+                        task.retry_condition_fn,
+                        task=task,
+                        task_run=task_run,
+                        state=state,
+                    )
+                )
+            )
+    except Exception:
+        logger.error(
+            (
+                "An error was encountered while running `retry_condition_fn` check"
+                f" '{task.retry_condition_fn!r}' for task {task.name!r}"
+            ),
+            exc_info=True,
+        )
+        return False
+
+
 async def _run_flow_hooks(flow: Flow, flow_run: FlowRun, state: State) -> None:
     """Run the on_failure, on_completion, on_cancellation, and on_crashed hooks for a flow, making sure to
     catch and log any errors that occur.

prefect/events/actions.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, Union
 from uuid import UUID
 
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
@@ -34,4 +34,15 @@ class RunDeployment(Action):
     deployment_id: UUID = Field(..., description="The identifier of the deployment")
 
 
-ActionTypes = RunDeployment
+class SendNotification(Action):
+    """Send a notification with the given parameters"""
+
+    type: Literal["send-notification"] = "send-notification"
+    block_document_id: UUID = Field(
+        ..., description="The identifier of the notification block"
+    )
+    body: str = Field(..., description="Notification body")
+    subject: Optional[str] = Field(None, description="Notification subject")
+
+
+ActionTypes = Union[RunDeployment, SendNotification]

prefect/events/schemas.py

@@ -341,7 +341,7 @@ class DeploymentTrigger(ResourceTrigger):
     def owner_resource(self) -> Optional[str]:
         return f"prefect.deployment.{self._deployment_id}"
 
-    def actions(self) -> List[ActionTypes]:
+    def actions(self) -> List[RunDeployment]:
         assert self._deployment_id
         return [
             RunDeployment(

prefect/flows.py

@@ -33,6 +33,7 @@ from typing import (
 from uuid import UUID
 
 from prefect._vendor.fastapi.encoders import jsonable_encoder
+from typing_extensions import Self
 
 from prefect._internal.concurrency.api import create_call, from_async
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
@@ -117,6 +118,7 @@ from prefect.utilities.visualization import (
 T = TypeVar("T")  # Generic type var for capturing the inner return type of async funcs
 R = TypeVar("R")  # The return type of the user's function
 P = ParamSpec("P")  # The parameters of the flow
+F = TypeVar("F", bound="Flow")  # The type of the flow
 
 logger = get_logger("flows")
 
@@ -373,7 +375,7 @@ class Flow(Generic[P, R]):
             List[Callable[[FlowSchema, FlowRun, State], None]]
         ] = None,
         on_crashed: Optional[List[Callable[[FlowSchema, FlowRun, State], None]]] = None,
-    ):
+    ) -> Self:
         """
         Create a new flow from the current object, updating provided options.
 
@@ -428,7 +430,7 @@ class Flow(Generic[P, R]):
             >>> assert state.result() == 4
 
         """
-        return Flow(
+        new_flow = Flow(
             fn=self.fn,
             name=name or self.name,
             description=description or self.description,
@@ -467,6 +469,9 @@ class Flow(Generic[P, R]):
             on_cancellation=on_cancellation or self.on_cancellation,
             on_crashed=on_crashed or self.on_crashed,
         )
+        new_flow._storage = self._storage
+        new_flow._entrypoint = self._entrypoint
+        return new_flow
 
     def validate_parameters(self, parameters: Dict[str, Any]) -> Dict[str, Any]:
         """
@@ -618,6 +623,8 @@ class Flow(Generic[P, R]):
         """
         from prefect.deployments.runner import RunnerDeployment
 
+        if not name.endswith(".py"):
+            raise_on_name_with_banned_characters(name)
         if self._storage and self._entrypoint:
             return await RunnerDeployment.from_storage(
                 storage=self._storage,
@@ -775,10 +782,10 @@ class Flow(Generic[P, R]):
     @classmethod
     @sync_compatible
     async def from_source(
-        cls,
+        cls: Type[F],
         source: Union[str, RunnerStorage, ReadableDeploymentStorage],
         entrypoint: str,
-    ) -> "Flow":
+    ) -> F:
         """
         Loads a flow from a remote s ource.
 

prefect/infrastructure/provisioners/container_instance.py

@@ -669,8 +669,9 @@ class ContainerInstancePushProvisioner:
             registry: The registry to grant access to.
         """
         command = (
-            f"az role assignment create --assignee {identity['principalId']} --scope"
-            f" {registry['id']} --role AcrPull --subscription {subscription_id}"
+            "az role assignment create --assignee-object-id"
+            f" {identity['principalId']} --assignee-principal-type ServicePrincipal"
+            f" --scope {registry['id']} --role AcrPull --subscription {subscription_id}"
         )
         await self.azure_cli.run_command(
             command,
@@ -830,18 +831,10 @@ class ContainerInstancePushProvisioner:
                     "The prefix must be alphanumeric and between 3-50 characters.",
                     style="red",
                 )
-        while True:
-            self._identity_name = prompt(
-                "Please enter a name for the identity (used for ACR access)",
-                default=self._identity_name,
-            )
-            if self._validate_user_input(self._identity_name):
-                break
-            else:
-                self._console.print(
-                    "The identity name must be alphanumeric and at least 3 characters.",
-                    style="red",
-                )
+        self._identity_name = prompt(
+            "Please enter a name for the identity (used for ACR access)",
+            default=self._identity_name,
+        )
         self._credentials_block_name = prompt(
             "Please enter a name for the ACI credentials block",
             default=self._credentials_block_name,

prefect/input/run_input.py

@@ -56,9 +56,6 @@ class RunInput(pydantic.BaseModel):
     class Config:
         extra = "forbid"
 
-    title: str = "Run is asking for input"
-    description: Optional[str] = None
-
     @classmethod
     @sync_compatible
     async def save(cls, keyset: Keyset, flow_run_id: Optional[UUID] = None):

prefect/runner/runner.py

@@ -86,7 +86,7 @@ from prefect.settings import (
 )
 from prefect.states import Crashed, Pending, exception_to_failed_state
 from prefect.utilities.asyncutils import is_async_fn, sync_compatible
-from prefect.utilities.processutils import run_process
+from prefect.utilities.processutils import _register_signal, run_process
 from prefect.utilities.services import critical_service_loop
 
 __all__ = ["Runner", "serve"]
@@ -337,7 +337,7 @@ class Runner:
                 runner.start()
             ```
         """
-        signal.signal(signal.SIGTERM, self.handle_sigterm)
+        _register_signal(signal.SIGTERM, self.handle_sigterm)
 
         webserver = webserver if webserver is not None else self.webserver
 

prefect/runner/storage.py

@@ -1,3 +1,4 @@
+import shutil
 import subprocess
 from copy import deepcopy
 from pathlib import Path
@@ -218,35 +219,49 @@ class GitRepository:
             if self._include_submodules:
                 cmd += ["--recurse-submodules"]
             cmd += ["--depth", "1"]
-            await run_process(cmd, cwd=self.destination)
+            try:
+                await run_process(cmd, cwd=self.destination)
+                self._logger.debug("Successfully pulled latest changes")
+            except subprocess.CalledProcessError as exc:
+                self._logger.error(
+                    f"Failed to pull latest changes with exit code {exc}"
+                )
+                shutil.rmtree(self.destination)
+                await self._clone_repo()
+
         else:
-            self._logger.debug("Cloning repository %s", self._url)
-            # Clone the repository if it doesn't exist at the destination
+            await self._clone_repo()
 
-            repository_url = self._repository_url_with_credentials
+    async def _clone_repo(self):
+        """
+        Clones the repository into the local destination.
+        """
+        self._logger.debug("Cloning repository %s", self._url)
 
-            cmd = [
-                "git",
-                "clone",
-                repository_url,
-            ]
-            if self._branch:
-                cmd += ["--branch", self._branch]
-            if self._include_submodules:
-                cmd += ["--recurse-submodules"]
+        repository_url = self._repository_url_with_credentials
 
-            # Limit git history and set path to clone to
-            cmd += ["--depth", "1", str(self.destination)]
+        cmd = [
+            "git",
+            "clone",
+            repository_url,
+        ]
+        if self._branch:
+            cmd += ["--branch", self._branch]
+        if self._include_submodules:
+            cmd += ["--recurse-submodules"]
 
-            try:
-                await run_process(cmd)
-            except subprocess.CalledProcessError as exc:
-                # Hide the command used to avoid leaking the access token
-                exc_chain = None if self._credentials else exc
-                raise RuntimeError(
-                    f"Failed to clone repository {self._url!r} with exit code"
-                    f" {exc.returncode}."
-                ) from exc_chain
+        # Limit git history and set path to clone to
+        cmd += ["--depth", "1", str(self.destination)]
+
+        try:
+            await run_process(cmd)
+        except subprocess.CalledProcessError as exc:
+            # Hide the command used to avoid leaking the access token
+            exc_chain = None if self._credentials else exc
+            raise RuntimeError(
+                f"Failed to clone repository {self._url!r} with exit code"
+                f" {exc.returncode}."
+            ) from exc_chain
 
     def __eq__(self, __value) -> bool:
         if isinstance(__value, GitRepository):