prefect-client 3.4.24.dev4__tar.gz → 3.4.25.dev1__tar.gz

{prefect_client-3.4.24.dev4 → prefect_client-3.4.25.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prefect-client
-Version: 3.4.24.dev4
+Version: 3.4.25.dev1
 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.25.dev1/src/prefect/_build_info.py

@@ -0,0 +1,5 @@
+# Generated by versioningit
+__version__ = "3.4.25.dev1"
+__build_date__ = "2025-10-17 08:09:39.529679+00:00"
+__git_commit__ = "081cbf6096562f05845ddbbdea13fac5201f2dcc"
+__dirty__ = False

{prefect_client-3.4.24.dev4 → prefect_client-3.4.25.dev1}/src/prefect/deployments/runner.py

@@ -861,7 +861,7 @@ class RunnerDeployment(BaseModel):
             concurrency_options = None
 
         deployment = cls(
-            name=Path(name).stem,
+            name=name,
             flow_name=flow_name or flow.name,
             schedules=constructed_schedules,
             concurrency_limit=concurrency_limit,
@@ -982,7 +982,7 @@ class RunnerDeployment(BaseModel):
             )
 
         deployment = cls(
-            name=Path(name).stem,
+            name=name,
             flow_name=flow_name or flow.name,
             schedules=constructed_schedules,
             concurrency_limit=concurrency_limit,
@@ -1106,7 +1106,7 @@ class RunnerDeployment(BaseModel):
             flow = load_flow_from_entrypoint(full_entrypoint)
 
         deployment = cls(
-            name=Path(name).stem,
+            name=name,
             flow_name=flow_name or flow.name,
             schedules=constructed_schedules,
             concurrency_limit=concurrency_limit,

{prefect_client-3.4.24.dev4 → prefect_client-3.4.25.dev1}/src/prefect/flow_engine.py

@@ -731,9 +731,16 @@ class FlowRunEngine(BaseFlowRunEngine[P, R]):
                     # Do not capture generator exits as crashes
                     raise
                 except BaseException as exc:
-                    # BaseExceptions are caught and handled as crashes
-                    self.handle_crash(exc)
-                    raise
+                    # We don't want to crash a flow run if the user code finished executing
+                    if self.flow_run.state and not self.flow_run.state.is_final():
+                        # BaseExceptions are caught and handled as crashes
+                        self.handle_crash(exc)
+                        raise
+                    else:
+                        self.logger.debug(
+                            "BaseException was raised after user code finished executing",
+                            exc_info=exc,
+                        )
                 finally:
                     # If debugging, use the more complete `repr` than the usual `str` description
                     display_state = (
@@ -1305,9 +1312,16 @@ class AsyncFlowRunEngine(BaseFlowRunEngine[P, R]):
                     # Do not capture generator exits as crashes
                     raise
                 except BaseException as exc:
-                    # BaseExceptions are caught and handled as crashes
-                    await self.handle_crash(exc)
-                    raise
+                    # We don't want to crash a flow run if the user code finished executing
+                    if self.flow_run.state and not self.flow_run.state.is_final():
+                        # BaseExceptions are caught and handled as crashes
+                        await self.handle_crash(exc)
+                        raise
+                    else:
+                        self.logger.debug(
+                            "BaseException was raised after user code finished executing",
+                            exc_info=exc,
+                        )
                 finally:
                     # If debugging, use the more complete `repr` than the usual `str` description
                     display_state = (

{prefect_client-3.4.24.dev4 → prefect_client-3.4.25.dev1}/src/prefect/runner/runner.py

@@ -1373,10 +1373,19 @@ class Runner:
                 f"Flow run process exited with non-zero status code {exit_code}.",
             )
 
-        api_flow_run = await self._client.read_flow_run(flow_run_id=flow_run.id)
-        terminal_state = api_flow_run.state
-        if terminal_state and terminal_state.is_crashed():
-            await self._run_on_crashed_hooks(flow_run=flow_run, state=terminal_state)
+        try:
+            api_flow_run = await self._client.read_flow_run(flow_run_id=flow_run.id)
+            terminal_state = api_flow_run.state
+            if terminal_state and terminal_state.is_crashed():
+                await self._run_on_crashed_hooks(
+                    flow_run=flow_run, state=terminal_state
+                )
+        except ObjectNotFound:
+            # Flow run was deleted - log it but don't crash the runner
+            run_logger = self._get_flow_run_logger(flow_run)
+            run_logger.debug(
+                f"Flow run '{flow_run.id}' was deleted before final state could be checked"
+            )
 
         return exit_code
 
@@ -1444,6 +1453,11 @@ class Runner:
         except Abort:
             # Flow run already marked as failed
             pass
+        except ObjectNotFound:
+            # Flow run was deleted - log it but don't crash the runner
+            run_logger.debug(
+                f"Flow run '{flow_run.id}' was deleted before state could be updated"
+            )
         except Exception:
             run_logger.exception(f"Failed to update state of flow run '{flow_run.id}'")
         else:
@@ -1468,7 +1482,14 @@ class Runner:
             )
             return
 
-        await self._client.set_flow_run_state(flow_run.id, state, force=True)
+        try:
+            await self._client.set_flow_run_state(flow_run.id, state, force=True)
+        except ObjectNotFound:
+            # Flow run was deleted - log it but don't crash the runner
+            run_logger = self._get_flow_run_logger(flow_run)
+            run_logger.debug(
+                f"Flow run '{flow_run.id}' was deleted before it could be marked as cancelled"
+            )
 
     async def _run_on_cancellation_hooks(
         self,

{prefect_client-3.4.24.dev4 → prefect_client-3.4.25.dev1}/src/prefect/server/api/concurrency_limits_v2.py

@@ -411,13 +411,24 @@ async def renew_concurrency_lease(
     ),
 ) -> None:
     lease_storage = get_concurrency_lease_storage()
-    lease = await lease_storage.read_lease(lease_id)
-    if not lease:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND, detail="Lease not found"
-        )
 
-    await lease_storage.renew_lease(
+    # Atomically renew the lease (checks existence and updates index in single operation)
+    renewed = await lease_storage.renew_lease(
         lease_id=lease_id,
         ttl=timedelta(seconds=lease_duration),
     )
+
+    # Handle the three possible return values:
+    # - True: lease successfully renewed
+    # - False: lease not found or expired
+    # - None: legacy implementation (check lease existence to determine success)
+    lease = None
+    if renewed is None:
+        # Legacy implementation returned None - check if lease actually exists
+        lease = await lease_storage.read_lease(lease_id)
+
+    if renewed is False or (renewed is None and lease is None):
+        raise HTTPException(
+            status_code=status.HTTP_410_GONE,
+            detail="Lease not found - it may have expired or been revoked",
+        )

{prefect_client-3.4.24.dev4 → prefect_client-3.4.25.dev1}/src/prefect/settings/base.py

@@ -268,7 +268,7 @@ def _to_environment_variable_value(
     value: list[object] | set[object] | tuple[object] | Any,
 ) -> str:
     if isinstance(value, (list, set, tuple)):
-        return ",".join(str(v) for v in value)
+        return ",".join(str(v) for v in sorted(value, key=str))
     if isinstance(value, dict):
         return json.dumps(value)
     return str(value)

{prefect_client-3.4.24.dev4 → prefect_client-3.4.25.dev1}/src/prefect/states.py

@@ -14,6 +14,7 @@ import httpx
 from opentelemetry import propagate
 from typing_extensions import TypeGuard
 
+from prefect._internal.compatibility.async_dispatch import async_dispatch
 from prefect.client.schemas.objects import State, StateDetails, StateType
 from prefect.exceptions import (
     CancelledRun,
@@ -28,7 +29,6 @@ from prefect.exceptions import (
 from prefect.logging.loggers import get_logger, get_run_logger
 from prefect.types._datetime import now
 from prefect.utilities.annotations import BaseAnnotation
-from prefect.utilities.asyncutils import sync_compatible
 from prefect.utilities.collections import ensure_iterable
 
 if TYPE_CHECKING:
@@ -154,7 +154,7 @@ async def _get_state_result(
     if raise_on_failure and (
         state.is_crashed() or state.is_failed() or state.is_cancelled()
     ):
-        raise await get_state_exception(state)
+        raise await aget_state_exception(state)
 
     if isinstance(state.data, ResultRecordMetadata):
         result = await _get_state_result_data_with_retries(
@@ -165,7 +165,7 @@ async def _get_state_result(
 
     elif state.data is None:
         if state.is_failed() or state.is_crashed() or state.is_cancelled():
-            return await get_state_exception(state)
+            return await aget_state_exception(state)
         else:
             raise MissingResult(
                 "State data is missing. "
@@ -442,9 +442,10 @@ async def return_value_to_state(
         return Completed(data=result_record)
 
 
-@sync_compatible
-async def get_state_exception(state: State) -> BaseException:
+async def aget_state_exception(state: State) -> BaseException:
     """
+    Get the exception from a state asynchronously.
+
     If not given a FAILED or CRASHED state, this raise a value error.
 
     If the state result is a state, its exception will be returned.
@@ -507,13 +508,114 @@ async def get_state_exception(state: State) -> BaseException:
 
     elif isinstance(result, State):
         # Return the exception from the inner state
-        return await get_state_exception(result)
+        return await aget_state_exception(result)
+
+    elif is_state_iterable(result):
+        # Return the first failure
+        for state in result:
+            if state.is_failed() or state.is_crashed() or state.is_cancelled():
+                return await aget_state_exception(state)
+
+        raise ValueError(
+            "Failed state result was an iterable of states but none were failed."
+        )
+
+    else:
+        raise TypeError(
+            f"Unexpected result for failed state: {result!r} —— "
+            f"{type(result).__name__} cannot be resolved into an exception"
+        )
+
+
+@async_dispatch(aget_state_exception)
+def get_state_exception(state: State) -> BaseException:
+    """
+    Get the exception from a state.
+
+    If not given a FAILED or CRASHED state, this raise a value error.
+
+    If the state result is a state, its exception will be returned.
+
+    If the state result is an iterable of states, the exception of the first failure
+    will be returned.
+
+    If the state result is a string, a wrapper exception will be returned with the
+    string as the message.
+
+    If the state result is null, a wrapper exception will be returned with the state
+    message attached.
+
+    If the state result is not of a known type, a `TypeError` will be returned.
+
+    When a wrapper exception is returned, the type will be:
+        - `FailedRun` if the state type is FAILED.
+        - `CrashedRun` if the state type is CRASHED.
+        - `CancelledRun` if the state type is CANCELLED.
+    """
+    from prefect._result_records import (
+        ResultRecord,
+        ResultRecordMetadata,
+    )
+    from prefect.results import ResultStore, resolve_result_storage
+
+    if state.is_failed():
+        wrapper = FailedRun
+        default_message = "Run failed."
+    elif state.is_crashed():
+        wrapper = CrashedRun
+        default_message = "Run crashed."
+    elif state.is_cancelled():
+        wrapper = CancelledRun
+        default_message = "Run cancelled."
+    else:
+        raise ValueError(f"Expected failed or crashed state got {state!r}.")
+
+    if isinstance(state.data, ResultRecord):
+        result = state.data.result
+    elif isinstance(state.data, ResultRecordMetadata):
+        # Inline sync version of _from_metadata
+        metadata = state.data
+        if metadata.storage_block_id is None:
+            storage_block = None
+        else:
+            storage_block = resolve_result_storage(
+                metadata.storage_block_id, _sync=True
+            )
+        store = ResultStore(
+            result_storage=storage_block, serializer=metadata.serializer
+        )
+        if metadata.storage_key is None:
+            raise ValueError(
+                "storage_key is required to hydrate a result record from metadata"
+            )
+        record = store.read(metadata.storage_key)
+        result = record.result
+    elif state.data is None:
+        result = None
+    else:
+        result = state.data
+
+    if result is None:
+        return wrapper(state.message or default_message)
+
+    if isinstance(result, Exception):
+        return result
+
+    elif isinstance(result, BaseException):
+        return result
+
+    elif isinstance(result, str):
+        return wrapper(result)
+
+    elif isinstance(result, State):
+        # Return the exception from the inner state
+        return get_state_exception(result)
 
     elif is_state_iterable(result):
         # Return the first failure
         for state in result:
             if state.is_failed() or state.is_crashed() or state.is_cancelled():
-                return await get_state_exception(state)
+                return get_state_exception(state)
 
         raise ValueError(
             "Failed state result was an iterable of states but none were failed."
@@ -526,15 +628,25 @@ async def get_state_exception(state: State) -> BaseException:
         )
 
 
-@sync_compatible
-async def raise_state_exception(state: State) -> None:
+async def araise_state_exception(state: State) -> None:
+    """
+    Given a FAILED or CRASHED state, raise the contained exception asynchronously.
+    """
+    if not (state.is_failed() or state.is_crashed() or state.is_cancelled()):
+        return None
+
+    raise await aget_state_exception(state)
+
+
+@async_dispatch(araise_state_exception)
+def raise_state_exception(state: State) -> None:
     """
     Given a FAILED or CRASHED state, raise the contained exception.
     """
     if not (state.is_failed() or state.is_crashed() or state.is_cancelled()):
         return None
 
-    raise await get_state_exception(state)
+    raise get_state_exception(state)
 
 
 def is_state_iterable(obj: Any) -> TypeGuard[Iterable[State]]:

{prefect_client-3.4.24.dev4 → prefect_client-3.4.25.dev1}/src/prefect/workers/base.py

@@ -1334,10 +1334,20 @@ class BaseWorker(abc.ABC, Generic[C, V, R]):
     def _release_limit_slot(self, flow_run_id: UUID) -> None:
         """
         Frees up a slot taken by the given flow run id.
+
+        This method gracefully handles cases where the slot has already been released
+        to prevent worker crashes from double-release scenarios.
         """
         if self._limiter:
-            self._limiter.release_on_behalf_of(flow_run_id)
-            self._logger.debug("Limit slot released for flow run '%s'", flow_run_id)
+            try:
+                self._limiter.release_on_behalf_of(flow_run_id)
+                self._logger.debug("Limit slot released for flow run '%s'", flow_run_id)
+            except RuntimeError:
+                # Slot was already released - this can happen in certain error paths
+                # where multiple cleanup attempts occur. Log it but don't crash.
+                self._logger.debug(
+                    "Limit slot for flow run '%s' was already released", flow_run_id
+                )
 
     def get_status(self) -> dict[str, Any]:
         """
@@ -1464,6 +1474,11 @@ class BaseWorker(abc.ABC, Generic[C, V, R]):
         except Abort:
             # Flow run already marked as failed
             pass
+        except ObjectNotFound:
+            # Flow run was deleted - log it but don't crash the worker
+            run_logger.debug(
+                f"Flow run '{flow_run.id}' was deleted before state could be updated"
+            )
         except Exception:
             run_logger.exception(f"Failed to update state of flow run '{flow_run.id}'")
         else:
@@ -1486,7 +1501,14 @@ class BaseWorker(abc.ABC, Generic[C, V, R]):
             # does not need to explicitly set the type
             state = Cancelled(**state_updates)
 
-        await self.client.set_flow_run_state(flow_run.id, state, force=True)
+        try:
+            await self.client.set_flow_run_state(flow_run.id, state, force=True)
+        except ObjectNotFound:
+            # Flow run was deleted - log it but don't crash the worker
+            run_logger = self.get_flow_run_logger(flow_run)
+            run_logger.debug(
+                f"Flow run '{flow_run.id}' was deleted before it could be marked as cancelled"
+            )
 
         # Do not remove the flow run from the cancelling set immediately because
         # the API caches responses for the `read_flow_runs` and we do not want to

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

@@ -1,5 +0,0 @@
-# Generated by versioningit
-__version__ = "3.4.24.dev4"
-__build_date__ = "2025-10-15 08:09:24.517909+00:00"
-__git_commit__ = "4d7bea0be73f046c90a05a964312a8e86261e17d"
-__dirty__ = False