prefect 3.2.10.dev4__tar.gz → 3.2.12.dev1__tar.gz

{prefect-3.2.10.dev4 → prefect-3.2.12.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prefect
-Version: 3.2.10.dev4
+Version: 3.2.12.dev1
 Summary: Workflow orchestration and management.
 Project-URL: Changelog, https://github.com/PrefectHQ/prefect/releases
 Project-URL: Documentation, https://docs.prefect.io

{prefect-3.2.10.dev4 → prefect-3.2.12.dev1}/pyproject.toml

@@ -287,9 +287,11 @@ ignore_errors = true
 
 [tool.ruff]
 src = ["src"]
+
+[tool.ruff.lint]
 extend-select = ["I"]
 
-[tool.ruff.per-file-ignores]
+[tool.ruff.lint.per-file-ignores]
 "__init__.py" = ["E402", "F401", "I"]
 "main.py" = ["E402", "F401", "I"]
 "src/prefect/utilities/compat.py" = ["F401", "I"]
@@ -297,10 +299,9 @@ extend-select = ["I"]
 "src/prefect/runtime/*" = ["F822"]
 "src/prefect/server/database/migrations/**/*" = ["E501"]
 
-[tool.ruff.isort]
+[tool.ruff.lint.isort]
 known-third-party = []
 
-
 [tool.codespell]
 skip = [
     ".git",
@@ -327,6 +328,7 @@ ignore-words-list = [
     "nmme",
     "afterall",
     "medias",
+    "falso",
 ]
 
 check-hidden = true

prefect-3.2.12.dev1/src/prefect/_build_info.py

@@ -0,0 +1,5 @@
+# Generated by versioningit
+__version__ = "3.2.12.dev1"
+__build_date__ = "2025-03-06 08:08:54.794437+00:00"
+__git_commit__ = "09391eca413cab607dd5d1a74e95724268ffd617"
+__dirty__ = False

{prefect-3.2.10.dev4 → prefect-3.2.12.dev1}/src/prefect/cli/flow_run.py

@@ -2,8 +2,13 @@
 Command line interface for working with flow runs
 """
 
+from __future__ import annotations
+
 import logging
 import os
+import signal
+import threading
+from types import FrameType
 from typing import List, Optional
 from uuid import UUID
 
@@ -352,4 +357,19 @@ async def execute(
     if id is None:
         exit_with_error("Could not determine the ID of the flow run to execute.")
 
-    await Runner().execute_flow_run(id)
+    runner = Runner()
+
+    def _handle_reschedule_sigterm(_signal: int, _frame: FrameType | None):
+        logger.info("SIGTERM received, initiating graceful shutdown...")
+        runner.reschedule_current_flow_runs()
+        exit_with_success("Flow run successfully rescheduled.")
+
+    # Set up signal handling to reschedule run on SIGTERM
+    on_sigterm = os.environ.get("PREFECT_FLOW_RUN_EXECUTE_SIGTERM_BEHAVIOR", "").lower()
+    if (
+        threading.current_thread() is threading.main_thread()
+        and on_sigterm == "reschedule"
+    ):
+        signal.signal(signal.SIGTERM, _handle_reschedule_sigterm)
+
+    await runner.execute_flow_run(id)

{prefect-3.2.10.dev4 → prefect-3.2.12.dev1}/src/prefect/cli/server.py

@@ -36,6 +36,7 @@ from prefect.settings import (
     PREFECT_API_URL,
     PREFECT_HOME,
     PREFECT_SERVER_ANALYTICS_ENABLED,
+    PREFECT_SERVER_API_BASE_PATH,
     PREFECT_SERVER_API_HOST,
     PREFECT_SERVER_API_KEEPALIVE_TIMEOUT,
     PREFECT_SERVER_API_PORT,
@@ -74,6 +75,11 @@ SERVICES_PID_FILE = Path(PREFECT_HOME.value()) / "services.pid"
 
 
 def generate_welcome_blurb(base_url: str, ui_enabled: bool) -> str:
+    if PREFECT_SERVER_API_BASE_PATH:
+        suffix = PREFECT_SERVER_API_BASE_PATH.value()
+    else:
+        suffix = "/api"
+
     blurb = textwrap.dedent(
         r"""
          ___ ___ ___ ___ ___ ___ _____
@@ -87,7 +93,7 @@ def generate_welcome_blurb(base_url: str, ui_enabled: bool) -> str:
 
         View the API reference documentation at {docs_url}
         """
-    ).format(api_url=base_url + "/api", docs_url=base_url + "/docs")
+    ).format(api_url=base_url + suffix, docs_url=base_url + "/docs")
 
     visit_dashboard = textwrap.dedent(
         f"""

{prefect-3.2.10.dev4 → prefect-3.2.12.dev1}/src/prefect/client/schemas/actions.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from copy import deepcopy
 from typing import TYPE_CHECKING, Any, Callable, Optional, TypeVar, Union
 from uuid import UUID, uuid4

{prefect-3.2.10.dev4 → prefect-3.2.12.dev1}/src/prefect/deployments/flow_runs.py

@@ -4,7 +4,6 @@ from uuid import UUID
 
 import anyio
 from opentelemetry import trace
-from opentelemetry.instrumentation.utils import is_instrumentation_enabled
 
 import prefect
 from prefect._result_records import ResultRecordMetadata
@@ -19,6 +18,16 @@ from prefect.types._datetime import now
 from prefect.utilities.asyncutils import sync_compatible
 from prefect.utilities.slugify import slugify
 
+
+def _is_instrumentation_enabled() -> bool:
+    try:
+        from opentelemetry.instrumentation.utils import is_instrumentation_enabled
+
+        return is_instrumentation_enabled()
+    except (ImportError, ModuleNotFoundError):
+        return False
+
+
 if TYPE_CHECKING:
     from prefect.client.orchestration import PrefectClient
     from prefect.client.schemas.objects import FlowRun
@@ -164,7 +173,7 @@ async def run_deployment(
 
     if flow_run_ctx and flow_run_ctx.flow_run:
         traceparent = flow_run_ctx.flow_run.labels.get(LABELS_TRACEPARENT_KEY)
-    elif is_instrumentation_enabled():
+    elif _is_instrumentation_enabled():
         traceparent = RunTelemetry.traceparent_from_span(span=trace.get_current_span())
     else:
         traceparent = None

{prefect-3.2.10.dev4 → prefect-3.2.12.dev1}/src/prefect/deployments/runner.py

@@ -47,6 +47,7 @@ from pydantic import (
 from rich.console import Console
 from rich.progress import Progress, SpinnerColumn, TextColumn, track
 from rich.table import Table
+from typing_extensions import Self
 
 from prefect._experimental.sla.objects import SlaTypes
 from prefect._internal.compatibility.async_dispatch import async_dispatch
@@ -84,6 +85,7 @@ from prefect.settings import (
 )
 from prefect.types import ListOfNonEmptyStrings
 from prefect.types.entrypoint import EntrypointType
+from prefect.utilities.annotations import freeze
 from prefect.utilities.asyncutils import run_coro_as_sync, sync_compatible
 from prefect.utilities.callables import ParameterSchema, parameter_schema
 from prefect.utilities.collections import get_from_dict, isiterable
@@ -135,7 +137,9 @@ class RunnerDeployment(BaseModel):
         _sla: (Experimental) SLA configuration for the deployment. May be removed or modified at any time. Currently only supported on Prefect Cloud.
     """
 
-    model_config: ClassVar[ConfigDict] = ConfigDict(arbitrary_types_allowed=True)
+    model_config: ClassVar[ConfigDict] = ConfigDict(
+        arbitrary_types_allowed=True, validate_assignment=True
+    )
 
     name: str = Field(..., description="The name of the deployment.")
     flow_name: Optional[str] = Field(
@@ -250,14 +254,30 @@ class RunnerDeployment(BaseModel):
                 trigger.name = f"{self.name}__automation_{i}"
         return self
 
+    @model_validator(mode="after")
+    def validate_deployment_parameters(self) -> Self:
+        """Update the parameter schema to mark frozen parameters as readonly."""
+        if not self.parameters:
+            return self
+
+        for key, value in self.parameters.items():
+            if isinstance(value, freeze):
+                raw_value = value.unfreeze()
+                if key in self._parameter_openapi_schema.properties:
+                    self._parameter_openapi_schema.properties[key]["readOnly"] = True
+                    self._parameter_openapi_schema.properties[key]["enum"] = [raw_value]
+                    self.parameters[key] = raw_value
+
+        return self
+
     @model_validator(mode="before")
     @classmethod
-    def reconcile_paused(cls, values):
+    def reconcile_paused(cls, values: dict[str, Any]) -> dict[str, Any]:
         return reconcile_paused_deployment(values)
 
     @model_validator(mode="before")
     @classmethod
-    def reconcile_schedules(cls, values):
+    def reconcile_schedules(cls, values: dict[str, Any]) -> dict[str, Any]:
         return reconcile_schedules_runner(values)
 
     async def _create(
@@ -367,7 +387,8 @@ class RunnerDeployment(BaseModel):
         await client.update_deployment(
             deployment_id,
             deployment=DeploymentUpdate(
-                **update_payload, parameter_openapi_schema=parameter_openapi_schema
+                **update_payload,
+                parameter_openapi_schema=parameter_openapi_schema,
             ),
         )
 

{prefect-3.2.10.dev4 → prefect-3.2.12.dev1}/src/prefect/runner/runner.py

@@ -108,6 +108,7 @@ from prefect.settings import (
     get_current_settings,
 )
 from prefect.states import (
+    AwaitingRetry,
     Crashed,
     Pending,
     exception_to_failed_state,
@@ -120,7 +121,7 @@ from prefect.utilities.asyncutils import (
     is_async_fn,
     sync_compatible,
 )
-from prefect.utilities.engine import propose_state
+from prefect.utilities.engine import propose_state, propose_state_sync
 from prefect.utilities.processutils import (
     get_sys_executable,
     run_process,
@@ -226,6 +227,7 @@ class Runner:
         )
         if self.heartbeat_seconds is not None and self.heartbeat_seconds < 30:
             raise ValueError("Heartbeat must be 30 seconds or greater.")
+        self._heartbeat_task: asyncio.Task[None] | None = None
 
         self._limiter: anyio.CapacityLimiter | None = None
         self._client: PrefectClient = get_client()
@@ -236,6 +238,8 @@ class Runner:
         self._flow_run_process_map: dict[UUID, ProcessMapEntry] = dict()
         self.__flow_run_process_map_lock: asyncio.Lock | None = None
         self._flow_run_bundle_map: dict[UUID, SerializedBundle] = dict()
+        # Flip to True when we are rescheduling flow runs to avoid marking flow runs as crashed
+        self._rescheduling: bool = False
 
         self._tmp_dir: Path = (
             Path(tempfile.gettempdir()) / "runner_storage" / str(uuid4())
@@ -506,16 +510,6 @@ class Runner:
                         jitter_range=0.3,
                     )
                 )
-                if self.heartbeat_seconds is not None:
-                    loops_task_group.start_soon(
-                        partial(
-                            critical_service_loop,
-                            workload=runner._emit_flow_run_heartbeats,
-                            interval=self.heartbeat_seconds,
-                            run_once=run_once,
-                            jitter_range=0.3,
-                        )
-                    )
 
     def execute_in_background(
         self, func: Callable[..., Any], *args: Any, **kwargs: Any
@@ -568,9 +562,9 @@ class Runner:
         flow_run_id: UUID,
         entrypoint: str | None = None,
         command: str | None = None,
-        cwd: Path | None = None,
+        cwd: Path | str | None = None,
         env: dict[str, str | None] | None = None,
-        task_status: anyio.abc.TaskStatus[int] | None = None,
+        task_status: anyio.abc.TaskStatus[int] = anyio.TASK_STATUS_IGNORED,
         stream_output: bool = True,
     ) -> anyio.abc.Process | None:
         """
@@ -594,7 +588,9 @@ class Runner:
                     self._submitting_flow_run_ids.add(flow_run_id)
                     flow_run = await self._client.read_flow_run(flow_run_id)
 
-                    process: anyio.abc.Process = await self._runs_task_group.start(
+                    process: (
+                        anyio.abc.Process | Exception
+                    ) = await self._runs_task_group.start(
                         partial(
                             self._submit_run_and_capture_errors,
                             flow_run=flow_run,
@@ -605,8 +601,13 @@ class Runner:
                             stream_output=stream_output,
                         ),
                     )
-                    if task_status:
-                        task_status.started(process.pid)
+                    if isinstance(process, Exception):
+                        return
+
+                    task_status.started(process.pid)
+
+                    if self.heartbeat_seconds is not None:
+                        await self._emit_flow_run_heartbeat(flow_run)
 
                     async with self._flow_run_process_map_lock:
                         # Only add the process to the map if it is still running
@@ -632,15 +633,6 @@ class Runner:
                             jitter_range=0.3,
                         )
                     )
-                    if self.heartbeat_seconds is not None:
-                        tg.start_soon(
-                            partial(
-                                critical_service_loop,
-                                workload=self._emit_flow_run_heartbeats,
-                                interval=self.heartbeat_seconds,
-                                jitter_range=0.3,
-                            )
-                        )
 
                     return process
 
@@ -668,6 +660,9 @@ class Runner:
                 await self._propose_crashed_state(flow_run, msg)
                 raise RuntimeError(msg)
 
+            if self.heartbeat_seconds is not None:
+                await self._emit_flow_run_heartbeat(flow_run)
+
             self._flow_run_process_map[flow_run.id] = ProcessMapEntry(
                 pid=process.pid, flow_run=flow_run
             )
@@ -683,16 +678,6 @@ class Runner:
                     )
                 )
             )
-            if self.heartbeat_seconds is not None:
-                tasks.append(
-                    asyncio.create_task(
-                        critical_service_loop(
-                            workload=self._emit_flow_run_heartbeats,
-                            interval=self.heartbeat_seconds,
-                            jitter_range=0.1,
-                        )
-                    )
-                )
 
             await anyio.to_thread.run_sync(process.join)
 
@@ -768,10 +753,12 @@ class Runner:
     async def _run_process(
         self,
         flow_run: "FlowRun",
-        task_status: anyio.abc.TaskStatus[anyio.abc.Process] | None = None,
+        task_status: anyio.abc.TaskStatus[
+            anyio.abc.Process
+        ] = anyio.TASK_STATUS_IGNORED,
         entrypoint: str | None = None,
         command: str | None = None,
-        cwd: Path | None = None,
+        cwd: Path | str | None = None,
         env: dict[str, str | None] | None = None,
         stream_output: bool = True,
     ) -> anyio.abc.Process:
@@ -951,6 +938,45 @@ class Runner:
                 # process ended right after the check above.
                 return
 
+    def reschedule_current_flow_runs(
+        self,
+    ) -> None:
+        """
+        Reschedules all flow runs that are currently running.
+
+        This should only be called when the runner is shutting down because it kill all
+        child processes and short-circuit the crash detection logic.
+        """
+        self._rescheduling = True
+        # Create a new sync client because this will often run in a separate thread
+        # as part of a signal handler.
+        with get_client(sync_client=True) as client:
+            self._logger.info("Rescheduling flow runs...")
+            for process_info in self._flow_run_process_map.values():
+                flow_run = process_info["flow_run"]
+                run_logger = self._get_flow_run_logger(flow_run)
+                run_logger.info(
+                    "Rescheduling flow run for resubmission in response to SIGTERM"
+                )
+                try:
+                    propose_state_sync(client, AwaitingRetry(), flow_run_id=flow_run.id)
+                    os.kill(process_info["pid"], signal.SIGTERM)
+                    run_logger.info("Rescheduled flow run for resubmission")
+                except ProcessLookupError:
+                    # Process may have already exited
+                    pass
+                except Abort as exc:
+                    run_logger.info(
+                        (
+                            "Aborted submission of flow run. "
+                            f"Server sent an abort signal: {exc}"
+                        ),
+                    )
+                except Exception:
+                    run_logger.exception(
+                        "Failed to reschedule flow run",
+                    )
+
     async def _pause_schedules(self):
         """
         Pauses all deployment schedules.
@@ -1381,7 +1407,7 @@ class Runner:
         task_status: anyio.abc.TaskStatus[anyio.abc.Process | Exception],
         entrypoint: str | None = None,
         command: str | None = None,
-        cwd: Path | None = None,
+        cwd: Path | str | None = None,
         env: dict[str, str | None] | None = None,
         stream_output: bool = True,
     ) -> Union[Optional[int], Exception]:
@@ -1399,12 +1425,12 @@ class Runner:
             )
             status_code = process.returncode
         except Exception as exc:
-            if task_status:
+            if not task_status._future.done():
                 # This flow run was being submitted and did not start successfully
                 run_logger.exception(
                     f"Failed to start process for flow run '{flow_run.id}'."
                 )
-                # Mark the task as started to prevent agent crash
+                # Mark the task as started to prevent runner crash
                 task_status.started(exc)
                 message = f"Flow run process could not be started:\n{exc!r}"
                 await self._propose_crashed_state(flow_run, message)
@@ -1421,7 +1447,7 @@ class Runner:
             async with self._flow_run_process_map_lock:
                 self._flow_run_process_map.pop(flow_run.id, None)
 
-        if status_code != 0:
+        if status_code != 0 and not self._rescheduling:
             await self._propose_crashed_state(
                 flow_run,
                 f"Flow run process exited with non-zero status code {status_code}.",
@@ -1637,6 +1663,15 @@ class Runner:
         if not hasattr(self, "_loops_task_group") or not self._loops_task_group:
             self._loops_task_group: anyio.abc.TaskGroup = anyio.create_task_group()
 
+        if self.heartbeat_seconds is not None:
+            self._heartbeat_task = asyncio.create_task(
+                critical_service_loop(
+                    workload=self._emit_flow_run_heartbeats,
+                    interval=self.heartbeat_seconds,
+                    jitter_range=0.3,
+                )
+            )
+
         self.started = True
         return self
 
@@ -1658,6 +1693,13 @@ class Runner:
         shutil.rmtree(str(self._tmp_dir))
         del self._runs_task_group, self._loops_task_group
 
+        if self._heartbeat_task:
+            self._heartbeat_task.cancel()
+            try:
+                await self._heartbeat_task
+            except asyncio.CancelledError:
+                pass
+
     def __repr__(self) -> str:
         return f"Runner(name={self.name!r})"
 

{prefect-3.2.10.dev4 → prefect-3.2.12.dev1}/src/prefect/server/api/ui/schemas.py

@@ -29,6 +29,7 @@ async def validate_obj(
         ...,
         embed=True,
         alias="schema",
+        validation_alias="schema",
         json_schema_extra={"additionalProperties": True},
     ),
     values: dict[str, Any] = Body(

{prefect-3.2.10.dev4 → prefect-3.2.12.dev1}/src/prefect/utilities/annotations.py

@@ -2,6 +2,8 @@ import warnings
 from operator import itemgetter
 from typing import Any, cast
 
+from pydantic import GetCoreSchemaHandler
+from pydantic_core import core_schema, to_json
 from typing_extensions import Self, TypeVar
 
 T = TypeVar("T", infer_variance=True)
@@ -108,3 +110,44 @@ class NotSet:
     """
     Singleton to distinguish `None` from a value that is not provided by the user.
     """
+
+
+class freeze(BaseAnnotation[T]):
+    """
+    Wrapper for parameters in deployments.
+
+    Indicates that this parameter should be frozen in the UI and not editable
+    when creating flow runs from this deployment.
+
+    Example:
+    ```python
+    @flow
+    def my_flow(customer_id: str):
+        # flow logic
+
+    deployment = my_flow.deploy(parameters={"customer_id": freeze("customer123")})
+    ```
+    """
+
+    def __new__(cls, value: T) -> Self:
+        try:
+            to_json(value)
+        except Exception:
+            raise ValueError("Value must be JSON serializable")
+        return super().__new__(cls, value)
+
+    def unfreeze(self) -> T:
+        """Return the unwrapped value."""
+        return self.unwrap()
+
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls, source: type[Any], handler: GetCoreSchemaHandler
+    ) -> core_schema.CoreSchema:
+        return core_schema.no_info_after_validator_function(
+            cls,  # Use the class itself as the validator
+            core_schema.any_schema(),
+            serialization=core_schema.plain_serializer_function_ser_schema(
+                lambda x: x.unfreeze()  # Serialize by unwrapping the value
+            ),
+        )

{prefect-3.2.10.dev4 → prefect-3.2.12.dev1}/src/prefect/workers/process.py

@@ -205,6 +205,9 @@ class ProcessWorker(
         configuration: ProcessJobConfiguration,
         task_status: Optional[anyio.abc.TaskStatus[int]] = None,
     ) -> ProcessWorkerResult:
+        if task_status is None:
+            task_status = anyio.TASK_STATUS_IGNORED
+
         working_dir_ctx = (
             tempfile.TemporaryDirectory(suffix="prefect")
             if not configuration.working_dir

prefect-3.2.10.dev4/src/prefect/_build_info.py

@@ -1,5 +0,0 @@
-# Generated by versioningit
-__version__ = "3.2.10.dev4"
-__build_date__ = "2025-03-05 08:09:00.166609+00:00"
-__git_commit__ = "99d94359bf5ea0f2f8a61e22c49fb25f8d7c7e33"
-__dirty__ = False