prefect-client 3.7.1.dev9__tar.gz → 3.7.2__tar.gz

{prefect_client-3.7.1.dev9 → prefect_client-3.7.2}/PKG-INFO

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

{prefect_client-3.7.1.dev9 → prefect_client-3.7.2}/src/prefect/AGENTS.md

@@ -23,13 +23,14 @@ There is no formal public/private boundary beyond the `_` prefix convention. Mod
 - **Engine ordering matters.** The engines apply features (retries, caching, result persistence, transactions) in a specific order. Changing the order or forgetting a feature in one engine path is the most common source of breakage.
 - **Set run metadata before state transitions.** Any run attribute that event subscribers observe at the moment of a state transition (e.g., custom `flow_run_name`) must be persisted to the server *before* `set_state()` is called for that transition. Metadata set after the call appears stale to subscribers of that state event.
 - **Sync and async must stay in sync.** Both `flow_engine.py` and `task_engine.py` have sync and async paths. Any behavior change must be applied to both.
-- **Use `whenever` compat helpers for all datetime conversions on Python 3.13+.** `types/_datetime.py` provides `now()`, `_whenever_to_stdlib()`, `_whenever_zdt_from_py()`, and `_whenever_pdt_from_py()` to abstract over API differences between whenever 0.7.x–0.9.x and ≥ 0.10.0. The `_WHENEVER_NEW_API` flag (True when whenever ≥ 0.10.0) guards version-specific code. Never call `DateTime.now()` or `pendulum.now()` directly — use `now()` from `types/_datetime.py` instead. Never call `ZonedDateTime.from_py_datetime()`, `PlainDateTime.from_py_datetime()`, or `.py_datetime()` directly — use the helpers instead. Violations will silently break on whichever whenever version the helpers weren't written for.
+- **Use `whenever` compat helpers for all datetime conversions on Python 3.13+.** `types/_datetime.py` provides `now()`, `_whenever_to_stdlib()`, `_whenever_zdt_from_py()`, and `_whenever_pdt_from_py()` to abstract over API differences between whenever 0.7.x–0.9.x and ≥ 0.10.0. The `_WHENEVER_NEW_API` flag (True when whenever ≥ 0.10.0) guards version-specific code. Never call `DateTime.now()` or `pendulum.now()` directly — use `now()` from `types/_datetime.py` instead. Avoid no-argument `datetime.datetime.now()` because it returns a tz-naive datetime that raises `TypeError` when compared to the tz-aware datetimes produced by `now()`. Explicitly timezone-aware stdlib calls such as `datetime.now(ZoneInfo("UTC"))` are allowed when needed to preserve timezone information. Never call `ZonedDateTime.from_py_datetime()`, `PlainDateTime.from_py_datetime()`, or `.py_datetime()` directly — use the helpers instead. Violations will silently break on whichever whenever version the helpers weren't written for.
 - **Flow and task engines advance state differently.** The flow engine makes blocking API calls to the server to propose and advance states. The task engine emits `prefect.task_run.*` events (delivered via WebSockets) but advances state locally through `set_state` calls with polling/backoff — do not assume the two engines work the same way.
 - **Flow state transitions go through the server.** The flow engine proposes states to the server, which accepts or rejects them via orchestration rules. The task engine, by contrast, manages state transitions locally via `set_state` and emits `prefect.task_run.*` events — it does not propose states to the server.
 - **`ProcessPoolTaskRunner` requires picklable data across subprocess boundaries.** `PrefectFuture` objects are not picklable and cannot be passed to worker subprocesses. Any `wait_for` futures must be waited on in the parent process and converted to `State` objects before submission. The subprocess task engine handles `State` objects via `resolve_to_final_result`, which raises `UpstreamTaskError` for non-completed upstreams.
 - **`ProcessPoolTaskRunner` instances may be deserialized without `__init__` running.** When a runner is pickled and restored in a subprocess, `__init__` is not called, so instance attributes set there may be absent. Access any such attribute via `getattr(self, "_attr", default)` rather than `self._attr` directly — both in the property getter and in `duplicate()`. The `subprocess_message_processor_factories` property demonstrates the required pattern.
 - **`ThreadPoolTaskRunner` is cloudpickled when a flow run is dispatched to a subprocess.** `threading.Lock` and other non-picklable thread primitives must be dropped in `__getstate__` and rebuilt in `__setstate__`. Any new instance state added to this class must be evaluated for picklability.
 - **Nested task submissions on a bounded `ThreadPoolTaskRunner` can deadlock.** When a worker task submits children and blocks on `.result()` while all `max_workers` threads are busy, the pool starves. `_warn_if_nested_submit_would_deadlock` detects this and emits a one-time warning — preserve this detection when changing pool management.
+- **Result storage resolves through three tiers, potentially making an API call.** `get_default_result_storage()` checks: (1) `PREFECT_DEFAULT_RESULT_STORAGE_BLOCK` setting, (2) server-configured default block (API call to the server's Configuration store), (3) local storage path. The API call is silently suppressed on any HTTP error. Engines use `_get_default_persist_result()` — not `should_persist_result()` — at context setup time to auto-enable persistence when a server default block is configured. Do not swap `_get_default_persist_result()` back to `should_persist_result()` in engine initialization paths; `should_persist_result()` does not consult the server default.
 - **`ResultRecordMetadata` tolerates unknown serializer types.** When loading persisted metadata, an unrecognized serializer `type` is converted to an `UnknownSerializer` placeholder rather than raising `ValidationError`. This allows inspecting result metadata when the serializer implementation is unavailable in the current environment. However, known serializer types with invalid fields still raise `ValidationError`. `UnknownSerializer.dumps()` and `UnknownSerializer.loads()` raise `RuntimeError` — the tolerance is for inspection only, not actual serialization/deserialization.
 - **Flow-run suspension is enforced at orchestration boundaries.** Suspension is delivered via `FlowRunSuspensionRequest` and raised with `raise_if_flow_run_suspension_requested()`. When changing engines, futures, task runners, or generator execution, check before returning control to flow user code or proposing a flow state that could leave `Suspended`; keep sync/async paths aligned and avoid per-boundary API reads.
 

{prefect_client-3.7.1.dev9 → prefect_client-3.7.2}/src/prefect/__init__.py

@@ -113,6 +113,11 @@ def _initialize_plugins() -> None:
         # Re-raise SystemExit from strict mode
         raise
     except Exception as e:
+        from pydantic_settings.exceptions import SettingsError
+
+        if isinstance(e, SettingsError):
+            return
+
         # Log but don't crash on plugin errors
         try:
             from prefect.logging import get_logger

prefect_client-3.7.2/src/prefect/_build_info.py

@@ -0,0 +1,5 @@
+# Generated by versioningit
+__version__ = "3.7.2"
+__build_date__ = "2026-05-23 00:21:39.748528+00:00"
+__git_commit__ = "5836855ecd0a9924117d212bad5308a8a89ab97d"
+__dirty__ = False

{prefect_client-3.7.1.dev9 → prefect_client-3.7.2}/src/prefect/automations.py

@@ -11,6 +11,7 @@ from prefect.events.actions import (
     CancelFlowRun,
     ChangeFlowRunState,
     DeclareIncident,
+    DeleteFlowRun,
     DoNothing,
     PauseAutomation,
     PauseDeployment,
@@ -61,6 +62,7 @@ __all__ = [
     "PauseDeployment",
     "ResumeDeployment",
     "CancelFlowRun",
+    "DeleteFlowRun",
     "ChangeFlowRunState",
     "PauseWorkQueue",
     "ResumeWorkQueue",

{prefect_client-3.7.1.dev9 → prefect_client-3.7.2}/src/prefect/blocks/notifications.py

@@ -57,7 +57,15 @@ class AbstractAppriseNotificationBlock(NotificationBlock, ABC):
         body: str,
         subject: str | None = None,
     ) -> None:
-        with LogEavesdropper("apprise", level=logging.DEBUG) as eavesdropper:
+        apprise_logger = logging.getLogger("apprise")
+        root_logger = logging.getLogger()
+
+        if apprise_logger.level == logging.NOTSET:
+            log_level = root_logger.getEffectiveLevel()
+        else:
+            log_level = max(apprise_logger.level, root_logger.getEffectiveLevel())
+
+        with LogEavesdropper("apprise", level=log_level) as eavesdropper:
             result = await self._apprise_client.async_notify(  # pyright: ignore[reportUnknownMemberType] incomplete type hints in apprise
                 body=body,
                 title=subject or "",
@@ -72,7 +80,15 @@ class AbstractAppriseNotificationBlock(NotificationBlock, ABC):
         body: str,
         subject: str | None = None,
     ) -> None:
-        with LogEavesdropper("apprise", level=logging.DEBUG) as eavesdropper:
+        apprise_logger = logging.getLogger("apprise")
+        root_logger = logging.getLogger()
+
+        if apprise_logger.level == logging.NOTSET:
+            log_level = root_logger.getEffectiveLevel()
+        else:
+            log_level = max(apprise_logger.level, root_logger.getEffectiveLevel())
+
+        with LogEavesdropper("apprise", level=log_level) as eavesdropper:
             result = self._apprise_client.notify(  # pyright: ignore[reportUnknownMemberType] incomplete type hints in apprise
                 body=body,
                 title=subject or "",

{prefect_client-3.7.1.dev9 → prefect_client-3.7.2}/src/prefect/bundles/__init__.py

@@ -593,8 +593,23 @@ def execute_bundle_in_subprocess(
 
     # Install dependencies if necessary
     if dependencies := bundle.get("dependencies"):
+        dep_lines = [line.strip() for line in dependencies.split("\n") if line.strip()]
+        validated_deps: list[str] = []
+        for dep_line in dep_lines:
+            if dep_line.startswith("-"):
+                raise ValueError(
+                    f"Invalid dependency (command-line flags are not allowed): {dep_line!r}"
+                )
+            try:
+                Requirement(dep_line)
+            except InvalidRequirement as e:
+                raise ValueError(
+                    f"Invalid PEP 508 dependency specifier: {dep_line!r}"
+                ) from e
+            validated_deps.append(dep_line)
+
         subprocess.check_call(
-            [_get_uv_path(), "pip", "install", *dependencies.split("\n")],
+            [_get_uv_path(), "pip", "install", *validated_deps],
             # Copy the current environment to ensure we install into the correct venv
             env=os.environ,
         )

{prefect_client-3.7.1.dev9 → prefect_client-3.7.2}/src/prefect/bundles/_zip_builder.py

@@ -11,6 +11,7 @@ from __future__ import annotations
 import hashlib
 import logging
 import shutil
+import struct
 import tempfile
 import zipfile
 from dataclasses import dataclass
@@ -32,7 +33,8 @@ class ZipResult:
 
     Attributes:
         zip_path: Path to the temporary zip file.
-        sha256_hash: Lowercase hex digest of the zip content.
+        sha256_hash: SHA256 hex digest of the canonical bundled file contents
+            (paths, modes, and bytes), not the raw zip archive bytes.
         storage_key: Content-addressed storage key in format "files/{hash}.zip".
         size_bytes: Size of the zip file in bytes.
     """
@@ -95,16 +97,40 @@ class ZipBuilder:
         self._temp_dir = tempfile.mkdtemp(prefix="prefect-zip-")
         zip_path = Path(self._temp_dir) / "files.zip"
 
-        # Build the zip with DEFLATED compression
+        # Build the zip and compute the content hash in a single pass so
+        # that every file is read exactly once, avoiding race conditions
+        # where a source file could change between the zip write and the
+        # hash computation.
+        hasher = hashlib.sha256()
+        hasher.update(b"prefect-bundle-files-v1\0")
+
         with zipfile.ZipFile(zip_path, "w", compression=zipfile.ZIP_DEFLATED) as zf:
             for file_path in sorted_files:
-                # Compute relative path with forward slashes
                 rel_path = file_path.relative_to(self.base_dir)
                 arcname = str(rel_path).replace("\\", "/")
-                zf.write(file_path, arcname)
 
-        # Compute SHA256 hash using chunked reading
-        sha256_hash = self._compute_hash(zip_path)
+                file_stat = file_path.stat()
+
+                arcname_bytes = arcname.encode("utf-8")
+                hasher.update(struct.pack(">I", len(arcname_bytes)))
+                hasher.update(arcname_bytes)
+                hasher.update(struct.pack(">I", file_stat.st_mode & 0xFFFF))
+                hasher.update(struct.pack(">Q", file_stat.st_size))
+
+                zip_info = zipfile.ZipInfo.from_file(file_path, arcname)
+                zip_info.compress_type = zipfile.ZIP_DEFLATED
+                with (
+                    file_path.open("rb") as src,
+                    zf.open(zip_info, "w") as dest,
+                ):
+                    while True:
+                        chunk = src.read(HASH_CHUNK_SIZE)
+                        if not chunk:
+                            break
+                        dest.write(chunk)
+                        hasher.update(chunk)
+
+        sha256_hash = hasher.hexdigest()
 
         # Get file size
         size_bytes = zip_path.stat().st_size
@@ -123,25 +149,6 @@ class ZipBuilder:
             size_bytes=size_bytes,
         )
 
-    def _compute_hash(self, zip_path: Path) -> str:
-        """
-        Compute SHA256 hash of a file using chunked reading.
-
-        Args:
-            zip_path: Path to the file to hash.
-
-        Returns:
-            Lowercase hex digest of the SHA256 hash.
-        """
-        hasher = hashlib.sha256()
-        with open(zip_path, "rb") as f:
-            while True:
-                chunk = f.read(HASH_CHUNK_SIZE)
-                if not chunk:
-                    break
-                hasher.update(chunk)
-        return hasher.hexdigest()
-
     def _emit_size_warning(
         self, zip_path: Path, files: list[Path], size_bytes: int
     ) -> None:

{prefect_client-3.7.1.dev9 → prefect_client-3.7.2}/src/prefect/concurrency/_leases.py

@@ -143,9 +143,14 @@ def _start_lease_renewal_thread(
     stop_event = threading.Event()
     renewal_ctx = contextvars.copy_context()
 
-    def renewal_loop() -> None:
+    def _run_with_failure_handler() -> None:
+        # Runs inside renewal_ctx so the failure handler also sees the
+        # copied flow/task run contextvars; otherwise get_run_logger() in
+        # _handle_lease_renewal_failure can't find the run context and the
+        # message falls back to the plain "prefect.concurrency" logger,
+        # never reaching the run logs API.
         try:
-            renewal_ctx.run(_lease_renewal_loop, lease_id, lease_duration, stop_event)
+            _lease_renewal_loop(lease_id, lease_duration, stop_event)
         except Exception as exc:
             if not stop_event.is_set():
                 _handle_lease_renewal_failure(
@@ -156,6 +161,9 @@ def _start_lease_renewal_thread(
                     cancel_scope,
                 )
 
+    def renewal_loop() -> None:
+        renewal_ctx.run(_run_with_failure_handler)
+
     thread = threading.Thread(
         target=renewal_loop,
         daemon=True,

{prefect_client-3.7.1.dev9 → prefect_client-3.7.2}/src/prefect/events/__init__.py

@@ -31,6 +31,7 @@ from .actions import (
     ResumeDeployment,
     ChangeFlowRunState,
     CancelFlowRun,
+    DeleteFlowRun,
     SuspendFlowRun,
     CallWebhook,
     SendNotification,
@@ -78,6 +79,7 @@ __all__ = [
     "ResumeDeployment",
     "ChangeFlowRunState",
     "CancelFlowRun",
+    "DeleteFlowRun",
     "SuspendFlowRun",
     "CallWebhook",
     "SendNotification",

{prefect_client-3.7.1.dev9 → prefect_client-3.7.2}/src/prefect/events/actions.py

@@ -126,6 +126,12 @@ class CancelFlowRun(Action):
     type: Literal["cancel-flow-run"] = "cancel-flow-run"
 
 
+class DeleteFlowRun(Action):
+    """Deletes a flow run associated with the trigger"""
+
+    type: Literal["delete-flow-run"] = "delete-flow-run"
+
+
 class ResumeFlowRun(Action):
     """Resumes a flow run associated with the trigger"""
 
@@ -294,6 +300,7 @@ ActionTypes: TypeAlias = Union[
     ResumeDeployment,
     ResumeFlowRun,
     CancelFlowRun,
+    DeleteFlowRun,
     ChangeFlowRunState,
     PauseWorkQueue,
     ResumeWorkQueue,

{prefect_client-3.7.1.dev9 → prefect_client-3.7.2}/src/prefect/events/clients.py

@@ -31,7 +31,7 @@ from websockets.exceptions import (
 import prefect.types._datetime
 from prefect._internal.version_checking import check_server_version
 from prefect._internal.websockets import websocket_connect
-from prefect.events import Event
+from prefect.events.schemas.events import Event
 from prefect.logging import get_logger
 from prefect.settings import (
     PREFECT_API_KEY,

{prefect_client-3.7.1.dev9 → prefect_client-3.7.2}/src/prefect/events/subscribers.py

@@ -13,9 +13,9 @@ from typing_extensions import Self
 
 from prefect.client.schemas.filters import LogFilter, LogFilterFlowRunId
 from prefect.client.schemas.objects import TERMINAL_STATES, Log, StateType
-from prefect.events import Event
 from prefect.events.clients import get_events_subscriber
 from prefect.events.filters import EventAnyResourceFilter, EventFilter
+from prefect.events.schemas.events import Event
 from prefect.logging.clients import get_logs_subscriber
 
 if TYPE_CHECKING:

{prefect_client-3.7.1.dev9 → prefect_client-3.7.2}/src/prefect/flow_engine.py

@@ -909,10 +909,15 @@ class FlowRunEngine(BaseFlowRunEngine[P, R]):
         This method attempts to load an existing flow run for a subflow task
         run, if appropriate.
 
-        If the parent task run is in a final but not COMPLETED state, and not
-        being rerun, then we attempt to load an existing flow run instead of
-        creating a new one. This will prevent the engine from running the
-        subflow again.
+        If the parent task run is in a final state, we return the existing
+        subflow run to avoid re-execution (unless the parent is being rerun
+        and the subflow did not complete, in which case a fresh run is
+        desired).
+
+        If the parent task run is in a non-final state (e.g. still Running
+        after a process restart), we also look for an existing subflow run
+        to reattach to, preventing duplicate subflow runs from being created
+        under the same parent task run.
 
         If no existing flow run is found, or if the subflow should be rerun,
         then no flow run is returned.
@@ -926,27 +931,32 @@ class FlowRunEngine(BaseFlowRunEngine[P, R]):
             else False
         )
 
-        # if the parent task run is in a final but not completed state, and
-        # not rerunning, then retrieve the most recent flow run instead of
-        # creating a new one. This effectively loads a cached flow run for
-        # situations where we are confident the flow should not be run
-        # again.
         assert isinstance(parent_task_run.state, State)
-        if parent_task_run.state.is_final() and not (
-            rerunning and not parent_task_run.state.is_completed()
+
+        # If the user explicitly triggered a re-run and the subflow did not
+        # complete, allow a fresh subflow to be created.
+        if (
+            parent_task_run.state.is_final()
+            and rerunning
+            and not parent_task_run.state.is_completed()
         ):
-            # return the most recent flow run, if it exists
-            flow_runs = client.read_flow_runs(
-                flow_run_filter=FlowRunFilter(
-                    parent_task_run_id={"any_": [parent_task_run.id]}
-                ),
-                sort=FlowRunSort.EXPECTED_START_TIME_ASC,
-                limit=1,
-            )
-            if flow_runs:
-                loaded_flow_run = flow_runs[-1]
+            return None
+
+        # Look for an existing subflow run attached to this parent task run.
+        flow_runs = client.read_flow_runs(
+            flow_run_filter=FlowRunFilter(
+                parent_task_run_id={"any_": [parent_task_run.id]}
+            ),
+            sort=FlowRunSort.EXPECTED_START_TIME_DESC,
+            limit=1,
+        )
+        if flow_runs:
+            loaded_flow_run = flow_runs[0]
+            # When the parent task run is final the subflow has already
+            # finished; cache the result so the engine skips re-execution.
+            if parent_task_run.state.is_final():
                 self._return_value = loaded_flow_run.state
-                return loaded_flow_run
+            return loaded_flow_run
 
     def create_flow_run(self, client: SyncPrefectClient) -> FlowRun:
         flow_run_ctx = FlowRunContext.get()
@@ -1594,10 +1604,15 @@ class AsyncFlowRunEngine(BaseFlowRunEngine[P, R]):
         This method attempts to load an existing flow run for a subflow task
         run, if appropriate.
 
-        If the parent task run is in a final but not COMPLETED state, and not
-        being rerun, then we attempt to load an existing flow run instead of
-        creating a new one. This will prevent the engine from running the
-        subflow again.
+        If the parent task run is in a final state, we return the existing
+        subflow run to avoid re-execution (unless the parent is being rerun
+        and the subflow did not complete, in which case a fresh run is
+        desired).
+
+        If the parent task run is in a non-final state (e.g. still Running
+        after a process restart), we also look for an existing subflow run
+        to reattach to, preventing duplicate subflow runs from being created
+        under the same parent task run.
 
         If no existing flow run is found, or if the subflow should be rerun,
         then no flow run is returned.
@@ -1611,27 +1626,32 @@ class AsyncFlowRunEngine(BaseFlowRunEngine[P, R]):
             else False
         )
 
-        # if the parent task run is in a final but not completed state, and
-        # not rerunning, then retrieve the most recent flow run instead of
-        # creating a new one. This effectively loads a cached flow run for
-        # situations where we are confident the flow should not be run
-        # again.
         assert isinstance(parent_task_run.state, State)
-        if parent_task_run.state.is_final() and not (
-            rerunning and not parent_task_run.state.is_completed()
+
+        # If the user explicitly triggered a re-run and the subflow did not
+        # complete, allow a fresh subflow to be created.
+        if (
+            parent_task_run.state.is_final()
+            and rerunning
+            and not parent_task_run.state.is_completed()
         ):
-            # return the most recent flow run, if it exists
-            flow_runs = await client.read_flow_runs(
-                flow_run_filter=FlowRunFilter(
-                    parent_task_run_id={"any_": [parent_task_run.id]}
-                ),
-                sort=FlowRunSort.EXPECTED_START_TIME_ASC,
-                limit=1,
-            )
-            if flow_runs:
-                loaded_flow_run = flow_runs[-1]
+            return None
+
+        # Look for an existing subflow run attached to this parent task run.
+        flow_runs = await client.read_flow_runs(
+            flow_run_filter=FlowRunFilter(
+                parent_task_run_id={"any_": [parent_task_run.id]}
+            ),
+            sort=FlowRunSort.EXPECTED_START_TIME_DESC,
+            limit=1,
+        )
+        if flow_runs:
+            loaded_flow_run = flow_runs[0]
+            # When the parent task run is final the subflow has already
+            # finished; cache the result so the engine skips re-execution.
+            if parent_task_run.state.is_final():
                 self._return_value = loaded_flow_run.state
-                return loaded_flow_run
+            return loaded_flow_run
 
     async def create_flow_run(self, client: PrefectClient) -> FlowRun:
         flow_run_ctx = FlowRunContext.get()

{prefect_client-3.7.1.dev9 → prefect_client-3.7.2}/src/prefect/logging/handlers.py

@@ -16,7 +16,6 @@ from rich.highlighter import Highlighter, NullHighlighter
 from rich.theme import Theme
 from typing_extensions import Self
 
-import prefect.context
 from prefect._internal.concurrency.api import create_call, from_sync
 from prefect._internal.concurrency.event_loop import get_running_loop
 from prefect._internal.concurrency.services import BatchedQueueService
@@ -161,7 +160,9 @@ class APILogHandler(logging.Handler):
         Send a log to the `APILogWorker`
         """
         try:
-            profile = prefect.context.get_settings_context()
+            from prefect.context import get_settings_context
+
+            profile = get_settings_context()
 
             if not profile.settings.logging.to_api.enabled:
                 return  # Respect the global settings toggle
@@ -214,7 +215,9 @@ class APILogHandler(logging.Handler):
 
         if not flow_run_id:
             try:
-                context = prefect.context.get_run_context()
+                from prefect.context import get_run_context
+
+                context = get_run_context()
             except MissingContextError:
                 raise MissingContextError(
                     f"Logger {record.name!r} attempted to send logs to the API without"

{prefect_client-3.7.1.dev9 → prefect_client-3.7.2}/src/prefect/results.py

@@ -699,6 +699,8 @@ class ResultStore(BaseModel):
             except Exception:
                 return False
         else:
+            if self.result_storage is None:
+                self.result_storage = await aget_default_result_storage()
             try:
                 content = await call_explicitly_async_block_method(
                     self.result_storage, "read_path", (key,), {}
@@ -742,6 +744,8 @@ class ResultStore(BaseModel):
             except Exception:
                 return False
         else:
+            if self.result_storage is None:
+                self.result_storage = get_default_result_storage(_sync=True)
             try:
                 content = call_explicitly_sync_block_method(
                     self.result_storage, "read_path", (key,), {}

{prefect_client-3.7.1.dev9 → prefect_client-3.7.2}/src/prefect/runner/_scheduled_run_poller.py

@@ -126,7 +126,6 @@ class ScheduledRunPoller:
             ),
         )
 
-        submitted_ids: set[UUID] = set()
         for flow_run in submittable_flow_runs:
             if flow_run.id in self._submitting_flow_run_ids:
                 continue
@@ -135,13 +134,12 @@ class ScheduledRunPoller:
             except anyio.WouldBlock:
                 break  # sorted: no earlier run fits
             self._submitting_flow_run_ids.add(flow_run.id)
-            submitted_ids.add(flow_run.id)
             task_group.start_soon(self._submit_run, flow_run, task_group, slot_token)
 
         skipped_count = sum(
             1
             for r in submittable_flow_runs
-            if r.id not in self._submitting_flow_run_ids and r.id not in submitted_ids
+            if r.id not in self._submitting_flow_run_ids
         )
         if skipped_count > 0:
             self._logger.info("%d scheduled runs skipped (at capacity)", skipped_count)
@@ -182,18 +180,15 @@ class ScheduledRunPoller:
             pull_interval = getattr(storage, "pull_interval", None)
             if storage and isinstance(pull_interval, (int, float)) and pull_interval:
                 last_adhoc_pull = getattr(storage, "last_adhoc_pull", None)
-                if (
-                    last_adhoc_pull is None
-                    or last_adhoc_pull
-                    < datetime.datetime.now()
-                    - datetime.timedelta(seconds=storage.pull_interval)
-                ):
+                if last_adhoc_pull is None or last_adhoc_pull < now(
+                    "UTC"
+                ) - datetime.timedelta(seconds=storage.pull_interval):
                     self._logger.debug(
                         "Performing adhoc pull of code for flow run %s",
                         flow_run.id,
                     )
                     await storage.pull_code()
-                    storage.last_adhoc_pull = datetime.datetime.now()
+                    storage.last_adhoc_pull = now("UTC")
 
             executor = FlowRunExecutor(
                 flow_run=flow_run,

{prefect_client-3.7.1.dev9 → prefect_client-3.7.2}/src/prefect/runner/runner.py

@@ -129,6 +129,7 @@ from prefect.settings import (
 from prefect.states import (
     AwaitingRetry,
 )
+from prefect.types._datetime import now
 from prefect.types.entrypoint import EntrypointType
 from prefect.utilities.annotations import NotSet
 from prefect.utilities.asyncutils import (
@@ -214,7 +215,7 @@ class Runner:
                 def goodbye_flow(name):
                     print(f"goodbye {name}")
 
-                if __name__ == "__main__"
+                if __name__ == "__main__":
                     runner = Runner(name="my-runner")
 
                     # Will be runnable via the API
@@ -613,17 +614,17 @@ class Runner:
             def goodbye_flow(name):
                 print(f"goodbye {name}")
 
-            if __name__ == "__main__"
-                runner = Runner(name="my-runner")
+                if __name__ == "__main__":
+                    runner = Runner(name="my-runner")
 
-                # Will be runnable via the API
-                runner.add_flow(hello_flow)
+                    # Will be runnable via the API
+                    runner.add_flow(hello_flow)
 
-                # Run on a cron schedule
-                runner.add_flow(goodbye_flow, schedule={"cron": "0 * * * *"})
+                    # Run on a cron schedule
+                    runner.add_flow(goodbye_flow, schedule={"cron": "0 * * * *"})
 
-                asyncio.run(runner.start())
-            ```
+                    asyncio.run(runner.start())
+                ```
         """
         from prefect.runner.server import start_webserver
 
@@ -780,9 +781,9 @@ class Runner:
             # The process may be a multiprocessing.context.SpawnProcess, in which case it will have an `exitcode` attribute
             # but no `returncode` attribute
             if (
-                getattr(process, "returncode", None)
-                or getattr(process, "exitcode", None)
-            ) is None:
+                getattr(process, "returncode", None) is None
+                and getattr(process, "exitcode", None) is None
+            ):
                 await self._add_flow_run_process_map_entry(
                     flow_run.id, ProcessMapEntry(pid=process.pid, flow_run=flow_run)
                 )
@@ -1051,19 +1052,16 @@ class Runner:
             # adhoc pull hasn't been performed in the last pull_interval
             # TODO: Explore integrating this behavior with global concurrency.
             last_adhoc_pull = getattr(storage, "last_adhoc_pull", None)
-            if (
-                last_adhoc_pull is None
-                or last_adhoc_pull
-                < datetime.datetime.now()
-                - datetime.timedelta(seconds=storage.pull_interval)
-            ):
+            if last_adhoc_pull is None or last_adhoc_pull < now(
+                "UTC"
+            ) - datetime.timedelta(seconds=storage.pull_interval):
                 self._logger.debug(
                     "Performing adhoc pull of code for flow run %s with storage %r",
                     flow_run.id,
                     storage,
                 )
                 await storage.pull_code()
-                setattr(storage, "last_adhoc_pull", datetime.datetime.now())
+                setattr(storage, "last_adhoc_pull", now("UTC"))
 
         handed_off = False