prefect-client 3.4.11.dev4__tar.gz → 3.4.11.dev5__tar.gz

{prefect_client-3.4.11.dev4 → prefect_client-3.4.11.dev5}/PKG-INFO

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

prefect_client-3.4.11.dev5/src/prefect/_build_info.py

@@ -0,0 +1,5 @@
+# Generated by versioningit
+__version__ = "3.4.11.dev5"
+__build_date__ = "2025-07-30 08:09:57.333018+00:00"
+__git_commit__ = "b6f64e41da1f5bd15c47308722b1e674b929efdd"
+__dirty__ = False

{prefect_client-3.4.11.dev4 → prefect_client-3.4.11.dev5}/src/prefect/client/schemas/objects.py

@@ -185,6 +185,9 @@ class StateDetails(PrefectBaseModel):
     task_parameters_id: Optional[UUID] = None
     # Captures the trace_id and span_id of the span where this state was created
     traceparent: Optional[str] = None
+    # The ID of the lease that is currently holding the deployment concurrency slot
+    # for this run.
+    deployment_concurrency_lease_id: Optional[UUID] = None
 
     def to_run_result(
         self, run_type: RunType

{prefect_client-3.4.11.dev4 → prefect_client-3.4.11.dev5}/src/prefect/concurrency/_asyncio.py

@@ -131,27 +131,6 @@ async def aacquire_concurrency_slots_with_lease(
         ) from exc
 
 
-async def amaintain_concurrency_lease(
-    lease_id: UUID,
-    lease_duration: float,
-) -> None:
-    """
-    Maintain a concurrency lease by renewing it after the given interval.
-
-    Args:
-        lease_id: The ID of the lease to maintain.
-        lease_duration: The duration of the lease in seconds.
-    """
-    async with get_client() as client:
-        while True:
-            await asyncio.sleep(  # Renew the lease 3/4 of the way through the lease duration
-                lease_duration * 0.75
-            )
-            await client.renew_concurrency_lease(
-                lease_id=lease_id, lease_duration=lease_duration
-            )
-
-
 async def arelease_concurrency_slots(
     names: list[str], slots: int, occupancy_seconds: float
 ) -> list[MinimalConcurrencyLimitResponse]:

prefect_client-3.4.11.dev5/src/prefect/concurrency/_leases.py

@@ -0,0 +1,137 @@
+import asyncio
+import concurrent.futures
+from contextlib import asynccontextmanager, contextmanager
+from typing import AsyncGenerator, Generator
+from uuid import UUID
+
+from prefect._internal.concurrency.api import create_call
+from prefect._internal.concurrency.cancellation import (
+    AsyncCancelScope,
+    WatcherThreadCancelScope,
+)
+from prefect._internal.concurrency.threads import get_global_loop
+from prefect.client.orchestration import get_client
+from prefect.logging.loggers import get_logger, get_run_logger
+
+
+async def _lease_renewal_loop(
+    lease_id: UUID,
+    lease_duration: float,
+) -> None:
+    """
+    Maintain a concurrency lease by renewing it after the given interval.
+
+    Args:
+        lease_id: The ID of the lease to maintain.
+        lease_duration: The duration of the lease in seconds.
+    """
+    async with get_client() as client:
+        while True:
+            await client.renew_concurrency_lease(
+                lease_id=lease_id, lease_duration=lease_duration
+            )
+            await asyncio.sleep(  # Renew the lease 3/4 of the way through the lease duration
+                lease_duration * 0.75
+            )
+
+
+@contextmanager
+def maintain_concurrency_lease(
+    lease_id: UUID,
+    lease_duration: float,
+    raise_on_lease_renewal_failure: bool = False,
+) -> Generator[None, None, None]:
+    """
+    Maintain a concurrency lease for the given lease ID.
+
+    Args:
+        lease_id: The ID of the lease to maintain.
+        lease_duration: The duration of the lease in seconds.
+        raise_on_lease_renewal_failure: A boolean specifying whether to raise an error if the lease renewal fails.
+    """
+    # Start a loop to renew the lease on the global event loop to avoid blocking the main thread
+    global_loop = get_global_loop()
+    lease_renewal_call = create_call(
+        _lease_renewal_loop,
+        lease_id,
+        lease_duration,
+    )
+    global_loop.submit(lease_renewal_call)
+
+    with WatcherThreadCancelScope() as cancel_scope:
+
+        def handle_lease_renewal_failure(future: concurrent.futures.Future[None]):
+            exc = future.exception()
+            if exc:
+                try:
+                    # Use a run logger if available
+                    logger = get_run_logger()
+                except Exception:
+                    logger = get_logger("concurrency")
+                if raise_on_lease_renewal_failure:
+                    logger.error(
+                        "Concurrency lease renewal failed - slots are no longer reserved. Terminating execution to prevent over-allocation."
+                    )
+                    assert cancel_scope.cancel()
+                else:
+                    logger.warning(
+                        "Concurrency lease renewal failed - slots are no longer reserved. Execution will continue, but concurrency limits may be exceeded."
+                    )
+
+        lease_renewal_call.future.add_done_callback(handle_lease_renewal_failure)
+
+        try:
+            yield
+        finally:
+            # Cancel the lease renewal loop
+            lease_renewal_call.cancel()
+
+
+@asynccontextmanager
+async def amaintain_concurrency_lease(
+    lease_id: UUID,
+    lease_duration: float,
+    raise_on_lease_renewal_failure: bool = False,
+) -> AsyncGenerator[None, None]:
+    """
+    Maintain a concurrency lease for the given lease ID.
+
+    Args:
+        lease_id: The ID of the lease to maintain.
+        lease_duration: The duration of the lease in seconds.
+        raise_on_lease_renewal_failure: A boolean specifying whether to raise an error if the lease renewal fails.
+    """
+    lease_renewal_task = asyncio.create_task(
+        _lease_renewal_loop(lease_id, lease_duration)
+    )
+    with AsyncCancelScope() as cancel_scope:
+
+        def handle_lease_renewal_failure(task: asyncio.Task[None]):
+            exc = task.exception()
+            if exc:
+                try:
+                    # Use a run logger if available
+                    logger = get_run_logger()
+                except Exception:
+                    logger = get_logger("concurrency")
+                if raise_on_lease_renewal_failure:
+                    logger.error(
+                        "Concurrency lease renewal failed - slots are no longer reserved. Terminating execution to prevent over-allocation."
+                    )
+                    cancel_scope.cancel()
+                else:
+                    logger.warning(
+                        "Concurrency lease renewal failed - slots are no longer reserved. Execution will continue, but concurrency limits may be exceeded."
+                    )
+
+        # Add a callback to stop execution if the lease renewal fails and strict is True
+        lease_renewal_task.add_done_callback(handle_lease_renewal_failure)
+        try:
+            yield
+        finally:
+            lease_renewal_task.cancel()
+            try:
+                await lease_renewal_task
+            except (asyncio.CancelledError, Exception):
+                # Handling for errors will be done in the callback
+                pass

{prefect_client-3.4.11.dev4 → prefect_client-3.4.11.dev5}/src/prefect/concurrency/asyncio.py

@@ -1,12 +1,10 @@
-import asyncio
 from collections.abc import AsyncGenerator
 from contextlib import asynccontextmanager
 from typing import Optional, Union
 
 import anyio
 
-from prefect._internal.concurrency.cancellation import AsyncCancelScope
-from prefect.logging.loggers import get_logger, get_run_logger
+from prefect.concurrency._leases import amaintain_concurrency_lease
 
 from ._asyncio import (
     AcquireConcurrencySlotTimeoutError as AcquireConcurrencySlotTimeoutError,
@@ -15,7 +13,6 @@ from ._asyncio import ConcurrencySlotAcquisitionError as ConcurrencySlotAcquisit
 from ._asyncio import (
     aacquire_concurrency_slots,
     aacquire_concurrency_slots_with_lease,
-    amaintain_concurrency_lease,
     arelease_concurrency_slots_with_lease,
 )
 from ._events import (
@@ -81,43 +78,12 @@ async def concurrency(
     )
     emitted_events = emit_concurrency_acquisition_events(response.limits, occupy)
 
-    lease_renewal_task = asyncio.create_task(
-        amaintain_concurrency_lease(response.lease_id, lease_duration)
-    )
-
     try:
-        with AsyncCancelScope() as cancel_scope:
-
-            def handle_lease_renewal_failure(task: asyncio.Task[None]):
-                exc = task.exception()
-                if exc:
-                    try:
-                        # Use a run logger if available
-                        logger = get_run_logger()
-                    except Exception:
-                        logger = get_logger("concurrency")
-                    if strict:
-                        logger.error(
-                            "Concurrency lease renewal failed - slots are no longer reserved. Terminating execution to prevent over-allocation."
-                        )
-                        cancel_scope.cancel()
-                    else:
-                        logger.warning(
-                            "Concurrency lease renewal failed - slots are no longer reserved. Execution will continue, but concurrency limits may be exceeded."
-                        )
-
-            # Add a callback to stop execution if the lease renewal fails and strict is True
-            lease_renewal_task.add_done_callback(handle_lease_renewal_failure)
-
+        async with amaintain_concurrency_lease(
+            response.lease_id, lease_duration, raise_on_lease_renewal_failure=strict
+        ):
             yield
     finally:
-        lease_renewal_task.cancel()
-        try:
-            await lease_renewal_task
-        except (asyncio.CancelledError, Exception):
-            # Handling for errors will be done in the callback
-            pass
-
         try:
             await arelease_concurrency_slots_with_lease(
                 lease_id=response.lease_id,

{prefect_client-3.4.11.dev4 → prefect_client-3.4.11.dev5}/src/prefect/concurrency/sync.py

@@ -1,4 +1,3 @@
-import concurrent.futures
 from collections.abc import Generator
 from contextlib import contextmanager
 from typing import Optional, TypeVar, Union
@@ -6,22 +5,16 @@ from uuid import UUID
 
 from typing_extensions import Literal
 
-from prefect._internal.concurrency.api import create_call
-from prefect._internal.concurrency.cancellation import (
-    WatcherThreadCancelScope,
-)
-from prefect._internal.concurrency.threads import get_global_loop
 from prefect.client.schemas.responses import (
     ConcurrencyLimitWithLeaseResponse,
     MinimalConcurrencyLimitResponse,
 )
-from prefect.logging.loggers import get_logger, get_run_logger
+from prefect.concurrency._leases import maintain_concurrency_lease
 from prefect.utilities.asyncutils import run_coro_as_sync
 
 from ._asyncio import (
     aacquire_concurrency_slots,
     aacquire_concurrency_slots_with_lease,
-    amaintain_concurrency_lease,
     arelease_concurrency_slots_with_lease,
 )
 from ._events import (
@@ -126,42 +119,14 @@ def concurrency(
         acquisition_response.limits, occupy
     )
 
-    # Start a loop to renew the lease on the global event loop to avoid blocking the main thread
-    global_loop = get_global_loop()
-    lease_renewal_call = create_call(
-        amaintain_concurrency_lease,
-        acquisition_response.lease_id,
-        lease_duration,
-    )
-    global_loop.submit(lease_renewal_call)
-
     try:
-        with WatcherThreadCancelScope() as cancel_scope:
-
-            def handle_lease_renewal_failure(future: concurrent.futures.Future[None]):
-                exc = future.exception()
-                if exc:
-                    try:
-                        # Use a run logger if available
-                        logger = get_run_logger()
-                    except Exception:
-                        logger = get_logger("concurrency")
-                    if strict:
-                        logger.error(
-                            "Concurrency lease renewal failed - slots are no longer reserved. Terminating execution to prevent over-allocation."
-                        )
-                        assert cancel_scope.cancel()
-                    else:
-                        logger.warning(
-                            "Concurrency lease renewal failed - slots are no longer reserved. Execution will continue, but concurrency limits may be exceeded."
-                        )
-
-            lease_renewal_call.future.add_done_callback(handle_lease_renewal_failure)
+        with maintain_concurrency_lease(
+            acquisition_response.lease_id,
+            lease_duration,
+            raise_on_lease_renewal_failure=strict,
+        ):
             yield
     finally:
-        # Cancel the lease renewal loop
-        lease_renewal_call.cancel()
-
         _release_concurrency_slots_with_lease(acquisition_response.lease_id)
         emit_concurrency_release_events(
             acquisition_response.limits, occupy, emitted_events

{prefect_client-3.4.11.dev4 → prefect_client-3.4.11.dev5}/src/prefect/flow_engine.py

@@ -6,7 +6,13 @@ import multiprocessing
 import multiprocessing.context
 import os
 import time
-from contextlib import ExitStack, asynccontextmanager, contextmanager, nullcontext
+from contextlib import (
+    AsyncExitStack,
+    ExitStack,
+    asynccontextmanager,
+    contextmanager,
+    nullcontext,
+)
 from dataclasses import dataclass, field
 from functools import wraps
 from typing import (
@@ -35,7 +41,11 @@ from prefect.client.orchestration import PrefectClient, SyncPrefectClient, get_c
 from prefect.client.schemas import FlowRun, TaskRun
 from prefect.client.schemas.filters import FlowRunFilter
 from prefect.client.schemas.sorting import FlowRunSort
+from prefect.concurrency.asyncio import (
+    amaintain_concurrency_lease,
+)
 from prefect.concurrency.context import ConcurrencyContext
+from prefect.concurrency.sync import maintain_concurrency_lease
 from prefect.concurrency.v1.context import ConcurrencyContext as ConcurrencyContextV1
 from prefect.context import (
     AsyncClientContext,
@@ -618,6 +628,13 @@ class FlowRunEngine(BaseFlowRunEngine[P, R]):
             )
             stack.enter_context(ConcurrencyContextV1())
             stack.enter_context(ConcurrencyContext())
+            if lease_id := self.state.state_details.deployment_concurrency_lease_id:
+                stack.enter_context(
+                    maintain_concurrency_lease(
+                        lease_id,
+                        300,
+                    )
+                )
 
             # set the logger to the flow run logger
 
@@ -1157,7 +1174,7 @@ class AsyncFlowRunEngine(BaseFlowRunEngine[P, R]):
         self.flow_run = await client.read_flow_run(self.flow_run.id)
         log_prints = should_log_prints(self.flow)
 
-        with ExitStack() as stack:
+        async with AsyncExitStack() as stack:
             # TODO: Explore closing task runner before completing the flow to
             # wait for futures to complete
             stack.enter_context(capture_sigterm())
@@ -1182,6 +1199,13 @@ class AsyncFlowRunEngine(BaseFlowRunEngine[P, R]):
             )
             stack.enter_context(ConcurrencyContextV1())
             stack.enter_context(ConcurrencyContext())
+            if lease_id := self.state.state_details.deployment_concurrency_lease_id:
+                await stack.enter_async_context(
+                    amaintain_concurrency_lease(
+                        lease_id,
+                        300,
+                    )
+                )
 
             # set the logger to the flow run logger
             self.logger: "logging.Logger" = flow_run_logger(

{prefect_client-3.4.11.dev4 → prefect_client-3.4.11.dev5}/src/prefect/server/api/flow_runs.py

@@ -378,10 +378,10 @@ async def read_flow_run_graph_v2(
 
 @router.post("/{id:uuid}/resume")
 async def resume_flow_run(
+    response: Response,
     flow_run_id: UUID = Path(..., description="The flow run id", alias="id"),
     db: PrefectDBInterface = Depends(provide_database_interface),
     run_input: Optional[dict[str, Any]] = Body(default=None, embed=True),
-    response: Response = None,
     flow_policy: type[FlowRunOrchestrationPolicy] = Depends(
         orchestration_dependencies.provide_flow_policy
     ),
@@ -392,6 +392,7 @@ async def resume_flow_run(
         orchestration_dependencies.provide_flow_orchestration_parameters
     ),
     api_version: str = Depends(dependencies.provide_request_api_version),
+    client_version: Optional[str] = Depends(dependencies.get_prefect_client_version),
 ) -> OrchestrationResult:
     """
     Resume a paused flow run.
@@ -488,6 +489,7 @@ async def resume_flow_run(
                 ),
                 flow_policy=flow_policy,
                 orchestration_parameters=orchestration_parameters,
+                client_version=client_version,
             )
         else:
             orchestration_result = await models.flow_runs.set_flow_run_state(
@@ -496,6 +498,7 @@ async def resume_flow_run(
                 state=schemas.states.Running(),
                 flow_policy=flow_policy,
                 orchestration_parameters=orchestration_parameters,
+                client_version=client_version,
             )
 
         if (
@@ -601,6 +604,7 @@ async def delete_flow_run_logs(db: PrefectDBInterface, flow_run_id: UUID) -> Non
 
 @router.post("/{id:uuid}/set_state")
 async def set_flow_run_state(
+    response: Response,
     flow_run_id: UUID = Path(..., description="The flow run id", alias="id"),
     state: schemas.actions.StateCreate = Body(..., description="The intended state."),
     force: bool = Body(
@@ -617,8 +621,8 @@ async def set_flow_run_state(
     orchestration_parameters: Dict[str, Any] = Depends(
         orchestration_dependencies.provide_flow_orchestration_parameters
     ),
-    response: Response = None,
     api_version: str = Depends(dependencies.provide_request_api_version),
+    client_version: Optional[str] = Depends(dependencies.get_prefect_client_version),
 ) -> OrchestrationResult:
     """Set a flow run state, invoking any orchestration rules."""
 
@@ -639,6 +643,7 @@ async def set_flow_run_state(
             force=force,
             flow_policy=flow_policy,
             orchestration_parameters=orchestration_parameters,
+            client_version=client_version,
         )
 
     # set the 201 if a new state was created

prefect_client-3.4.11.dev4/src/prefect/_build_info.py

@@ -1,5 +0,0 @@
-# Generated by versioningit
-__version__ = "3.4.11.dev4"
-__build_date__ = "2025-07-29 08:09:34.883121+00:00"
-__git_commit__ = "55c579d72bb116cda2ed885f89d89cb20dd99462"
-__dirty__ = False