prefect-client 3.1.10__py3-none-any.whl → 3.1.12__py3-none-any.whl

prefect/tasks.py

@@ -30,7 +30,7 @@ from uuid import UUID, uuid4
 from typing_extensions import Literal, ParamSpec, Self, TypeAlias, TypeIs
 
 import prefect.states
-from prefect.cache_policies import DEFAULT, NONE, CachePolicy
+from prefect.cache_policies import DEFAULT, NO_CACHE, CachePolicy
 from prefect.client.orchestration import get_client
 from prefect.client.schemas import TaskRun
 from prefect.client.schemas.objects import (
@@ -74,7 +74,7 @@ if TYPE_CHECKING:
     from prefect.context import TaskRunContext
     from prefect.transactions import Transaction
 
-T = TypeVar("T")  # Generic type var for capturing the inner return type of async funcs
+T = TypeVar("T")
 R = TypeVar("R")  # The return type of the user's function
 P = ParamSpec("P")  # The parameters of the task
 
@@ -82,6 +82,11 @@ NUM_CHARS_DYNAMIC_KEY = 8
 
 logger = get_logger("tasks")
 
+FutureOrResult: TypeAlias = Union[PrefectFuture[T], T]
+OneOrManyFutureOrResult: TypeAlias = Union[
+    FutureOrResult[T], Iterable[FutureOrResult[T]]
+]
+
 
 def task_input_hash(
     context: "TaskRunContext", arguments: dict[str, Any]
@@ -436,7 +441,9 @@ class Task(Generic[P, R]):
         if persist_result is None:
             if any(
                 [
-                    cache_policy and cache_policy != NONE and cache_policy != NotSet,
+                    cache_policy
+                    and cache_policy != NO_CACHE
+                    and cache_policy != NotSet,
                     cache_key_fn is not None,
                     result_storage_key is not None,
                     result_storage is not None,
@@ -446,8 +453,8 @@ class Task(Generic[P, R]):
                 persist_result = True
 
         if persist_result is False:
-            self.cache_policy = None if cache_policy is None else NONE
-            if cache_policy and cache_policy is not NotSet and cache_policy != NONE:
+            self.cache_policy = None if cache_policy is None else NO_CACHE
+            if cache_policy and cache_policy is not NotSet and cache_policy != NO_CACHE:
                 logger.warning(
                     "Ignoring `cache_policy` because `persist_result` is False"
                 )
@@ -737,7 +744,7 @@ class Task(Generic[P, R]):
         parameters: Optional[dict[str, Any]] = None,
         flow_run_context: Optional[FlowRunContext] = None,
         parent_task_run_context: Optional[TaskRunContext] = None,
-        wait_for: Optional[Iterable[PrefectFuture[R]]] = None,
+        wait_for: Optional[OneOrManyFutureOrResult[Any]] = None,
         extra_task_inputs: Optional[dict[str, set[TaskRunInput]]] = None,
         deferred: bool = False,
     ) -> TaskRun:
@@ -838,7 +845,7 @@ class Task(Generic[P, R]):
         parameters: Optional[dict[str, Any]] = None,
         flow_run_context: Optional[FlowRunContext] = None,
         parent_task_run_context: Optional[TaskRunContext] = None,
-        wait_for: Optional[Iterable[PrefectFuture[R]]] = None,
+        wait_for: Optional[OneOrManyFutureOrResult[Any]] = None,
         extra_task_inputs: Optional[dict[str, set[TaskRunInput]]] = None,
         deferred: bool = False,
     ) -> TaskRun:
@@ -952,6 +959,8 @@ class Task(Generic[P, R]):
     def __call__(
         self: "Task[P, NoReturn]",
         *args: P.args,
+        return_state: Literal[False],
+        wait_for: Optional[OneOrManyFutureOrResult[Any]] = None,
         **kwargs: P.kwargs,
     ) -> None:
         # `NoReturn` matches if a type can't be inferred for the function which stops a
@@ -960,28 +969,41 @@ class Task(Generic[P, R]):
 
     @overload
     def __call__(
-        self: "Task[P, T]",
+        self: "Task[P, R]",
         *args: P.args,
+        return_state: Literal[True],
+        wait_for: Optional[OneOrManyFutureOrResult[Any]] = None,
         **kwargs: P.kwargs,
-    ) -> T:
+    ) -> State[R]:
         ...
 
     @overload
     def __call__(
-        self: "Task[P, T]",
+        self: "Task[P, R]",
         *args: P.args,
-        return_state: Literal[True],
+        return_state: Literal[False],
+        wait_for: Optional[OneOrManyFutureOrResult[Any]] = None,
         **kwargs: P.kwargs,
-    ) -> State[T]:
+    ) -> R:
         ...
 
+    @overload
     def __call__(
-        self,
+        self: "Task[P, R]",
+        *args: P.args,
+        return_state: Literal[False] = False,
+        wait_for: Optional[OneOrManyFutureOrResult[Any]] = None,
+        **kwargs: P.kwargs,
+    ) -> R:
+        ...
+
+    def __call__(
+        self: "Union[Task[P, R], Task[P, NoReturn]]",
         *args: P.args,
         return_state: bool = False,
-        wait_for: Optional[Iterable[PrefectFuture[R]]] = None,
+        wait_for: Optional[OneOrManyFutureOrResult[Any]] = None,
         **kwargs: P.kwargs,
-    ):
+    ) -> Union[R, State[R], None]:
         """
         Run the task and return the result. If `return_state` is True returns
         the result is wrapped in a Prefect State which provides error handling.
@@ -1013,53 +1035,57 @@ class Task(Generic[P, R]):
 
     @overload
     def submit(
-        self: "Task[P, NoReturn]",
+        self: "Task[P, R]",
         *args: P.args,
         **kwargs: P.kwargs,
-    ) -> PrefectFuture[NoReturn]:
-        # `NoReturn` matches if a type can't be inferred for the function which stops a
-        # sync function from matching the `Coroutine` overload
+    ) -> PrefectFuture[R]:
         ...
 
     @overload
     def submit(
-        self: "Task[P, Coroutine[Any, Any, T]]",
+        self: "Task[P, Coroutine[Any, Any, R]]",
         *args: P.args,
+        return_state: Literal[False],
+        wait_for: Optional[OneOrManyFutureOrResult[Any]] = None,
         **kwargs: P.kwargs,
-    ) -> PrefectFuture[T]:
+    ) -> PrefectFuture[R]:
         ...
 
     @overload
     def submit(
-        self: "Task[P, T]",
+        self: "Task[P, R]",
         *args: P.args,
+        return_state: Literal[False],
+        wait_for: Optional[OneOrManyFutureOrResult[Any]] = None,
         **kwargs: P.kwargs,
-    ) -> PrefectFuture[T]:
+    ) -> PrefectFuture[R]:
         ...
 
     @overload
     def submit(
-        self: "Task[P, Coroutine[Any, Any, T]]",
+        self: "Task[P, Coroutine[Any, Any, R]]",
         *args: P.args,
         return_state: Literal[True],
+        wait_for: Optional[OneOrManyFutureOrResult[Any]] = None,
         **kwargs: P.kwargs,
-    ) -> State[T]:
+    ) -> State[R]:
         ...
 
     @overload
     def submit(
-        self: "Task[P, T]",
+        self: "Task[P, R]",
         *args: P.args,
         return_state: Literal[True],
+        wait_for: Optional[OneOrManyFutureOrResult[Any]] = None,
         **kwargs: P.kwargs,
-    ) -> State[T]:
+    ) -> State[R]:
         ...
 
     def submit(
-        self,
+        self: "Union[Task[P, R], Task[P, Coroutine[Any, Any, R]]]",
         *args: Any,
         return_state: bool = False,
-        wait_for: Optional[Iterable[PrefectFuture[R]]] = None,
+        wait_for: Optional[OneOrManyFutureOrResult[Any]] = None,
         **kwargs: Any,
     ):
         """
@@ -1584,11 +1610,39 @@ def task(__fn: Callable[P, R]) -> Task[P, R]:
 @overload
 def task(
     __fn: Literal[None] = None,
+    *,
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+    tags: Optional[Iterable[str]] = None,
+    version: Optional[str] = None,
+    cache_policy: Union[CachePolicy, type[NotSet]] = NotSet,
+    cache_key_fn: Optional[
+        Callable[["TaskRunContext", dict[str, Any]], Optional[str]]
+    ] = None,
+    cache_expiration: Optional[datetime.timedelta] = None,
+    task_run_name: Optional[TaskRunNameValueOrCallable] = None,
+    retries: int = 0,
+    retry_delay_seconds: Union[
+        float, int, list[float], Callable[[int], list[float]], None
+    ] = None,
+    retry_jitter_factor: Optional[float] = None,
+    persist_result: Optional[bool] = None,
+    result_storage: Optional[ResultStorage] = None,
+    result_storage_key: Optional[str] = None,
+    result_serializer: Optional[ResultSerializer] = None,
+    cache_result_in_memory: bool = True,
+    timeout_seconds: Union[int, float, None] = None,
+    log_prints: Optional[bool] = None,
+    refresh_cache: Optional[bool] = None,
+    on_completion: Optional[list[StateHookCallable]] = None,
+    on_failure: Optional[list[StateHookCallable]] = None,
+    retry_condition_fn: Optional[Callable[[Task[P, Any], TaskRun, State], bool]] = None,
+    viz_return_value: Any = None,
 ) -> Callable[[Callable[P, R]], Task[P, R]]:
     ...
 
 
-@overload
+@overload  # TODO: do we need this overload?
 def task(
     *,
     name: Optional[str] = None,
@@ -1619,7 +1673,7 @@ def task(
     refresh_cache: Optional[bool] = None,
     on_completion: Optional[list[StateHookCallable]] = None,
     on_failure: Optional[list[StateHookCallable]] = None,
-    retry_condition_fn: Optional[Callable[["Task[P, R]", TaskRun, State], bool]] = None,
+    retry_condition_fn: Optional[Callable[[Task[P, Any], TaskRun, State], bool]] = None,
     viz_return_value: Any = None,
 ) -> Callable[[Callable[P, R]], Task[P, R]]:
     ...
@@ -1653,7 +1707,7 @@ def task(
     refresh_cache: Optional[bool] = None,
     on_completion: Optional[list[StateHookCallable]] = None,
     on_failure: Optional[list[StateHookCallable]] = None,
-    retry_condition_fn: Optional[Callable[["Task[P, R]", TaskRun, State], bool]] = None,
+    retry_condition_fn: Optional[Callable[[Task[P, Any], TaskRun, State], bool]] = None,
     viz_return_value: Any = None,
 ):
     """
@@ -1685,10 +1739,10 @@ def task(
             callable that, given the total number of retries, generates a list of retry
             delays. If a number of seconds, that delay will be applied to all retries.
             If a list, each retry will wait for the corresponding delay before retrying.
-            When passing a callable or a list, the number of configured retry delays
-            cannot exceed 50.
-        retry_jitter_factor: An optional factor that defines the factor to which a retry
-            can be jittered in order to avoid a "thundering herd".
+            When passing a callable or a list, the number of
+            configured retry delays cannot exceed 50.
+        retry_jitter_factor: An optional factor that defines the factor to which a
+            retry can be jittered in order to avoid a "thundering herd".
         persist_result: A toggle indicating whether the result of this task
             should be persisted to result storage. Defaults to `None`, which
             indicates that the global default should be used (which is `True` by

prefect/telemetry/bootstrap.py

@@ -2,6 +2,9 @@ from typing import TYPE_CHECKING, Union
 
 import prefect.settings
 from prefect.client.base import ServerType, determine_server_type
+from prefect.logging.loggers import get_logger
+
+logger = get_logger(__name__)
 
 if TYPE_CHECKING:
     from opentelemetry.sdk._logs import LoggerProvider
@@ -16,30 +19,28 @@ def setup_telemetry() -> (
     ]
 ):
     settings = prefect.settings.get_current_settings()
-    if not settings.experiments.telemetry_enabled:
-        return None, None, None
 
     server_type = determine_server_type()
     if server_type != ServerType.CLOUD:
         return None, None, None
 
+    if not settings.cloud.enable_orchestration_telemetry:
+        return None, None, None
+
     if not settings.api.key:
-        raise ValueError(
+        logger.warning(
             "A Prefect Cloud API key is required to enable telemetry. Please set "
             "the `PREFECT_API_KEY` environment variable or authenticate with "
             "Prefect Cloud via the `prefect cloud login` command."
         )
+        return None, None, None
 
     assert settings.api.url
 
     # This import is here to defer importing of the `opentelemetry` packages.
     try:
         from .instrumentation import setup_exporters
-    except ImportError as exc:
-        raise ValueError(
-            "Unable to import OpenTelemetry instrumentation libraries. Please "
-            "ensure you have installed the `otel` extra when installing Prefect: "
-            "`pip install 'prefect[otel]'`"
-        ) from exc
+    except ImportError:
+        return None, None, None
 
     return setup_exporters(settings.api.url, settings.api.key.get_secret_value())

prefect/telemetry/run_telemetry.py

@@ -53,10 +53,9 @@ class RunTelemetry:
         self,
         run: FlowOrTaskRun,
         client: PrefectClient,
-        name: Optional[str] = None,
         parameters: Optional[dict[str, Any]] = None,
     ):
-        traceparent, span = self._start_span(run, name, parameters)
+        traceparent, span = self._start_span(run, parameters)
 
         if self._run_type(run) == "flow" and traceparent:
             # Only explicitly update labels if the run is a flow as task runs
@@ -71,10 +70,9 @@ class RunTelemetry:
         self,
         run: FlowOrTaskRun,
         client: SyncPrefectClient,
-        name: Optional[str] = None,
         parameters: Optional[dict[str, Any]] = None,
     ):
-        traceparent, span = self._start_span(run, name, parameters)
+        traceparent, span = self._start_span(run, parameters)
 
         if self._run_type(run) == "flow" and traceparent:
             # Only explicitly update labels if the run is a flow as task runs
@@ -86,7 +84,6 @@ class RunTelemetry:
     def _start_span(
         self,
         run: FlowOrTaskRun,
-        name: Optional[str] = None,
         parameters: Optional[dict[str, Any]] = None,
     ) -> tuple[Optional[str], Span]:
         """
@@ -117,10 +114,10 @@ class RunTelemetry:
         run_type = self._run_type(run)
 
         self.span = self._tracer.start_span(
-            name=name or run.name,
+            name=run.name,
             context=context,
             attributes={
-                "prefect.run.name": name or run.name,
+                "prefect.run.name": run.name,
                 "prefect.run.type": run_type,
                 "prefect.run.id": str(run.id),
                 "prefect.tags": run.tags,
@@ -152,7 +149,7 @@ class RunTelemetry:
         return propagate.extract(carrier)
 
     def _traceparent_from_span(self, span: Span) -> Optional[str]:
-        carrier = {}
+        carrier: dict[str, Any] = {}
         propagate.inject(carrier, context=trace.set_span_in_context(span))
         return carrier.get(TRACEPARENT_KEY)
 
@@ -198,6 +195,14 @@ class RunTelemetry:
                 },
             )
 
+    def update_run_name(self, name: str) -> None:
+        """
+        Update the name of the run.
+        """
+        if self.span:
+            self.span.update_name(name=name)
+            self.span.set_attribute("prefect.run.name", name)
+
     def _parent_run(self) -> Union[FlowOrTaskRun, None]:
         """
         Identify the "parent run" for the current execution context.

prefect/telemetry/services.py

@@ -53,6 +53,8 @@ class QueueingSpanExporter(BaseQueueingExporter[ReadableSpan], SpanExporter):
 
     def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
         for item in spans:
+            if self._stopped:
+                break
             self.send(item)
         return SpanExportResult.SUCCESS
 
@@ -65,4 +67,6 @@ class QueueingLogExporter(BaseQueueingExporter[LogData], LogExporter):
 
     def export(self, batch: Sequence[LogData]) -> None:
         for item in batch:
+            if self._stopped:
+                break
             self.send(item)

prefect/transactions.py

@@ -24,10 +24,7 @@ from prefect.exceptions import (
     SerializationError,
 )
 from prefect.logging.loggers import LoggingAdapter, get_logger, get_run_logger
-from prefect.records import RecordStore
-from prefect.records.base import TransactionRecord
 from prefect.results import (
-    BaseResult,
     ResultRecord,
     ResultStore,
     get_result_store,
@@ -61,7 +58,7 @@ class Transaction(ContextModel):
     A base model for transaction state.
     """
 
-    store: Union[RecordStore, ResultStore, None] = None
+    store: Optional[ResultStore] = None
     key: Optional[str] = None
     children: List["Transaction"] = Field(default_factory=list)
     commit_mode: Optional[CommitMode] = None
@@ -254,15 +251,11 @@ class Transaction(ContextModel):
         ):
             self.state = TransactionState.COMMITTED
 
-    def read(self) -> Union["BaseResult[Any]", ResultRecord[Any], None]:
+    def read(self) -> Optional[ResultRecord[Any]]:
         if self.store and self.key:
             record = self.store.read(key=self.key)
             if isinstance(record, ResultRecord):
                 return record
-            # for backwards compatibility, if we encounter a transaction record, return the result
-            # This happens when the transaction is using a `ResultStore`
-            if isinstance(record, TransactionRecord):
-                return record.result
         return None
 
     def reset(self) -> None:
@@ -315,11 +308,7 @@ class Transaction(ContextModel):
 
             if self.store and self.key and self.write_on_commit:
                 if isinstance(self.store, ResultStore):
-                    if isinstance(self._staged_value, BaseResult):
-                        self.store.write(
-                            key=self.key, obj=self._staged_value.get(_sync=True)
-                        )
-                    elif isinstance(self._staged_value, ResultRecord):
+                    if isinstance(self._staged_value, ResultRecord):
                         self.store.persist_result_record(
                             result_record=self._staged_value
                         )
@@ -436,7 +425,7 @@ def get_transaction() -> Optional[Transaction]:
 @contextmanager
 def transaction(
     key: Optional[str] = None,
-    store: Union[RecordStore, ResultStore, None] = None,
+    store: Optional[ResultStore] = None,
     commit_mode: Optional[CommitMode] = None,
     isolation_level: Optional[IsolationLevel] = None,
     overwrite: bool = False,

prefect/utilities/_git.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import subprocess
+import sys
+
+
+def get_git_remote_origin_url() -> str | None:
+    """
+    Returns the git remote origin URL for the current directory.
+    """
+    try:
+        origin_url = subprocess.check_output(
+            ["git", "config", "--get", "remote.origin.url"],
+            shell=sys.platform == "win32",
+            stderr=subprocess.DEVNULL,
+        )
+        origin_url = origin_url.decode().strip()
+    except subprocess.CalledProcessError:
+        return None
+
+    return origin_url
+
+
+def get_git_branch() -> str | None:
+    """
+    Returns the git branch for the current directory.
+    """
+    try:
+        branch = subprocess.check_output(["git", "rev-parse", "--abbrev-ref", "HEAD"])
+        branch = branch.decode().strip()
+    except subprocess.CalledProcessError:
+        return None
+
+    return branch

prefect/utilities/asyncutils.py

@@ -77,7 +77,7 @@ def get_thread_limiter() -> anyio.CapacityLimiter:
 
 def is_async_fn(
     func: _SyncOrAsyncCallable[P, R],
-) -> TypeGuard[Callable[P, Awaitable[R]]]:
+) -> TypeGuard[Callable[P, Coroutine[Any, Any, Any]]]:
     """
     Returns `True` if a function returns a coroutine.
 

prefect/utilities/engine.py

@@ -45,7 +45,7 @@ from prefect.exceptions import (
 from prefect.flows import Flow
 from prefect.futures import PrefectFuture
 from prefect.logging.loggers import get_logger
-from prefect.results import BaseResult, ResultRecord, should_persist_result
+from prefect.results import ResultRecord, should_persist_result
 from prefect.settings import PREFECT_LOGGING_LOG_PRINTS
 from prefect.states import State
 from prefect.tasks import Task
@@ -283,10 +283,6 @@ async def resolve_inputs(
     return resolved_parameters
 
 
-def _is_base_result(data: Any) -> TypeIs[BaseResult[Any]]:
-    return isinstance(data, BaseResult)
-
-
 def _is_result_record(data: Any) -> TypeIs[ResultRecord[Any]]:
     return isinstance(data, ResultRecord)
 
@@ -335,11 +331,7 @@ async def propose_state(
     # Handle task and sub-flow tracing
     if state.is_final():
         result: Any
-        if _is_base_result(state.data) and state.data.has_cached_object():
-            # Avoid fetching the result unless it is cached, otherwise we defeat
-            # the purpose of disabling `cache_result_in_memory`
-            result = state.result(raise_on_failure=False, fetch=True)
-        elif _is_result_record(state.data):
+        if _is_result_record(state.data):
             result = state.data.result
         else:
             result = state.data
@@ -451,13 +443,7 @@ def propose_state_sync(
 
     # Handle task and sub-flow tracing
     if state.is_final():
-        if _is_base_result(state.data) and state.data.has_cached_object():
-            # Avoid fetching the result unless it is cached, otherwise we defeat
-            # the purpose of disabling `cache_result_in_memory`
-            result = state.result(raise_on_failure=False, fetch=True)
-            if asyncio.iscoroutine(result):
-                result = run_coro_as_sync(result)
-        elif _is_result_record(state.data):
+        if _is_result_record(state.data):
             result = state.data.result
         else:
             result = state.data
@@ -636,8 +622,6 @@ def emit_task_run_state_change_event(
 
     if _is_result_record(validated_state.data) and should_persist_result():
         data = validated_state.data.metadata.model_dump(mode="json")
-    elif _is_base_result(validated_state.data):
-        data = validated_state.data.model_dump(mode="json")
     else:
         data = None
 

prefect/utilities/generics.py

@@ -0,0 +1,18 @@
+from typing import Any, TypeVar
+
+from pydantic import BaseModel
+from pydantic_core import SchemaValidator, core_schema
+
+T = TypeVar("T", bound=BaseModel)
+
+ListValidator = SchemaValidator(
+    schema=core_schema.list_schema(
+        items_schema=core_schema.dict_schema(
+            keys_schema=core_schema.str_schema(), values_schema=core_schema.any_schema()
+        )
+    )
+)
+
+
+def validate_list(model: type[T], input: Any) -> list[T]:
+    return [model.model_validate(item) for item in ListValidator.validate_python(input)]

prefect/utilities/templating.py

@@ -1,7 +1,17 @@
 import enum
 import os
 import re
-from typing import TYPE_CHECKING, Any, NamedTuple, Optional, TypeVar, Union, cast
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Literal,
+    NamedTuple,
+    Optional,
+    TypeVar,
+    Union,
+    cast,
+    overload,
+)
 
 from prefect.client.utilities import inject_client
 from prefect.utilities.annotations import NotSet
@@ -79,6 +89,20 @@ def find_placeholders(template: T) -> set[Placeholder]:
         raise ValueError(f"Unexpected type: {type(template)}")
 
 
+@overload
+def apply_values(
+    template: T, values: dict[str, Any], remove_notset: Literal[True] = True
+) -> T:
+    ...
+
+
+@overload
+def apply_values(
+    template: T, values: dict[str, Any], remove_notset: Literal[False] = False
+) -> Union[T, type[NotSet]]:
+    ...
+
+
 def apply_values(
     template: T, values: dict[str, Any], remove_notset: bool = True
 ) -> Union[T, type[NotSet]]:

prefect/workers/base.py

@@ -866,6 +866,9 @@ class BaseWorker(abc.ABC):
 
         for flow_run in submittable_flow_runs:
             if flow_run.id in self._submitting_flow_run_ids:
+                self._logger.debug(
+                    f"Skipping {flow_run.id} because it's already being submitted"
+                )
                 continue
             try:
                 if self._limiter:
@@ -945,7 +948,7 @@ class BaseWorker(abc.ABC):
             return
 
         ready_to_submit = await self._propose_pending_state(flow_run)
-
+        self._logger.debug(f"Ready to submit {flow_run.id}: {ready_to_submit}")
         if ready_to_submit:
             readiness_result = await self._runs_task_group.start(
                 self._submit_run_and_capture_errors, flow_run
@@ -969,10 +972,9 @@ class BaseWorker(abc.ABC):
             else:
                 # If the run is not ready to submit, release the concurrency slot
                 self._release_limit_slot(flow_run.id)
-
-            self._submitting_flow_run_ids.remove(flow_run.id)
         else:
             self._release_limit_slot(flow_run.id)
+        self._submitting_flow_run_ids.remove(flow_run.id)
 
     async def _submit_run_and_capture_errors(
         self, flow_run: "FlowRun", task_status: Optional[anyio.abc.TaskStatus] = None
@@ -1102,6 +1104,7 @@ class BaseWorker(abc.ABC):
                     f"Server sent an abort signal: {exc}"
                 ),
             )
+
             return False
         except Exception:
             run_logger.exception(

prefect/workers/process.py

@@ -85,7 +85,7 @@ class ProcessJobConfiguration(BaseJobConfiguration):
 
     @field_validator("working_dir")
     @classmethod
-    def validate_command(cls, v):
+    def validate_command(cls, v: str) -> str:
         return validate_command(v)
 
     def prepare_for_flow_run(