prefect-client 3.2.11__tar.gz → 3.2.13__tar.gz

{prefect_client-3.2.11 → prefect_client-3.2.13}/.gitignore

@@ -7,8 +7,9 @@ __pycache__/
 build/
 dist/
 sdist/
-# We likely ought to eventually include uv.lock
-uv.lock
+
+# uv (consider committing later)
+src/integrations/**/uv.lock
 
 # Build metadata
 src/prefect/_build_info.py
@@ -75,6 +76,7 @@ prefect.yaml
 
 # Deployment recipes
 !src/prefect/deployments/recipes/*/**
+!src/prefect/deployments/templates/prefect.yaml
 
 # For development doc server if link
 libcairo.2.dylib

{prefect_client-3.2.11 → prefect_client-3.2.13}/PKG-INFO

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

prefect_client-3.2.13/src/prefect/_build_info.py

@@ -0,0 +1,5 @@
+# Generated by versioningit
+__version__ = "3.2.13"
+__build_date__ = "2025-03-14 20:36:04.139050+00:00"
+__git_commit__ = "1280029757bdefaca553d85a008f9b82da0c697a"
+__dirty__ = False

{prefect_client-3.2.11 → prefect_client-3.2.13}/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_client-3.2.11 → prefect_client-3.2.13}/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_client-3.2.11 → prefect_client-3.2.13}/src/prefect/flows.py

@@ -1046,10 +1046,9 @@ class Flow(Generic[P, R]):
         if not name:
             name = self.name
         else:
-            # Handling for my_flow.serve(__file__)
-            # Will set name to name of file where my_flow.serve() without the extension
-            # Non filepath strings will pass through unchanged
-            name = Path(name).stem
+            # Only strip extension if it is a file path
+            if (p := Path(name)).is_file():
+                name = p.stem
 
         runner = Runner(name=name, pause_on_shutdown=pause_on_shutdown, limit=limit)
         deployment_id = runner.add_flow(
@@ -1490,10 +1489,10 @@ class Flow(Generic[P, R]):
             _sla=_sla,
         )
 
-        if TYPE_CHECKING:
-            assert inspect.isawaitable(to_deployment_coro)
-
-        deployment = await to_deployment_coro
+        if inspect.isawaitable(to_deployment_coro):
+            deployment = await to_deployment_coro
+        else:
+            deployment = to_deployment_coro
 
         from prefect.deployments.runner import deploy
 

{prefect_client-3.2.11 → prefect_client-3.2.13}/src/prefect/logging/loggers.py

@@ -146,10 +146,11 @@ def get_run_logger(
             **kwargs,
         )
     elif (
-        get_logger("prefect.flow_run").disabled
-        and get_logger("prefect.task_run").disabled
+        get_logger("prefect.flow_runs").disabled
+        and get_logger("prefect.task_runs").disabled
     ):
         logger = logging.getLogger("null")
+        logger.disabled = True
     else:
         raise MissingContextError("There is no active flow or task run context.")
 
@@ -280,9 +281,9 @@ def disable_run_logger():
     """
     Gets both `prefect.flow_run` and `prefect.task_run` and disables them
     within the context manager. Upon exiting the context manager, both loggers
-    are returned to its original state.
+    are returned to their original state.
     """
-    with disable_logger("prefect.flow_run"), disable_logger("prefect.task_run"):
+    with disable_logger("prefect.flow_runs"), disable_logger("prefect.task_runs"):
         yield
 
 

{prefect_client-3.2.11 → prefect_client-3.2.13}/src/prefect/server/api/flow_runs.py

@@ -313,7 +313,7 @@ async def read_flow_run(
         )
 
 
-@router.get("/{id}/graph")
+@router.get("/{id}/graph", tags=["Flow Run Graph"])
 async def read_flow_run_graph_v1(
     flow_run_id: UUID = Path(..., description="The flow run id", alias="id"),
     db: PrefectDBInterface = Depends(provide_database_interface),
@@ -327,7 +327,7 @@ async def read_flow_run_graph_v1(
         )
 
 
-@router.get("/{id:uuid}/graph-v2")
+@router.get("/{id:uuid}/graph-v2", tags=["Flow Run Graph"])
 async def read_flow_run_graph_v2(
     flow_run_id: UUID = Path(..., description="The flow run id", alias="id"),
     since: DateTime = Query(

{prefect_client-3.2.11 → prefect_client-3.2.13}/src/prefect/server/api/server.py

@@ -294,12 +294,16 @@ async def prefect_object_not_found_exception_handler(
     )
 
 
+API_APP_CACHE: dict[tuple[str, str | None], FastAPI] = {}
+
+
 def create_api_app(
     dependencies: list[Any] | None = None,
     health_check_path: str = "/health",
     version_check_path: str = "/version",
     fast_api_app_kwargs: dict[str, Any] | None = None,
     final: bool = False,
+    ignore_cache: bool = False,
 ) -> FastAPI:
     """
     Create a FastAPI app that includes the Prefect REST API
@@ -310,10 +314,20 @@ def create_api_app(
         fast_api_app_kwargs: kwargs to pass to the FastAPI constructor
         final: whether this will be the last instance of the Prefect server to be
             created in this process, so that additional optimizations may be applied
+        ignore_cache: if set, a new app will be created even if the settings and fast_api_app_kwargs match
+            an existing app in the cache
 
     Returns:
         a FastAPI app that serves the Prefect REST API
     """
+    cache_key = (
+        prefect.settings.get_current_settings().hash_key(),
+        hash_objects(fast_api_app_kwargs) if fast_api_app_kwargs else None,
+    )
+
+    if cache_key in API_APP_CACHE and not ignore_cache:
+        return API_APP_CACHE[cache_key]
+
     fast_api_app_kwargs = fast_api_app_kwargs or {}
     api_app = FastAPI(title=API_TITLE, **fast_api_app_kwargs)
     api_app.add_middleware(GZipMiddleware)
@@ -389,6 +403,8 @@ def create_api_app(
                 )
             return await call_next(request)
 
+    API_APP_CACHE[cache_key] = api_app
+
     return api_app
 
 
@@ -655,6 +671,7 @@ def create_app(
             }
         },
         final=final,
+        ignore_cache=ignore_cache,
     )
     ui_app = create_ui_app(ephemeral)
 

{prefect_client-3.2.11 → prefect_client-3.2.13}/src/prefect/task_engine.py

@@ -24,6 +24,7 @@ from typing import (
     Type,
     TypeVar,
     Union,
+    overload,
 )
 from uuid import UUID
 
@@ -1527,6 +1528,32 @@ async def run_generator_task_async(
         await engine.result()
 
 
+@overload
+def run_task(
+    task: "Task[P, R]",
+    task_run_id: Optional[UUID] = None,
+    task_run: Optional[TaskRun] = None,
+    parameters: Optional[dict[str, Any]] = None,
+    wait_for: Optional["OneOrManyFutureOrResult[Any]"] = None,
+    return_type: Literal["state"] = "state",
+    dependencies: Optional[dict[str, set[TaskRunInput]]] = None,
+    context: Optional[dict[str, Any]] = None,
+) -> State[R]: ...
+
+
+@overload
+def run_task(
+    task: "Task[P, R]",
+    task_run_id: Optional[UUID] = None,
+    task_run: Optional[TaskRun] = None,
+    parameters: Optional[dict[str, Any]] = None,
+    wait_for: Optional["OneOrManyFutureOrResult[Any]"] = None,
+    return_type: Literal["result"] = "result",
+    dependencies: Optional[dict[str, set[TaskRunInput]]] = None,
+    context: Optional[dict[str, Any]] = None,
+) -> R: ...
+
+
 def run_task(
     task: "Task[P, Union[R, Coroutine[Any, Any, R]]]",
     task_run_id: Optional[UUID] = None,

{prefect_client-3.2.11 → prefect_client-3.2.13}/src/prefect/tasks.py

@@ -1426,6 +1426,8 @@ class Task(Generic[P, R]):
         else:
             return futures
 
+    # Background task methods
+
     def apply_async(
         self,
         args: Optional[tuple[Any, ...]] = None,

{prefect_client-3.2.11 → prefect_client-3.2.13}/src/prefect/telemetry/run_telemetry.py

@@ -16,6 +16,7 @@ from opentelemetry.trace import (
 from typing_extensions import TypeAlias
 
 import prefect
+import prefect.settings
 from prefect.client.orchestration import PrefectClient, SyncPrefectClient
 from prefect.client.schemas import FlowRun, TaskRun
 from prefect.client.schemas.objects import State
@@ -50,15 +51,19 @@ class RunTelemetry:
         default_factory=lambda: get_tracer("prefect", prefect.__version__)
     )
     span: Span | None = None
+    _enabled: bool = field(
+        default_factory=lambda: prefect.settings.get_current_settings().cloud.enable_orchestration_telemetry
+    )
 
     async def async_start_span(
         self,
         run: FlowOrTaskRun,
         client: PrefectClient,
         parameters: dict[str, Any] | None = None,
-    ) -> Span:
+    ) -> Span | None:
+        if not self._enabled:
+            return None
         traceparent, span = self._start_span(run, parameters)
-
         if self._run_type(run) == "flow" and traceparent:
             # Only explicitly update labels if the run is a flow as task runs
             # are updated via events.
@@ -73,7 +78,10 @@ class RunTelemetry:
         run: FlowOrTaskRun,
         client: SyncPrefectClient,
         parameters: dict[str, Any] | None = None,
-    ) -> Span:
+    ) -> Span | None:
+        if not self._enabled:
+            return None
+
         traceparent, span = self._start_span(run, parameters)
 
         if self._run_type(run) == "flow" and traceparent:

{prefect_client-3.2.11 → prefect_client-3.2.13}/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
+            ),
+        )