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

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

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

prefect_client-3.2.11/src/prefect/_build_info.py

@@ -0,0 +1,5 @@
+# Generated by versioningit
+__version__ = "3.2.11"
+__build_date__ = "2025-03-05 21:59:47.932907+00:00"
+__git_commit__ = "9481694f9d12e27ab26ae33d3cc5d1306d78693a"
+__dirty__ = False

{prefect_client-3.2.9 → prefect_client-3.2.11}/src/prefect/deployments/flow_runs.py

@@ -3,6 +3,7 @@ from typing import TYPE_CHECKING, Any, Iterable, Optional, Union
 from uuid import UUID
 
 import anyio
+from opentelemetry import trace
 
 import prefect
 from prefect._result_records import ResultRecordMetadata
@@ -12,13 +13,21 @@ from prefect.context import FlowRunContext, TaskRunContext
 from prefect.logging import get_logger
 from prefect.states import Pending, Scheduled
 from prefect.tasks import Task
-from prefect.telemetry.run_telemetry import (
-    LABELS_TRACEPARENT_KEY,
-)
+from prefect.telemetry.run_telemetry import LABELS_TRACEPARENT_KEY, RunTelemetry
 from prefect.types._datetime import now
 from prefect.utilities.asyncutils import sync_compatible
 from prefect.utilities.slugify import slugify
 
+
+def _is_instrumentation_enabled() -> bool:
+    try:
+        from opentelemetry.instrumentation.utils import is_instrumentation_enabled
+
+        return is_instrumentation_enabled()
+    except (ImportError, ModuleNotFoundError):
+        return False
+
+
 if TYPE_CHECKING:
     from prefect.client.orchestration import PrefectClient
     from prefect.client.schemas.objects import FlowRun
@@ -164,6 +173,8 @@ async def run_deployment(
 
     if flow_run_ctx and flow_run_ctx.flow_run:
         traceparent = flow_run_ctx.flow_run.labels.get(LABELS_TRACEPARENT_KEY)
+    elif _is_instrumentation_enabled():
+        traceparent = RunTelemetry.traceparent_from_span(span=trace.get_current_span())
     else:
         traceparent = None
 

{prefect_client-3.2.9 → prefect_client-3.2.11}/src/prefect/events/clients.py

@@ -21,6 +21,7 @@ from urllib.parse import urlparse
 from urllib.request import proxy_bypass
 from uuid import UUID
 
+import certifi
 import orjson
 from cachetools import TTLCache
 from prometheus_client import Counter
@@ -38,6 +39,7 @@ from prefect.events import Event
 from prefect.logging import get_logger
 from prefect.settings import (
     PREFECT_API_KEY,
+    PREFECT_API_SSL_CERT_FILE,
     PREFECT_API_TLS_INSECURE_SKIP_VERIFY,
     PREFECT_API_URL,
     PREFECT_CLOUD_API_URL,
@@ -123,12 +125,19 @@ class WebsocketProxyConnect(connect):
         self._host = host
         self._port = port
 
-        if PREFECT_API_TLS_INSECURE_SKIP_VERIFY:
+        if PREFECT_API_TLS_INSECURE_SKIP_VERIFY and u.scheme == "wss":
             # Create an unverified context for insecure connections
             ctx = ssl.create_default_context()
             ctx.check_hostname = False
             ctx.verify_mode = ssl.CERT_NONE
             self._kwargs.setdefault("ssl", ctx)
+        elif u.scheme == "wss":
+            cert_file = PREFECT_API_SSL_CERT_FILE.value()
+            if not cert_file:
+                cert_file = certifi.where()
+            # Create a verified context with the certificate file
+            ctx = ssl.create_default_context(cafile=cert_file)
+            self._kwargs.setdefault("ssl", ctx)
 
     async def _proxy_connect(self: Self) -> ClientConnection:
         if self._proxy:

{prefect_client-3.2.9 → prefect_client-3.2.11}/src/prefect/flows.py

@@ -2162,6 +2162,14 @@ def serve(
 
     runner = Runner(pause_on_shutdown=pause_on_shutdown, limit=limit, **kwargs)
     for deployment in args:
+        if deployment.work_pool_name:
+            warnings.warn(
+                "Work pools are not necessary for served deployments - "
+                "the `work_pool_name` argument will be ignored. Omit the "
+                f"`work_pool_name` argument from `to_deployment` for {deployment.name!r}.",
+                UserWarning,
+            )
+            deployment.work_pool_name = None
         runner.add_deployment(deployment)
 
     if print_starting_message:

{prefect_client-3.2.9 → prefect_client-3.2.11}/src/prefect/runner/runner.py

@@ -108,6 +108,7 @@ from prefect.settings import (
     get_current_settings,
 )
 from prefect.states import (
+    AwaitingRetry,
     Crashed,
     Pending,
     exception_to_failed_state,
@@ -120,7 +121,7 @@ from prefect.utilities.asyncutils import (
     is_async_fn,
     sync_compatible,
 )
-from prefect.utilities.engine import propose_state
+from prefect.utilities.engine import propose_state, propose_state_sync
 from prefect.utilities.processutils import (
     get_sys_executable,
     run_process,
@@ -226,6 +227,7 @@ class Runner:
         )
         if self.heartbeat_seconds is not None and self.heartbeat_seconds < 30:
             raise ValueError("Heartbeat must be 30 seconds or greater.")
+        self._heartbeat_task: asyncio.Task[None] | None = None
 
         self._limiter: anyio.CapacityLimiter | None = None
         self._client: PrefectClient = get_client()
@@ -236,6 +238,8 @@ class Runner:
         self._flow_run_process_map: dict[UUID, ProcessMapEntry] = dict()
         self.__flow_run_process_map_lock: asyncio.Lock | None = None
         self._flow_run_bundle_map: dict[UUID, SerializedBundle] = dict()
+        # Flip to True when we are rescheduling flow runs to avoid marking flow runs as crashed
+        self._rescheduling: bool = False
 
         self._tmp_dir: Path = (
             Path(tempfile.gettempdir()) / "runner_storage" / str(uuid4())
@@ -506,16 +510,6 @@ class Runner:
                         jitter_range=0.3,
                     )
                 )
-                if self.heartbeat_seconds is not None:
-                    loops_task_group.start_soon(
-                        partial(
-                            critical_service_loop,
-                            workload=runner._emit_flow_run_heartbeats,
-                            interval=self.heartbeat_seconds,
-                            run_once=run_once,
-                            jitter_range=0.3,
-                        )
-                    )
 
     def execute_in_background(
         self, func: Callable[..., Any], *args: Any, **kwargs: Any
@@ -568,9 +562,9 @@ class Runner:
         flow_run_id: UUID,
         entrypoint: str | None = None,
         command: str | None = None,
-        cwd: Path | None = None,
+        cwd: Path | str | None = None,
         env: dict[str, str | None] | None = None,
-        task_status: anyio.abc.TaskStatus[int] | None = None,
+        task_status: anyio.abc.TaskStatus[int] = anyio.TASK_STATUS_IGNORED,
         stream_output: bool = True,
     ) -> anyio.abc.Process | None:
         """
@@ -594,7 +588,9 @@ class Runner:
                     self._submitting_flow_run_ids.add(flow_run_id)
                     flow_run = await self._client.read_flow_run(flow_run_id)
 
-                    process: anyio.abc.Process = await self._runs_task_group.start(
+                    process: (
+                        anyio.abc.Process | Exception
+                    ) = await self._runs_task_group.start(
                         partial(
                             self._submit_run_and_capture_errors,
                             flow_run=flow_run,
@@ -605,8 +601,13 @@ class Runner:
                             stream_output=stream_output,
                         ),
                     )
-                    if task_status:
-                        task_status.started(process.pid)
+                    if isinstance(process, Exception):
+                        return
+
+                    task_status.started(process.pid)
+
+                    if self.heartbeat_seconds is not None:
+                        await self._emit_flow_run_heartbeat(flow_run)
 
                     async with self._flow_run_process_map_lock:
                         # Only add the process to the map if it is still running
@@ -632,15 +633,6 @@ class Runner:
                             jitter_range=0.3,
                         )
                     )
-                    if self.heartbeat_seconds is not None:
-                        tg.start_soon(
-                            partial(
-                                critical_service_loop,
-                                workload=self._emit_flow_run_heartbeats,
-                                interval=self.heartbeat_seconds,
-                                jitter_range=0.3,
-                            )
-                        )
 
                     return process
 
@@ -668,6 +660,9 @@ class Runner:
                 await self._propose_crashed_state(flow_run, msg)
                 raise RuntimeError(msg)
 
+            if self.heartbeat_seconds is not None:
+                await self._emit_flow_run_heartbeat(flow_run)
+
             self._flow_run_process_map[flow_run.id] = ProcessMapEntry(
                 pid=process.pid, flow_run=flow_run
             )
@@ -683,16 +678,6 @@ class Runner:
                     )
                 )
             )
-            if self.heartbeat_seconds is not None:
-                tasks.append(
-                    asyncio.create_task(
-                        critical_service_loop(
-                            workload=self._emit_flow_run_heartbeats,
-                            interval=self.heartbeat_seconds,
-                            jitter_range=0.1,
-                        )
-                    )
-                )
 
             await anyio.to_thread.run_sync(process.join)
 
@@ -768,10 +753,12 @@ class Runner:
     async def _run_process(
         self,
         flow_run: "FlowRun",
-        task_status: anyio.abc.TaskStatus[anyio.abc.Process] | None = None,
+        task_status: anyio.abc.TaskStatus[
+            anyio.abc.Process
+        ] = anyio.TASK_STATUS_IGNORED,
         entrypoint: str | None = None,
         command: str | None = None,
-        cwd: Path | None = None,
+        cwd: Path | str | None = None,
         env: dict[str, str | None] | None = None,
         stream_output: bool = True,
     ) -> anyio.abc.Process:
@@ -951,6 +938,45 @@ class Runner:
                 # process ended right after the check above.
                 return
 
+    def reschedule_current_flow_runs(
+        self,
+    ) -> None:
+        """
+        Reschedules all flow runs that are currently running.
+
+        This should only be called when the runner is shutting down because it kill all
+        child processes and short-circuit the crash detection logic.
+        """
+        self._rescheduling = True
+        # Create a new sync client because this will often run in a separate thread
+        # as part of a signal handler.
+        with get_client(sync_client=True) as client:
+            self._logger.info("Rescheduling flow runs...")
+            for process_info in self._flow_run_process_map.values():
+                flow_run = process_info["flow_run"]
+                run_logger = self._get_flow_run_logger(flow_run)
+                run_logger.info(
+                    "Rescheduling flow run for resubmission in response to SIGTERM"
+                )
+                try:
+                    propose_state_sync(client, AwaitingRetry(), flow_run_id=flow_run.id)
+                    os.kill(process_info["pid"], signal.SIGTERM)
+                    run_logger.info("Rescheduled flow run for resubmission")
+                except ProcessLookupError:
+                    # Process may have already exited
+                    pass
+                except Abort as exc:
+                    run_logger.info(
+                        (
+                            "Aborted submission of flow run. "
+                            f"Server sent an abort signal: {exc}"
+                        ),
+                    )
+                except Exception:
+                    run_logger.exception(
+                        "Failed to reschedule flow run",
+                    )
+
     async def _pause_schedules(self):
         """
         Pauses all deployment schedules.
@@ -1381,7 +1407,7 @@ class Runner:
         task_status: anyio.abc.TaskStatus[anyio.abc.Process | Exception],
         entrypoint: str | None = None,
         command: str | None = None,
-        cwd: Path | None = None,
+        cwd: Path | str | None = None,
         env: dict[str, str | None] | None = None,
         stream_output: bool = True,
     ) -> Union[Optional[int], Exception]:
@@ -1399,12 +1425,12 @@ class Runner:
             )
             status_code = process.returncode
         except Exception as exc:
-            if task_status:
+            if not task_status._future.done():
                 # This flow run was being submitted and did not start successfully
                 run_logger.exception(
                     f"Failed to start process for flow run '{flow_run.id}'."
                 )
-                # Mark the task as started to prevent agent crash
+                # Mark the task as started to prevent runner crash
                 task_status.started(exc)
                 message = f"Flow run process could not be started:\n{exc!r}"
                 await self._propose_crashed_state(flow_run, message)
@@ -1421,7 +1447,7 @@ class Runner:
             async with self._flow_run_process_map_lock:
                 self._flow_run_process_map.pop(flow_run.id, None)
 
-        if status_code != 0:
+        if status_code != 0 and not self._rescheduling:
             await self._propose_crashed_state(
                 flow_run,
                 f"Flow run process exited with non-zero status code {status_code}.",
@@ -1637,6 +1663,15 @@ class Runner:
         if not hasattr(self, "_loops_task_group") or not self._loops_task_group:
             self._loops_task_group: anyio.abc.TaskGroup = anyio.create_task_group()
 
+        if self.heartbeat_seconds is not None:
+            self._heartbeat_task = asyncio.create_task(
+                critical_service_loop(
+                    workload=self._emit_flow_run_heartbeats,
+                    interval=self.heartbeat_seconds,
+                    jitter_range=0.3,
+                )
+            )
+
         self.started = True
         return self
 
@@ -1658,6 +1693,13 @@ class Runner:
         shutil.rmtree(str(self._tmp_dir))
         del self._runs_task_group, self._loops_task_group
 
+        if self._heartbeat_task:
+            self._heartbeat_task.cancel()
+            try:
+                await self._heartbeat_task
+            except asyncio.CancelledError:
+                pass
+
     def __repr__(self) -> str:
         return f"Runner(name={self.name!r})"
 

{prefect_client-3.2.9 → prefect_client-3.2.11}/src/prefect/runner/storage.py

@@ -141,7 +141,8 @@ class GitRepository:
         self._credentials = credentials
         self._include_submodules = include_submodules
         repo_name = urlparse(url).path.split("/")[-1].replace(".git", "")
-        default_name = f"{repo_name}-{branch}" if branch else repo_name
+        safe_branch = branch.replace("/", "-") if branch else None
+        default_name = f"{repo_name}-{safe_branch}" if safe_branch else repo_name
         self._name = name or default_name
         self._logger = get_logger(f"runner.storage.git-repository.{self._name}")
         self._storage_base_path = Path.cwd()

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

@@ -376,12 +376,12 @@ async def read_deployment(
 async def read_deployments(
     limit: int = dependencies.LimitBody(),
     offset: int = Body(0, ge=0),
-    flows: schemas.filters.FlowFilter = None,
-    flow_runs: schemas.filters.FlowRunFilter = None,
-    task_runs: schemas.filters.TaskRunFilter = None,
-    deployments: schemas.filters.DeploymentFilter = None,
-    work_pools: schemas.filters.WorkPoolFilter = None,
-    work_pool_queues: schemas.filters.WorkQueueFilter = None,
+    flows: Optional[schemas.filters.FlowFilter] = None,
+    flow_runs: Optional[schemas.filters.FlowRunFilter] = None,
+    task_runs: Optional[schemas.filters.TaskRunFilter] = None,
+    deployments: Optional[schemas.filters.DeploymentFilter] = None,
+    work_pools: Optional[schemas.filters.WorkPoolFilter] = None,
+    work_pool_queues: Optional[schemas.filters.WorkQueueFilter] = None,
     sort: schemas.sorting.DeploymentSort = Body(
         schemas.sorting.DeploymentSort.NAME_ASC
     ),
@@ -415,12 +415,12 @@ async def read_deployments(
 async def paginate_deployments(
     limit: int = dependencies.LimitBody(),
     page: int = Body(1, ge=1),
-    flows: schemas.filters.FlowFilter = None,
-    flow_runs: schemas.filters.FlowRunFilter = None,
-    task_runs: schemas.filters.TaskRunFilter = None,
-    deployments: schemas.filters.DeploymentFilter = None,
-    work_pools: schemas.filters.WorkPoolFilter = None,
-    work_pool_queues: schemas.filters.WorkQueueFilter = None,
+    flows: Optional[schemas.filters.FlowFilter] = None,
+    flow_runs: Optional[schemas.filters.FlowRunFilter] = None,
+    task_runs: Optional[schemas.filters.TaskRunFilter] = None,
+    deployments: Optional[schemas.filters.DeploymentFilter] = None,
+    work_pools: Optional[schemas.filters.WorkPoolFilter] = None,
+    work_pool_queues: Optional[schemas.filters.WorkQueueFilter] = None,
     sort: schemas.sorting.DeploymentSort = Body(
         schemas.sorting.DeploymentSort.NAME_ASC
     ),
@@ -474,7 +474,7 @@ async def paginate_deployments(
 @router.post("/get_scheduled_flow_runs")
 async def get_scheduled_flow_runs_for_deployments(
     background_tasks: BackgroundTasks,
-    deployment_ids: List[UUID] = Body(
+    deployment_ids: list[UUID] = Body(
         default=..., description="The deployment IDs to get scheduled runs for"
     ),
     scheduled_before: DateTime = Body(
@@ -482,7 +482,7 @@ async def get_scheduled_flow_runs_for_deployments(
     ),
     limit: int = dependencies.LimitBody(),
     db: PrefectDBInterface = Depends(provide_database_interface),
-) -> List[schemas.responses.FlowRunResponse]:
+) -> list[schemas.responses.FlowRunResponse]:
     """
     Get scheduled runs for a set of deployments. Used by a runner to poll for work.
     """
@@ -515,6 +515,7 @@ async def get_scheduled_flow_runs_for_deployments(
 
     background_tasks.add_task(
         mark_deployments_ready,
+        db=db,
         deployment_ids=deployment_ids,
     )
 
@@ -523,12 +524,12 @@ async def get_scheduled_flow_runs_for_deployments(
 
 @router.post("/count")
 async def count_deployments(
-    flows: schemas.filters.FlowFilter = None,
-    flow_runs: schemas.filters.FlowRunFilter = None,
-    task_runs: schemas.filters.TaskRunFilter = None,
-    deployments: schemas.filters.DeploymentFilter = None,
-    work_pools: schemas.filters.WorkPoolFilter = None,
-    work_pool_queues: schemas.filters.WorkQueueFilter = None,
+    flows: Optional[schemas.filters.FlowFilter] = None,
+    flow_runs: Optional[schemas.filters.FlowRunFilter] = None,
+    task_runs: Optional[schemas.filters.TaskRunFilter] = None,
+    deployments: Optional[schemas.filters.DeploymentFilter] = None,
+    work_pools: Optional[schemas.filters.WorkPoolFilter] = None,
+    work_pool_queues: Optional[schemas.filters.WorkQueueFilter] = None,
     db: PrefectDBInterface = Depends(provide_database_interface),
 ) -> int:
     """

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

@@ -250,8 +250,14 @@ def copy_directory(directory: str, path: str) -> None:
             if os.path.exists(destination):
                 shutil.rmtree(destination)
             shutil.copytree(source, destination, symlinks=True)
+            # ensure copied files are writeable
+            for root, dirs, files in os.walk(destination):
+                for f in files:
+                    os.chmod(os.path.join(root, f), 0o600)
         else:
             shutil.copy2(source, destination)
+            # Ensure copied file is writeable
+            os.chmod(destination, 0o600)
 
 
 async def custom_internal_exception_handler(

{prefect_client-3.2.9 → prefect_client-3.2.11}/src/prefect/server/api/ui/schemas.py

@@ -29,6 +29,7 @@ async def validate_obj(
         ...,
         embed=True,
         alias="schema",
+        validation_alias="schema",
         json_schema_extra={"additionalProperties": True},
     ),
     values: dict[str, Any] = Body(

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

@@ -164,6 +164,7 @@ async def read_work_queue_runs(
 
     background_tasks.add_task(
         mark_work_queues_ready,
+        db=db,
         polled_work_queue_ids=[work_queue_id],
         ready_work_queue_ids=(
             [work_queue_id] if work_queue.status == WorkQueueStatus.NOT_READY else []
@@ -172,6 +173,7 @@ async def read_work_queue_runs(
 
     background_tasks.add_task(
         mark_deployments_ready,
+        db=db,
         work_queue_ids=[work_queue_id],
     )
 

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

@@ -375,6 +375,7 @@ async def get_scheduled_flow_runs(
 
     background_tasks.add_task(
         mark_work_queues_ready,
+        db=db,
         polled_work_queue_ids=[
             wq.id for wq in work_queues if wq.status != WorkQueueStatus.NOT_READY
         ],
@@ -385,6 +386,7 @@ async def get_scheduled_flow_runs(
 
     background_tasks.add_task(
         mark_deployments_ready,
+        db=db,
         work_queue_ids=[wq.id for wq in work_queues],
     )
 

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

@@ -132,7 +132,7 @@ class RunTelemetry:
             },
         )
 
-        if traceparent := self._traceparent_from_span(self.span):
+        if traceparent := RunTelemetry.traceparent_from_span(self.span):
             run.labels[LABELS_TRACEPARENT_KEY] = traceparent
 
         return traceparent, self.span
@@ -150,7 +150,8 @@ class RunTelemetry:
         carrier = {TRACEPARENT_KEY: traceparent}
         return propagate.extract(carrier)
 
-    def _traceparent_from_span(self, span: Span) -> str | None:
+    @staticmethod
+    def traceparent_from_span(span: Span) -> str | None:
         carrier: dict[str, Any] = {}
         propagate.inject(carrier, context=trace.set_span_in_context(span))
         return carrier.get(TRACEPARENT_KEY)

{prefect_client-3.2.9 → prefect_client-3.2.11}/src/prefect/workers/base.py

@@ -933,40 +933,32 @@ class BaseWorker(abc.ABC, Generic[C, V, R]):
             )
         )
 
-    async def _check_flow_run(self, flow_run: "FlowRun") -> None:
+    async def _submit_run(self, flow_run: "FlowRun") -> None:
         """
-        Performs a check on a submitted flow run to warn the user if the flow run
-        was created from a deployment with a storage block.
+        Submits a given flow run for execution by the worker.
         """
+        run_logger = self.get_flow_run_logger(flow_run)
+
         if flow_run.deployment_id:
             assert self._client and self._client._started, (
                 "Client must be started to check flow run deployment."
             )
-            deployment = await self._client.read_deployment(flow_run.deployment_id)
-            if deployment.storage_document_id:
-                raise ValueError(
-                    f"Flow run {flow_run.id!r} was created from deployment"
-                    f" {deployment.name!r} which is configured with a storage block."
-                    " Please use an agent to execute this flow run."
-                )
-
-    async def _submit_run(self, flow_run: "FlowRun") -> None:
-        """
-        Submits a given flow run for execution by the worker.
-        """
-        run_logger = self.get_flow_run_logger(flow_run)
 
         try:
-            await self._check_flow_run(flow_run)
-        except (ValueError, ObjectNotFound):
+            await self._client.read_deployment(flow_run.deployment_id)
+        except ObjectNotFound:
             self._logger.exception(
-                (
-                    "Flow run %s did not pass checks and will not be submitted for"
-                    " execution"
-                ),
-                flow_run.id,
+                f"Deployment {flow_run.deployment_id} no longer exists. "
+                f"Flow run {flow_run.id} will not be submitted for"
+                " execution"
             )
             self._submitting_flow_run_ids.remove(flow_run.id)
+            await self._mark_flow_run_as_cancelled(
+                flow_run,
+                state_updates=dict(
+                    message=f"Deployment {flow_run.deployment_id} no longer exists, cancelled run."
+                ),
+            )
             return
 
         ready_to_submit = await self._propose_pending_state(flow_run)

{prefect_client-3.2.9 → prefect_client-3.2.11}/src/prefect/workers/process.py

@@ -16,7 +16,9 @@ checkout out the [Prefect docs](/concepts/work-pools/).
 
 from __future__ import annotations
 
+import contextlib
 import os
+import tempfile
 import threading
 from functools import partial
 from pathlib import Path
@@ -203,14 +205,23 @@ class ProcessWorker(
         configuration: ProcessJobConfiguration,
         task_status: Optional[anyio.abc.TaskStatus[int]] = None,
     ) -> ProcessWorkerResult:
-        process = await self._runner.execute_flow_run(
-            flow_run_id=flow_run.id,
-            command=configuration.command,
-            cwd=configuration.working_dir,
-            env=configuration.env,
-            stream_output=configuration.stream_output,
-            task_status=task_status,
+        if task_status is None:
+            task_status = anyio.TASK_STATUS_IGNORED
+
+        working_dir_ctx = (
+            tempfile.TemporaryDirectory(suffix="prefect")
+            if not configuration.working_dir
+            else contextlib.nullcontext(configuration.working_dir)
         )
+        with working_dir_ctx as working_dir:
+            process = await self._runner.execute_flow_run(
+                flow_run_id=flow_run.id,
+                command=configuration.command,
+                cwd=working_dir,
+                env=configuration.env,
+                stream_output=configuration.stream_output,
+                task_status=task_status,
+            )
 
         if process is None or process.returncode is None:
             raise RuntimeError("Failed to start flow run process.")

prefect_client-3.2.9/src/prefect/_build_info.py

@@ -1,5 +0,0 @@
-# Generated by versioningit
-__version__ = "3.2.9"
-__build_date__ = "2025-02-28 20:11:13.828993+00:00"
-__git_commit__ = "27eb408c48e16b1f16718b884ce7753d5b32ae35"
-__dirty__ = False