prefect 3.2.14.dev3__tar.gz → 3.2.15.dev2__tar.gz

{prefect-3.2.14.dev3 → prefect-3.2.15.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prefect
-Version: 3.2.14.dev3
+Version: 3.2.15.dev2
 Summary: Workflow orchestration and management.
 Project-URL: Changelog, https://github.com/PrefectHQ/prefect/releases
 Project-URL: Documentation, https://docs.prefect.io

prefect-3.2.15.dev2/src/prefect/_build_info.py

@@ -0,0 +1,5 @@
+# Generated by versioningit
+__version__ = "3.2.15.dev2"
+__build_date__ = "2025-03-24 08:09:28.230748+00:00"
+__git_commit__ = "8954815ddc767d674de646a300215fd6b4cce715"
+__dirty__ = False

{prefect-3.2.14.dev3 → prefect-3.2.15.dev2}/src/prefect/_experimental/bundles.py

@@ -173,13 +173,16 @@ def execute_bundle_in_subprocess(
     return process
 
 
-def convert_step_to_command(step: dict[str, Any], key: str) -> list[str]:
+def convert_step_to_command(
+    step: dict[str, Any], key: str, quiet: bool = False
+) -> list[str]:
     """
     Converts a bundle upload or execution step to a command.
 
     Args:
         step: The step to convert.
         key: The key to use for the remote file when downloading or uploading.
+        quiet: Whether to suppress `uv` output from the command.
 
     Returns:
         A list of strings representing the command to run the step.
@@ -187,6 +190,9 @@ def convert_step_to_command(step: dict[str, Any], key: str) -> list[str]:
     # Start with uv run
     command = ["uv", "run"]
 
+    if quiet:
+        command.append("--quiet")
+
     step_keys = list(step.keys())
 
     if len(step_keys) != 1:

{prefect-3.2.14.dev3 → prefect-3.2.15.dev2}/src/prefect/_internal/concurrency/services.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import abc
 import asyncio
 import concurrent.futures
@@ -375,6 +377,14 @@ class BatchedQueueService(QueueService[T]):
     _max_batch_size: int
     _min_interval: Optional[float] = None
 
+    @property
+    def min_interval(self) -> float | None:
+        return self.__class__._min_interval
+
+    @property
+    def max_batch_size(self) -> int:
+        return self.__class__._max_batch_size
+
     async def _main_loop(self):
         done = False
 
@@ -383,8 +393,8 @@ class BatchedQueueService(QueueService[T]):
             batch_size = 0
 
             # Pull items from the queue until we reach the batch size
-            deadline = get_deadline(self._min_interval)
-            while batch_size < self._max_batch_size:
+            deadline = get_deadline(self.min_interval)
+            while batch_size < self.max_batch_size:
                 try:
                     item = await self._queue_get_thread.submit(
                         create_call(self._queue.get, timeout=get_timeout(deadline))
@@ -401,7 +411,7 @@ class BatchedQueueService(QueueService[T]):
                         self,
                         item,
                         batch_size,
-                        self._max_batch_size,
+                        self.max_batch_size,
                     )
                 except queue.Empty:
                     # Process the batch after `min_interval` even if it is smaller than

{prefect-3.2.14.dev3 → prefect-3.2.15.dev2}/src/prefect/cli/deployment.py

@@ -922,6 +922,7 @@ async def delete(
     deployment_id: Optional[UUID] = typer.Option(
         None, "--id", help="A deployment id to search for if no name is given"
     ),
+    _all: bool = typer.Option(False, "--all", help="Delete all deployments"),
 ):
     """
     Delete a deployment.
@@ -933,6 +934,24 @@ async def delete(
         $ prefect deployment delete --id dfd3e220-a130-4149-9af6-8d487e02fea6
     """
     async with get_client() as client:
+        if _all:
+            if name is not None or deployment_id is not None:
+                exit_with_error(
+                    "Cannot provide a deployment name or id when deleting all deployments."
+                )
+            deployments = await client.read_deployments()
+            if len(deployments) == 0:
+                exit_with_success("No deployments found.")
+            if is_interactive() and not typer.confirm(
+                f"Are you sure you want to delete all {len(deployments)} deployments?",
+                default=False,
+            ):
+                exit_with_error("Deletion aborted.")
+            for deployment in deployments:
+                await client.delete_deployment(deployment.id)
+            plural = "" if len(deployments) == 1 else "s"
+            exit_with_success(f"Deleted {len(deployments)} deployment{plural}.")
+
         if name is None and deployment_id is not None:
             try:
                 if is_interactive() and not typer.confirm(

{prefect-3.2.14.dev3 → prefect-3.2.15.dev2}/src/prefect/cli/work_pool.py

@@ -2,8 +2,11 @@
 Command line interface for working with work queues.
 """
 
+from __future__ import annotations
+
 import json
 import textwrap
+from typing import Annotated
 
 import typer
 from rich.pretty import Pretty
@@ -19,7 +22,11 @@ from prefect.cli.root import app, is_interactive
 from prefect.client.collections import get_collections_metadata_client
 from prefect.client.orchestration import get_client
 from prefect.client.schemas.actions import WorkPoolCreate, WorkPoolUpdate
-from prefect.client.schemas.objects import FlowRun, WorkPool
+from prefect.client.schemas.objects import (
+    FlowRun,
+    WorkPool,
+    WorkPoolStorageConfiguration,
+)
 from prefect.exceptions import ObjectAlreadyExists, ObjectNotFound
 from prefect.infrastructure.provisioners import (
     _provisioners,
@@ -681,3 +688,154 @@ async def preview(
             ),
             style="yellow",
         )
+
+
+# --------------------------------------------------------------------------
+# Work Pool Storage Configuration
+# --------------------------------------------------------------------------
+
+work_pool_storage_app: PrefectTyper = PrefectTyper(
+    name="storage", help="EXPERIMENTAL: Manage work pool storage."
+)
+work_pool_app.add_typer(work_pool_storage_app)
+
+
+def _determine_storage_type(storage_config: WorkPoolStorageConfiguration) -> str | None:
+    if storage_config.bundle_upload_step is None:
+        return None
+    if storage_config.bundle_upload_step and any(
+        "prefect_aws" in step for step in storage_config.bundle_upload_step.keys()
+    ):
+        return "S3"
+    return "Unknown"
+
+
+@work_pool_storage_app.command(name="inspect")
+async def storage_inspect(
+    work_pool_name: Annotated[
+        str,
+        typer.Argument(
+            ..., help="The name of the work pool to display storage configuration for."
+        ),
+    ],
+):
+    """
+    EXPERIMENTAL: Inspect the storage configuration for a work pool.
+
+    Examples:
+        $ prefect work-pool storage inspect "my-pool"
+    """
+    async with get_client() as client:
+        try:
+            work_pool = await client.read_work_pool(work_pool_name=work_pool_name)
+            from rich.panel import Panel
+            from rich.table import Table
+
+            storage_table = Table(show_header=True, header_style="bold")
+            storage_table.add_column("Setting", style="cyan")
+            storage_table.add_column("Value")
+
+            storage_type = _determine_storage_type(work_pool.storage_configuration)
+            if not storage_type:
+                app.console.print(
+                    f"No storage configuration found for work pool {work_pool_name!r}",
+                    style="yellow",
+                )
+                return
+
+            storage_table.add_row("type", storage_type)
+
+            # Add other storage settings, filtering out None values
+            if work_pool.storage_configuration.bundle_upload_step is not None:
+                fqn = list(work_pool.storage_configuration.bundle_upload_step.keys())[0]
+                config_values = work_pool.storage_configuration.bundle_upload_step[fqn]
+                for key, value in config_values.items():
+                    storage_table.add_row(key, str(value))
+
+            panel = Panel(
+                storage_table,
+                title=f"[bold]Storage Configuration for {work_pool_name}[/bold]",
+                expand=False,
+            )
+
+            app.console.print(panel)
+
+        except ObjectNotFound:
+            exit_with_error(f"Work pool {work_pool_name!r} does not exist.")
+
+
+work_pool_storage_configure_app: PrefectTyper = PrefectTyper(
+    name="configure", help="EXPERIMENTAL: Configure work pool storage."
+)
+work_pool_storage_app.add_typer(work_pool_storage_configure_app)
+
+
+@work_pool_storage_configure_app.command()
+async def s3(
+    work_pool_name: Annotated[
+        str,
+        typer.Argument(
+            ...,
+            help="The name of the work pool to configure storage for.",
+            show_default=False,
+        ),
+    ],
+    bucket: str = typer.Option(
+        ...,
+        "--bucket",
+        help="The name of the S3 bucket to use.",
+        show_default=False,
+        prompt="Enter the name of the S3 bucket to use",
+    ),
+    credentials_block_name: str = typer.Option(
+        ...,
+        "--aws-credentials-block-name",
+        help="The name of the credentials block to use.",
+        show_default=False,
+        prompt="Enter the name of the AWS credentials block to use",
+    ),
+):
+    """
+    EXPERIMENTAL: Configure AWS S3 storage for a work pool.
+
+    \b
+    Examples:
+        $ prefect work-pool storage configure s3 "my-pool" --bucket my-bucket --credentials-block-name my-credentials
+    """
+    # TODO: Allow passing in AWS keys and creating a block for the user.
+    async with get_client() as client:
+        try:
+            await client.read_block_document_by_name(
+                name=credentials_block_name, block_type_slug="aws-credentials"
+            )
+        except ObjectNotFound:
+            exit_with_error(
+                f"AWS credentials block {credentials_block_name!r} does not exist. Please create one using `prefect block create aws-credentials`."
+            )
+
+        try:
+            await client.update_work_pool(
+                work_pool_name=work_pool_name,
+                work_pool=WorkPoolUpdate(
+                    storage_configuration=WorkPoolStorageConfiguration(
+                        bundle_upload_step={
+                            "prefect_aws.experimental.bundles.upload": {
+                                "requires": "prefect-aws",
+                                "bucket": bucket,
+                                "aws_credentials_block_name": credentials_block_name,
+                            }
+                        },
+                        bundle_execution_step={
+                            "prefect_aws.experimental.bundles.execute": {
+                                "requires": "prefect-aws",
+                                "bucket": bucket,
+                                "aws_credentials_block_name": credentials_block_name,
+                            }
+                        },
+                    ),
+                ),
+            )
+        except ObjectNotFound:
+            exit_with_error(f"Work pool {work_pool_name!r} does not exist.")
+
+        exit_with_success(f"Configured S3 storage for work pool {work_pool_name!r}")

{prefect-3.2.14.dev3 → prefect-3.2.15.dev2}/src/prefect/client/orchestration/_flow_runs/client.py

@@ -46,6 +46,9 @@ class FlowRunClient(BaseClient):
         tags: "Iterable[str] | None" = None,
         parent_task_run_id: "UUID | None" = None,
         state: "State[R] | None" = None,
+        work_pool_name: str | None = None,
+        work_queue_name: str | None = None,
+        job_variables: dict[str, Any] | None = None,
     ) -> "FlowRun":
         """
         Create a flow run for a flow.
@@ -59,7 +62,10 @@ class FlowRunClient(BaseClient):
             parent_task_run_id: if a subflow run is being created, the placeholder task
                 run identifier in the parent flow
             state: The initial state for the run. If not provided, defaults to
-                `Scheduled` for now. Should always be a `Scheduled` type.
+                `Pending`.
+            work_pool_name: The name of the work pool to run the flow run in.
+            work_queue_name: The name of the work queue to place the flow run in.
+            job_variables: The job variables to use when setting up flow run infrastructure.
 
         Raises:
             httpx.RequestError: if the Prefect API does not successfully create a run for any reason
@@ -100,7 +106,16 @@ class FlowRunClient(BaseClient):
             ),
         )
 
-        flow_run_create_json = flow_run_create.model_dump(mode="json")
+        if work_pool_name is not None:
+            flow_run_create.work_pool_name = work_pool_name
+        if work_queue_name is not None:
+            flow_run_create.work_queue_name = work_queue_name
+        if job_variables is not None:
+            flow_run_create.job_variables = job_variables
+
+        flow_run_create_json = flow_run_create.model_dump(
+            mode="json", exclude_unset=True
+        )
         response = self.request("POST", "/flow_runs/", json=flow_run_create_json)
 
         flow_run = FlowRun.model_validate(response.json())
@@ -480,6 +495,9 @@ class FlowRunAsyncClient(BaseAsyncClient):
         tags: "Iterable[str] | None" = None,
         parent_task_run_id: "UUID | None" = None,
         state: "State[R] | None" = None,
+        work_pool_name: str | None = None,
+        work_queue_name: str | None = None,
+        job_variables: dict[str, Any] | None = None,
     ) -> "FlowRun":
         """
         Create a flow run for a flow.
@@ -493,7 +511,10 @@ class FlowRunAsyncClient(BaseAsyncClient):
             parent_task_run_id: if a subflow run is being created, the placeholder task
                 run identifier in the parent flow
             state: The initial state for the run. If not provided, defaults to
-                `Scheduled` for now. Should always be a `Scheduled` type.
+                `Pending`.
+            work_pool_name: The name of the work pool to run the flow run in.
+            work_queue_name: The name of the work queue to place the flow run in.
+            job_variables: The job variables to use when setting up flow run infrastructure.
 
         Raises:
             httpx.RequestError: if the Prefect API does not successfully create a run for any reason
@@ -534,7 +555,16 @@ class FlowRunAsyncClient(BaseAsyncClient):
             ),
         )
 
-        flow_run_create_json = flow_run_create.model_dump(mode="json")
+        if work_pool_name is not None:
+            flow_run_create.work_pool_name = work_pool_name
+        if work_queue_name is not None:
+            flow_run_create.work_queue_name = work_queue_name
+        if job_variables is not None:
+            flow_run_create.job_variables = job_variables
+
+        flow_run_create_json = flow_run_create.model_dump(
+            mode="json", exclude_unset=True
+        )
         response = await self.request("POST", "/flow_runs/", json=flow_run_create_json)
 
         flow_run = FlowRun.model_validate(response.json())

{prefect-3.2.14.dev3 → prefect-3.2.15.dev2}/src/prefect/client/schemas/actions.py

@@ -39,6 +39,7 @@ from prefect.types import (
     DateTime,
     KeyValueLabelsField,
     Name,
+    NameOrEmpty,
     NonEmptyishName,
     NonNegativeFloat,
     NonNegativeInteger,
@@ -212,7 +213,7 @@ class DeploymentCreate(ActionBaseModel):
     ) -> Union[str, list[str]]:
         return convert_to_strings(values)
 
-    name: str = Field(..., description="The name of the deployment.")
+    name: NameOrEmpty = Field(..., description="The name of the deployment.")
     flow_id: UUID = Field(..., description="The ID of the flow to deploy.")
     paused: Optional[bool] = Field(default=None)
     schedules: list[DeploymentScheduleCreate] = Field(
@@ -444,6 +445,9 @@ class FlowRunCreate(ActionBaseModel):
     idempotency_key: Optional[str] = Field(default=None)
 
     labels: KeyValueLabelsField = Field(default_factory=dict)
+    work_pool_name: Optional[str] = Field(default=None)
+    work_queue_name: Optional[str] = Field(default=None)
+    job_variables: Optional[dict[str, Any]] = Field(default=None)
 
 
 class DeploymentFlowRunCreate(ActionBaseModel):

{prefect-3.2.14.dev3 → prefect-3.2.15.dev2}/src/prefect/deployments/runner.py

@@ -676,15 +676,7 @@ class RunnerDeployment(BaseModel):
                     try:
                         module = importlib.import_module(mod_name)
                         flow_file = getattr(module, "__file__", None)
-                    except ModuleNotFoundError as exc:
-                        # 16458 adds an identifier to the module name, so checking
-                        # for "__prefect_loader__" (2 underscores) will not match
-                        if "__prefect_loader_" in str(exc):
-                            raise ValueError(
-                                "Cannot create a RunnerDeployment from a flow that has been"
-                                " loaded from an entrypoint. To deploy a flow via"
-                                " entrypoint, use RunnerDeployment.from_entrypoint instead."
-                            )
+                    except ModuleNotFoundError:
                         raise ValueError(no_file_location_error)
                     if not flow_file:
                         raise ValueError(no_file_location_error)

{prefect-3.2.14.dev3 → prefect-3.2.15.dev2}/src/prefect/docker/docker_image.py

@@ -64,7 +64,8 @@ class DockerImage:
     def build(self) -> None:
         full_image_name = self.reference
         build_kwargs = self.build_kwargs.copy()
-        build_kwargs["context"] = Path.cwd()
+        if "context" not in build_kwargs:
+            build_kwargs["context"] = Path.cwd()
         build_kwargs["tag"] = full_image_name
         build_kwargs["pull"] = build_kwargs.get("pull", True)
 

{prefect-3.2.14.dev3 → prefect-3.2.15.dev2}/src/prefect/locking/memory.py

@@ -193,23 +193,31 @@ class MemoryLockManager(LockManager):
         )
 
     def wait_for_lock(self, key: str, timeout: Optional[float] = None) -> bool:
-        if lock := self._locks.get(key, {}).get("lock"):
+        lock_info: _LockInfo | None = self._locks.get(key)
+        if lock_info is None:
+            return True
+        if lock_info["lock"].locked():
             if timeout is not None:
-                lock_acquired = lock.acquire(timeout=timeout)
+                lock_acquired = lock_info["lock"].acquire(timeout=timeout)
             else:
-                lock_acquired = lock.acquire()
+                lock_acquired = lock_info["lock"].acquire()
             if lock_acquired:
-                lock.release()
+                lock_info["lock"].release()
             return lock_acquired
         return True
 
     async def await_for_lock(self, key: str, timeout: Optional[float] = None) -> bool:
-        if lock := self._locks.get(key, {}).get("lock"):
+        lock_info: _LockInfo | None = self._locks.get(key, None)
+        if lock_info is None:
+            return True
+        if lock_info["lock"].locked():
             if timeout is not None:
-                lock_acquired = await asyncio.to_thread(lock.acquire, timeout=timeout)
+                lock_acquired = await asyncio.to_thread(
+                    lock_info["lock"].acquire, timeout=timeout
+                )
             else:
-                lock_acquired = await asyncio.to_thread(lock.acquire)
+                lock_acquired = await asyncio.to_thread(lock_info["lock"].acquire)
             if lock_acquired:
-                lock.release()
+                lock_info["lock"].release()
             return lock_acquired
         return True

{prefect-3.2.14.dev3 → prefect-3.2.15.dev2}/src/prefect/logging/__init__.py

@@ -1,3 +1,3 @@
 from .loggers import disable_run_logger, get_logger, get_run_logger, LogEavesdropper
 
-__all__ = ["get_logger", "get_run_logger", "LogEavesdropper"]
+__all__ = ["get_logger", "get_run_logger", "LogEavesdropper", "disable_run_logger"]

{prefect-3.2.14.dev3 → prefect-3.2.15.dev2}/src/prefect/logging/configuration.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import logging
 import logging.config
 import os
@@ -6,7 +8,7 @@ import string
 import warnings
 from functools import partial
 from pathlib import Path
-from typing import Any, Callable, Dict, Optional
+from typing import Any, Callable
 
 import yaml
 
@@ -21,7 +23,7 @@ from prefect.utilities.collections import dict_to_flatdict, flatdict_to_dict
 DEFAULT_LOGGING_SETTINGS_PATH = Path(__file__).parent / "logging.yml"
 
 # Stores the configuration used to setup logging in this Python process
-PROCESS_LOGGING_CONFIG: Optional[Dict[str, Any]] = None
+PROCESS_LOGGING_CONFIG: dict[str, Any] = {}
 
 # Regex call to replace non-alphanumeric characters to '_' to create a valid env var
 to_envvar: Callable[[str], str] = partial(re.sub, re.compile(r"[^0-9a-zA-Z]+"), "_")
@@ -60,7 +62,7 @@ def load_logging_config(path: Path) -> dict[str, Any]:
     return flatdict_to_dict(flat_config)
 
 
-def setup_logging(incremental: Optional[bool] = None) -> dict[str, Any]:
+def setup_logging(incremental: bool | None = None) -> dict[str, Any]:
     """
     Sets up logging.
 
@@ -100,6 +102,6 @@ def setup_logging(incremental: Optional[bool] = None) -> dict[str, Any]:
             for handler in extra_config.handlers:
                 logger.addHandler(handler)
 
-    PROCESS_LOGGING_CONFIG = config
+    PROCESS_LOGGING_CONFIG.update(config)
 
     return config

{prefect-3.2.14.dev3 → prefect-3.2.15.dev2}/src/prefect/logging/formatters.py

@@ -78,7 +78,7 @@ class PrefectFormatter(logging.Formatter):
         self,
         format: str | None = None,
         datefmt: str | None = None,
-        style: str = "%",
+        style: Literal["%", "{", "$"] = "%",
         validate: bool = True,
         *,
         defaults: dict[str, Any] | None = None,
@@ -93,8 +93,8 @@ class PrefectFormatter(logging.Formatter):
         # See https://github.com/python/cpython/blob/c8c6113398ee9a7867fe9b08bc539cceb61e2aaa/Lib/logging/__init__.py#L546
         # for implementation details
 
-        init_kwargs = {}
-        style_kwargs = {}
+        init_kwargs: dict[str, Any] = {}
+        style_kwargs: dict[str, Any] = {}
 
         # defaults added in 3.10
         if sys.version_info >= (3, 10):