prefect 3.4.24.dev5__tar.gz → 3.4.25.dev2__tar.gz

{prefect-3.4.24.dev5 → prefect-3.4.25.dev2}/PKG-INFO

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

prefect-3.4.25.dev2/src/prefect/_build_info.py

@@ -0,0 +1,5 @@
+# Generated by versioningit
+__version__ = "3.4.25.dev2"
+__build_date__ = "2025-10-18 08:08:44.621960+00:00"
+__git_commit__ = "d52fd915565737e5c73d579f8c12c1865f9cab8e"
+__dirty__ = False

{prefect-3.4.24.dev5 → prefect-3.4.25.dev2}/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-3.4.24.dev5 → prefect-3.4.25.dev2}/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-3.4.24.dev5 → prefect-3.4.25.dev2}/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-3.4.24.dev5 → prefect-3.4.25.dev2}/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-3.4.24.dev5 → prefect-3.4.25.dev2}/src/prefect/server/concurrency/lease_storage/__init__.py

@@ -39,7 +39,20 @@ class ConcurrencyLeaseStorage(LeaseStorage[ConcurrencyLimitLeaseMetadata]):
         self, lease_id: UUID
     ) -> ResourceLease[ConcurrencyLimitLeaseMetadata] | None: ...
 
-    async def renew_lease(self, lease_id: UUID, ttl: timedelta) -> None: ...
+    async def renew_lease(self, lease_id: UUID, ttl: timedelta) -> bool | None:
+        """
+        Renew a resource lease.
+
+        Args:
+            lease_id: The ID of the lease to renew.
+            ttl: The new amount of time the lease should be held for.
+
+        Returns:
+            True if the lease was successfully renewed, False if the lease
+            does not exist or has already expired. None may be returned by
+            legacy implementations for backwards compatibility (treated as success).
+        """
+        ...
 
     async def revoke_lease(self, lease_id: UUID) -> None: ...
 

{prefect-3.4.24.dev5 → prefect-3.4.25.dev2}/src/prefect/server/concurrency/lease_storage/filesystem.py

@@ -163,11 +163,26 @@ class ConcurrencyLeaseStorage(_ConcurrencyLeaseStorage):
             await self._remove_from_expiration_index(lease_id)
             return None
 
-    async def renew_lease(self, lease_id: UUID, ttl: timedelta) -> None:
+    async def renew_lease(self, lease_id: UUID, ttl: timedelta) -> bool:
+        """
+        Atomically renew a concurrency lease by updating its expiration.
+
+        Checks if the lease exists and updates both the lease file and index,
+        preventing race conditions from creating orphaned index entries.
+
+        Args:
+            lease_id: The ID of the lease to renew
+            ttl: The new time-to-live duration
+
+        Returns:
+            True if the lease was renewed, False if it didn't exist
+        """
         lease_file = self._lease_file_path(lease_id)
 
         if not lease_file.exists():
-            return
+            # Clean up any orphaned index entry
+            await self._remove_from_expiration_index(lease_id)
+            return False
 
         try:
             with open(lease_file, "r") as f:
@@ -178,15 +193,25 @@ class ConcurrencyLeaseStorage(_ConcurrencyLeaseStorage):
             lease_data["expiration"] = new_expiration.isoformat()
 
             self._ensure_storage_path()
+
+            # Write updated lease file
             with open(lease_file, "w") as f:
                 json.dump(lease_data, f)
 
+            # Verify file still exists after write (could have been deleted)
+            if not lease_file.exists():
+                # Lease was deleted during update - clean up index
+                await self._remove_from_expiration_index(lease_id)
+                return False
+
             # Update expiration index
             await self._update_expiration_index(lease_id, new_expiration)
+            return True
         except (json.JSONDecodeError, KeyError, ValueError):
             # Clean up corrupted lease file
             lease_file.unlink(missing_ok=True)
             await self._remove_from_expiration_index(lease_id)
+            return False
 
     async def revoke_lease(self, lease_id: UUID) -> None:
         lease_file = self._lease_file_path(lease_id)

{prefect-3.4.24.dev5 → prefect-3.4.25.dev2}/src/prefect/server/concurrency/lease_storage/memory.py

@@ -53,8 +53,27 @@ class ConcurrencyLeaseStorage(_ConcurrencyLeaseStorage):
     ) -> ResourceLease[ConcurrencyLimitLeaseMetadata] | None:
         return self.leases.get(lease_id)
 
-    async def renew_lease(self, lease_id: UUID, ttl: timedelta) -> None:
+    async def renew_lease(self, lease_id: UUID, ttl: timedelta) -> bool:
+        """
+        Atomically renew a concurrency lease by updating its expiration.
+
+        Checks if the lease exists before updating the expiration index,
+        preventing orphaned index entries.
+
+        Args:
+            lease_id: The ID of the lease to renew
+            ttl: The new time-to-live duration
+
+        Returns:
+            True if the lease was renewed, False if it didn't exist
+        """
+        if lease_id not in self.leases:
+            # Clean up any orphaned expiration entry
+            self.expirations.pop(lease_id, None)
+            return False
+
         self.expirations[lease_id] = datetime.now(timezone.utc) + ttl
+        return True
 
     async def revoke_lease(self, lease_id: UUID) -> None:
         self.leases.pop(lease_id, None)

{prefect-3.4.24.dev5 → prefect-3.4.25.dev2}/src/prefect/server/utilities/leasing.py

@@ -47,13 +47,18 @@ class LeaseStorage(Protocol[T]):
         """
         ...
 
-    async def renew_lease(self, lease_id: UUID, ttl: timedelta) -> None:
+    async def renew_lease(self, lease_id: UUID, ttl: timedelta) -> bool | None:
         """
         Renew a resource lease.
 
         Args:
             lease_id: The ID of the lease to renew.
             ttl: The new amount of time the lease should be held for.
+
+        Returns:
+            True if the lease was successfully renewed, False if the lease
+            does not exist or has already expired. None may be returned by
+            legacy implementations for backwards compatibility (treated as success).
         """
         ...
 

{prefect-3.4.24.dev5 → prefect-3.4.25.dev2}/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-3.4.24.dev5 → prefect-3.4.25.dev2}/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-3.4.24.dev5 → prefect-3.4.25.dev2}/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-3.4.24.dev5/src/prefect/_build_info.py

@@ -1,5 +0,0 @@
-# Generated by versioningit
-__version__ = "3.4.24.dev5"
-__build_date__ = "2025-10-16 08:09:47.428197+00:00"
-__git_commit__ = "256e188058cee17efbc01f471d374b2462b6d461"
-__dirty__ = False