prefect 3.6.8__tar.gz → 3.6.8.dev3__tar.gz

{prefect-3.6.8 → prefect-3.6.8.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prefect
-Version: 3.6.8
+Version: 3.6.8.dev3
 Summary: Workflow orchestration and management.
 Project-URL: Changelog, https://github.com/PrefectHQ/prefect/releases
 Project-URL: Documentation, https://docs.prefect.io
@@ -57,7 +57,7 @@ Requires-Dist: pydantic!=2.11.0,!=2.11.1,!=2.11.2,!=2.11.3,!=2.11.4,<3.0.0,>=2.1
 Requires-Dist: pydantic-core<3.0.0,>=2.12.0
 Requires-Dist: pydantic-extra-types<3.0.0,>=2.8.2
 Requires-Dist: pydantic-settings!=2.9.0,<3.0.0,>2.2.1
-Requires-Dist: pydocket>=0.16.2
+Requires-Dist: pydocket>=0.13.0
 Requires-Dist: python-dateutil<3.0.0,>=2.8.2
 Requires-Dist: python-slugify<9.0,>=5.0
 Requires-Dist: pytz<2026,>=2021.1

{prefect-3.6.8 → prefect-3.6.8.dev3}/pyproject.toml

@@ -80,7 +80,7 @@ dependencies = [
     "whenever>=0.7.3,<0.10.0; python_version>='3.13'",
     "semver>=3.0.4",
     "pluggy>=1.6.0",
-    "pydocket>=0.16.2",
+    "pydocket>=0.13.0",
 ]
 [project.urls]
 Changelog = "https://github.com/PrefectHQ/prefect/releases"
@@ -160,7 +160,7 @@ dev = [
     "watchfiles>=1.0.4",
     "respx>=0.22.0",
     "codespell==2.4.1",
-    "ruff==0.14.10",
+    "ruff==0.14.8",
     "mypy==1.15.0",
     "types-cachetools>=5.3.1",
     "types-PyYAML>=6.0.12",

prefect-3.6.8.dev3/src/prefect/_build_info.py

@@ -0,0 +1,5 @@
+# Generated by versioningit
+__version__ = "3.6.8.dev3"
+__build_date__ = "2025-12-24 08:10:32.804810+00:00"
+__git_commit__ = "4baedb2efecfb4d82ce18b339ce16383da4a5754"
+__dirty__ = False

{prefect-3.6.8 → prefect-3.6.8.dev3}/src/prefect/blocks/notifications.py

@@ -844,12 +844,11 @@ class CustomWebhookNotificationBlock(NotificationBlock):
             ' "{{tokenFromSecrets}}"}'
         ],
     )
-    form_data: Optional[dict[str, str] | str] = Field(
+    form_data: Optional[dict[str, str]] = Field(
         default=None,
         title="Form Data",
         description=(
-            "Send form data as payload. Should not be used together with _JSON Data_. "
-            "Can be a dictionary for form-encoded data or a string for raw body content."
+            "Send form data as payload. Should not be used together with _JSON Data_."
         ),
         examples=[
             '{"text": "{{subject}}\\n{{body}}", "title": "{{name}}", "token":'
@@ -883,18 +882,13 @@ class CustomWebhookNotificationBlock(NotificationBlock):
                 "name": self.name,
             }
         )
-        # httpx uses 'data' for form-encoded dicts, 'content' for raw string/bytes
-        if isinstance(self.form_data, str):
-            data_key = "content"
-        else:
-            data_key = "data"
         # do substution
         return apply_values(
             {
                 "method": self.method,
                 "url": self.url,
                 "params": self.params,
-                data_key: self.form_data,
+                "data": self.form_data,
                 "json": self.json_data,
                 "headers": self.headers,
                 "cookies": self.cookies,

{prefect-3.6.8 → prefect-3.6.8.dev3}/src/prefect/cli/flow_run.py

@@ -10,15 +10,9 @@ import signal
 import threading
 import webbrowser
 from types import FrameType
-from typing import TYPE_CHECKING, List, Optional
+from typing import List, Optional
 from uuid import UUID
 
-from prefect.utilities.callables import get_call_parameters, parameters_to_args_kwargs
-
-if TYPE_CHECKING:
-    from prefect.client.orchestration import PrefectClient
-    from prefect.client.schemas.objects import FlowRun
-
 import httpx
 import orjson
 import typer
@@ -38,7 +32,7 @@ from prefect.client.schemas.sorting import FlowRunSort, LogSort
 from prefect.exceptions import ObjectNotFound
 from prefect.logging import get_logger
 from prefect.runner import Runner
-from prefect.states import State, exception_to_crashed_state
+from prefect.states import State
 from prefect.types._datetime import human_friendly_diff
 from prefect.utilities.asyncutils import run_sync_in_worker_thread
 from prefect.utilities.urls import url_for
@@ -49,65 +43,6 @@ flow_run_app: PrefectTyper = PrefectTyper(
 app.add_typer(flow_run_app, aliases=["flow-runs"])
 
 LOGS_DEFAULT_PAGE_SIZE = 200
-
-
-async def _get_flow_run_by_id_or_name(
-    client: "PrefectClient",
-    id_or_name: str,
-) -> "FlowRun":
-    """
-    Resolve a flow run identifier that could be either a UUID or a name.
-
-    Flow run names are not guaranteed to be unique, so this function will
-    error if multiple flow runs match the given name.
-
-    Args:
-        client: The Prefect client to use for API calls
-        id_or_name: Either a UUID string or a flow run name
-
-    Returns:
-        The matching FlowRun object
-
-    Raises:
-        typer.Exit: If flow run not found, or if multiple flow runs match the name
-    """
-    from prefect.client.schemas.filters import FlowRunFilterName
-
-    # First, try parsing as UUID
-    try:
-        flow_run_id = UUID(id_or_name)
-        try:
-            return await client.read_flow_run(flow_run_id)
-        except ObjectNotFound:
-            exit_with_error(f"Flow run '{id_or_name}' not found!")
-    except ValueError:
-        # Not a valid UUID, treat as a name
-        pass
-
-    # Query by name (exact match)
-    flow_runs = await client.read_flow_runs(
-        flow_run_filter=FlowRunFilter(name=FlowRunFilterName(any_=[id_or_name])),
-        limit=100,  # Reasonable limit for displaying matches
-    )
-
-    if not flow_runs:
-        exit_with_error(f"Flow run '{id_or_name}' not found!")
-
-    if len(flow_runs) == 1:
-        return flow_runs[0]
-
-    # Multiple matches - show all and exit with error
-    lines = [f"Multiple flow runs found with name '{id_or_name}':\n"]
-    for fr in flow_runs:
-        state_name = fr.state.name if fr.state else "unknown"
-        timestamp = fr.start_time or fr.created
-        timestamp_str = timestamp.strftime("%Y-%m-%d %H:%M:%S") if timestamp else "N/A"
-        lines.append(f"  - {fr.id} ({state_name}, {timestamp_str})")
-
-    lines.append("\nPlease retry using an explicit flow run ID.")
-    exit_with_error("\n".join(lines))
-
-
 LOGS_WITH_LIMIT_FLAG_DEFAULT_NUM_LOGS = 20
 
 logger: "logging.Logger" = get_logger(__name__)
@@ -341,189 +276,6 @@ async def cancel(id: UUID):
     exit_with_success(f"Flow run '{id}' was successfully scheduled for cancellation.")
 
 
-@flow_run_app.command()
-async def retry(
-    id_or_name: str = typer.Argument(
-        ...,
-        help="The flow run ID (UUID) or name to retry.",
-    ),
-    entrypoint: Optional[str] = typer.Option(
-        None,
-        "--entrypoint",
-        "-e",
-        help=(
-            "The path to a file containing the flow to run, and the name of the flow "
-            "function, in the format `path/to/file.py:flow_function_name`. "
-            "Required if the flow run does not have an associated deployment."
-        ),
-    ),
-):
-    """
-    Retry a failed or completed flow run.
-
-    The flow run can be specified by either its UUID or its name. If multiple
-    flow runs have the same name, you must use the UUID to disambiguate.
-
-    If the flow run has an associated deployment, it will be scheduled for retry
-    and a worker will pick it up. If there is no deployment, you must provide
-    an --entrypoint to the flow code, and the flow will execute locally.
-
-    \b
-    Examples:
-        $ prefect flow-run retry abc123-def456-7890-...
-        $ prefect flow-run retry my-flow-run-name
-        $ prefect flow-run retry abc123 --entrypoint ./flows/my_flow.py:my_flow
-    """
-    from prefect.flow_engine import run_flow
-    from prefect.flows import load_flow_from_entrypoint
-    from prefect.states import Scheduled
-
-    terminal_states = {
-        StateType.COMPLETED,
-        StateType.FAILED,
-        StateType.CANCELLED,
-        StateType.CRASHED,
-    }
-
-    async with get_client() as client:
-        # Resolve flow run by ID or name
-        flow_run = await _get_flow_run_by_id_or_name(client, id_or_name)
-        flow_run_id = flow_run.id
-
-        # Validate flow run is in terminal state
-        if flow_run.state is None or flow_run.state.type not in terminal_states:
-            current_state = flow_run.state.type.value if flow_run.state else "unknown"
-            exit_with_error(
-                f"Flow run '{flow_run_id}' is in state '{current_state}' and cannot be retried. "
-                f"Only flow runs in terminal states (COMPLETED, FAILED, CANCELLED, CRASHED) can be retried."
-            )
-
-        # Branch based on deployment association
-        if flow_run.deployment_id:
-            # Deployment-based retry: set state to Scheduled and exit
-            # Use force=True to bypass orchestration rules that prevent state transitions
-            # from terminal states (e.g., CANCELLED -> SCHEDULED)
-            scheduled_state = Scheduled(message="Retried via CLI")
-            try:
-                result = await client.set_flow_run_state(
-                    flow_run_id=flow_run_id, state=scheduled_state, force=True
-                )
-            except ObjectNotFound:
-                exit_with_error(f"Flow run '{flow_run_id}' not found!")
-
-            if result.status == SetStateStatus.ABORT:
-                exit_with_error(
-                    f"Flow run '{flow_run_id}' could not be retried. Reason: '{result.details.reason}'"
-                )
-
-            exit_with_success(
-                f"Flow run '{flow_run_id}' has been scheduled for retry. "
-                "A worker will pick it up shortly."
-            )
-        else:
-            # Local retry: require entrypoint and execute synchronously
-            if not entrypoint:
-                exit_with_error(
-                    f"Flow run '{flow_run_id}' does not have an associated deployment. "
-                    "Please provide an --entrypoint to the flow code.\n\n"
-                    f"Example: prefect flow-run retry {flow_run_id} --entrypoint ./flows/my_flow.py:my_flow"
-                )
-
-            # Load the flow from entrypoint
-            try:
-                flow = load_flow_from_entrypoint(entrypoint, use_placeholder_flow=False)
-            except Exception as exc:
-                exit_with_error(
-                    f"Failed to load flow from entrypoint '{entrypoint}': {exc}"
-                )
-
-            # Check if this is an infrastructure-bound flow
-            from prefect.flows import InfrastructureBoundFlow
-
-            if isinstance(flow, InfrastructureBoundFlow):
-                app.console.print(
-                    f"Retrying flow run '{flow_run_id}' on remote infrastructure "
-                    f"(work pool: {flow.work_pool})..."
-                )
-
-                try:
-                    # Use the retry method which handles remote execution
-                    await flow.retry(flow_run)
-                except Exception as exc:
-                    exit_with_error(f"Flow run failed: {exc}")
-
-                # Re-fetch to get final state
-                flow_run = await client.read_flow_run(flow_run_id)
-                final_state = flow_run.state.type.value if flow_run.state else "unknown"
-
-                if flow_run.state and flow_run.state.is_completed():
-                    exit_with_success(
-                        f"Flow run '{flow_run_id}' completed successfully."
-                    )
-                else:
-                    exit_with_error(
-                        f"Flow run '{flow_run_id}' finished with state: {final_state}"
-                    )
-            else:
-                # Regular local execution path
-                # Set state to Scheduled with force=True to bypass deployment check
-                scheduled_state = Scheduled(message="Retried via CLI (local execution)")
-                try:
-                    result = await client.set_flow_run_state(
-                        flow_run_id=flow_run_id, state=scheduled_state, force=True
-                    )
-                except ObjectNotFound:
-                    exit_with_error(f"Flow run '{flow_run_id}' not found!")
-
-                if result.status == SetStateStatus.ABORT:
-                    exit_with_error(
-                        f"Flow run '{flow_run_id}' could not be retried. Reason: '{result.details.reason}'"
-                    )
-
-                app.console.print(f"Executing flow run '{flow_run_id}' locally...")
-
-                # Re-fetch the flow run to get updated state
-                flow_run = await client.read_flow_run(flow_run_id)
-
-                try:
-                    call_args, call_kwargs = parameters_to_args_kwargs(
-                        flow.fn, flow_run.parameters if flow_run else {}
-                    )
-                    parameters = get_call_parameters(flow.fn, call_args, call_kwargs)
-                except Exception as exc:
-                    state = await exception_to_crashed_state(exc)
-                    await client.set_flow_run_state(
-                        flow_run_id=flow_run_id, state=state, force=True
-                    )
-                    exit_with_error(
-                        "Failed to use parameters from previous attempt. Please ensure the flow signature has not changed since the last run."
-                    )
-
-                # Execute the flow synchronously, reusing the existing flow run
-                try:
-                    run_flow(
-                        flow=flow,
-                        flow_run=flow_run,
-                        return_type="state",
-                        parameters=parameters,
-                    )
-                except Exception as exc:
-                    exit_with_error(f"Flow run failed: {exc}")
-
-                # Re-fetch to get final state
-                flow_run = await client.read_flow_run(flow_run_id)
-                final_state = flow_run.state.type.value if flow_run.state else "unknown"
-
-                if flow_run.state and flow_run.state.is_completed():
-                    exit_with_success(
-                        f"Flow run '{flow_run_id}' completed successfully."
-                    )
-                else:
-                    exit_with_error(
-                        f"Flow run '{flow_run_id}' finished with state: {final_state}"
-                    )
-
-
 @flow_run_app.command()
 async def logs(
     id: UUID,

{prefect-3.6.8 → prefect-3.6.8.dev3}/src/prefect/flows.py

@@ -2204,61 +2204,6 @@ class InfrastructureBoundFlow(Flow[P, R]):
 
         return run_coro_as_sync(submit_func())
 
-    async def retry(
-        self,
-        flow_run: "FlowRun",
-    ) -> R | State[R]:
-        """
-        EXPERIMENTAL: This method is experimental and may be removed or changed in future
-            releases.
-
-        Retry an existing flow run on remote infrastructure.
-
-        This method allows retrying a flow run that was previously executed,
-        reusing the same flow run ID and incrementing the run_count.
-
-        Args:
-            flow_run: The existing flow run to retry
-            return_state: If True, return the final state instead of the result
-
-        Returns:
-            The flow result or final state
-
-        Example:
-            ```python
-            from prefect import flow
-            from prefect_aws.experimental import ecs
-
-            @ecs(work_pool="my-pool")
-            @flow
-            def my_flow():
-                ...
-
-            # Original run
-            my_flow()  # Creates flow run abc123
-
-            # Later, retry the same flow run
-            flow_run = client.read_flow_run("abc123")
-            await my_flow.retry(flow_run)
-            ```
-        """
-        try:
-            async with self.worker_cls(work_pool_name=self.work_pool) as worker:
-                future = await worker.submit(
-                    flow=self,
-                    parameters=flow_run.parameters,
-                    job_variables=self.job_variables,
-                    flow_run=flow_run,
-                )
-                return await future.aresult()
-        except (ExceptionGroup, BaseExceptionGroup) as exc:
-            # For less verbose tracebacks
-            exceptions = exc.exceptions
-            if len(exceptions) == 1:
-                raise exceptions[0] from None
-            else:
-                raise
-
     def submit_to_work_pool(
         self, *args: P.args, **kwargs: P.kwargs
     ) -> PrefectFlowRunFuture[R]:

{prefect-3.6.8 → prefect-3.6.8.dev3}/src/prefect/futures.py

@@ -373,7 +373,7 @@ class PrefectFlowRunFuture(PrefectFuture[R]):
     async def wait_async(self, timeout: float | None = None) -> None:
         if self._final_state:
             logger.debug(
-                "Final state already set for %s. Returning...", self.flow_run_id
+                "Final state already set for %s. Returning...", self.task_run_id
             )
             return
 
@@ -425,7 +425,7 @@ class PrefectFlowRunFuture(PrefectFuture[R]):
             await self.wait_async(timeout=timeout)
             if not self._final_state:
                 raise TimeoutError(
-                    f"Flow run {self.flow_run_id} did not complete within {timeout} seconds"
+                    f"Task run {self.task_run_id} did not complete within {timeout} seconds"
                 )
 
         return await self._final_state.aresult(raise_on_failure=raise_on_failure)

{prefect-3.6.8 → prefect-3.6.8.dev3}/src/prefect/server/api/background_workers.py

@@ -47,7 +47,7 @@ async def background_worker(
     webserver_only: bool = False,
 ) -> AsyncGenerator[None, None]:
     worker_task: asyncio.Task[None] | None = None
-    async with Worker(docket) as worker:
+    try:
         # Register background task functions
         docket.register_collection(
             "prefect.server.api.background_workers:task_functions"
@@ -58,14 +58,24 @@ async def background_worker(
             docket, ephemeral=ephemeral, webserver_only=webserver_only
         )
 
-        try:
+        async with Worker(docket) as worker:
             worker_task = asyncio.create_task(worker.run_forever())
             yield
 
-        finally:
-            if worker_task:
-                worker_task.cancel()
-                try:
-                    await worker_task
-                except asyncio.CancelledError:
-                    pass
+    finally:
+        if worker_task:
+            worker_task.cancel()
+            try:
+                logger.debug(
+                    "Waiting for background worker to finish after cancellation..."
+                )
+                await asyncio.wait_for(worker_task, timeout=5.0)
+                logger.debug(
+                    "Background worker finished successfully after cancellation"
+                )
+            except asyncio.TimeoutError:
+                logger.debug(
+                    "Background worker did not finish within 5 seconds after cancellation. Proceeding with shutdown"
+                )
+            except asyncio.CancelledError:
+                pass

{prefect-3.6.8 → prefect-3.6.8.dev3}/src/prefect/workers/base.py

@@ -766,7 +766,6 @@ class BaseWorker(abc.ABC, Generic[C, V, R]):
         flow: "Flow[..., FR]",
         parameters: dict[str, Any] | None = None,
         job_variables: dict[str, Any] | None = None,
-        flow_run: "FlowRun | None" = None,
     ) -> "PrefectFlowRunFuture[FR]":
         """
         EXPERIMENTAL: The interface for this method is subject to change.
@@ -776,11 +775,9 @@ class BaseWorker(abc.ABC, Generic[C, V, R]):
         Args:
             flow: The flow to submit
             parameters: The parameters to pass to the flow
-            job_variables: Job variables for infrastructure configuration
-            flow_run: Optional existing flow run to retry (reuses ID instead of creating new)
 
         Returns:
-            A flow run future
+            A flow run object
         """
         warnings.warn(
             "Ad-hoc flow submission via workers is experimental. The interface "
@@ -796,7 +793,6 @@ class BaseWorker(abc.ABC, Generic[C, V, R]):
                 flow=flow,
                 parameters=parameters,
                 job_variables=job_variables,
-                flow_run=flow_run,
             ),
         )
         return PrefectFlowRunFuture(flow_run_id=flow_run.id)
@@ -807,17 +803,9 @@ class BaseWorker(abc.ABC, Generic[C, V, R]):
         parameters: dict[str, Any] | None = None,
         job_variables: dict[str, Any] | None = None,
         task_status: anyio.abc.TaskStatus["FlowRun"] | None = None,
-        flow_run: "FlowRun | None" = None,
     ):
         """
         Submits a flow for the worker to kick off execution for.
-
-        Args:
-            flow: The flow to submit
-            parameters: The parameters to pass to the flow
-            job_variables: Job variables for infrastructure configuration
-            task_status: Task status for signaling when the flow run is ready
-            flow_run: Optional existing flow run to retry (reuses ID instead of creating new)
         """
         from prefect._experimental.bundles import (
             aupload_bundle_to_storage,
@@ -874,40 +862,28 @@ class BaseWorker(abc.ABC, Generic[C, V, R]):
         job_variables = (job_variables or {}) | {"command": " ".join(execute_command)}
         parameters = parameters or {}
 
-        if flow_run is None:
-            # Create new flow run (standard behavior)
-            # Create a parent task run if this is a child flow run to ensure it shows up as a child flow in the UI
-            parent_task_run = None
-            if flow_run_ctx := FlowRunContext.get():
-                parent_task = Task[Any, Any](
-                    name=flow.name,
-                    fn=flow.fn,
-                    version=flow.version,
-                )
-                parent_task_run = await parent_task.create_run(
-                    flow_run_context=flow_run_ctx,
-                    parameters=parameters,
-                )
-
-            flow_run = await self.client.create_flow_run(
-                flow,
-                parameters=flow.serialize_parameters(parameters),
-                state=Pending(),
-                job_variables=job_variables,
-                work_pool_name=self.work_pool.name,
-                tags=TagsContext.get().current_tags,
-                parent_task_run_id=getattr(parent_task_run, "id", None),
+        # Create a parent task run if this is a child flow run to ensure it shows up as a child flow in the UI
+        parent_task_run = None
+        if flow_run_ctx := FlowRunContext.get():
+            parent_task = Task[Any, Any](
+                name=flow.name,
+                fn=flow.fn,
+                version=flow.version,
             )
-        else:
-            # Reuse existing flow run - set state to Pending for retry
-            await self.client.set_flow_run_state(
-                flow_run_id=flow_run.id,
-                state=Pending(message="Retrying on remote infrastructure"),
-                force=True,
+            parent_task_run = await parent_task.create_run(
+                flow_run_context=flow_run_ctx,
+                parameters=parameters,
             )
-            # Re-fetch to get updated state
-            flow_run = await self.client.read_flow_run(flow_run.id)
 
+        flow_run = await self.client.create_flow_run(
+            flow,
+            parameters=flow.serialize_parameters(parameters),
+            state=Pending(),
+            job_variables=job_variables,
+            work_pool_name=self.work_pool.name,
+            tags=TagsContext.get().current_tags,
+            parent_task_run_id=getattr(parent_task_run, "id", None),
+        )
         if task_status is not None:
             # Emit the flow run object to .submit to allow it to return a future as soon as possible
             task_status.started(flow_run)

{prefect-3.6.8 → prefect-3.6.8.dev3}/src/prefect/workers/process.py

@@ -263,27 +263,18 @@ class ProcessWorker(
         parameters: dict[str, Any] | None = None,
         job_variables: dict[str, Any] | None = None,
         task_status: anyio.abc.TaskStatus["FlowRun"] | None = None,
-        flow_run: "FlowRun | None" = None,
     ):
         from prefect._experimental.bundles import (
             create_bundle_for_flow_run,
         )
 
-        if flow_run is None:
-            flow_run = await self.client.create_flow_run(
-                flow,
-                parameters=parameters,
-                state=Pending(),
-                job_variables=job_variables,
-                work_pool_name=self.work_pool.name,
-            )
-        else:
-            # Reuse existing flow run - set state to Pending for retry
-            await self.client.set_flow_run_state(
-                flow_run.id,
-                Pending(),
-                force=True,
-            )
+        flow_run = await self.client.create_flow_run(
+            flow,
+            parameters=parameters,
+            state=Pending(),
+            job_variables=job_variables,
+            work_pool_name=self.work_pool.name,
+        )
         if task_status is not None:
             # Emit the flow run object to .submit to allow it to return a future as soon as possible
             task_status.started(flow_run)

prefect-3.6.8/src/prefect/_build_info.py

@@ -1,5 +0,0 @@
-# Generated by versioningit
-__version__ = "3.6.8"
-__build_date__ = "2025-12-24 19:25:05.398703+00:00"
-__git_commit__ = "8ae19ff770f3b9095c478314f845b0d699ba852f"
-__dirty__ = False