prefect-client 3.1.9__py3-none-any.whl → 3.1.11__py3-none-any.whl

prefect/settings/models/server/services.py

@@ -1,6 +1,7 @@
 from datetime import timedelta
+from typing import ClassVar
 
-from pydantic import AliasChoices, AliasPath, Field
+from pydantic import AliasChoices, AliasPath, ConfigDict, Field
 
 from prefect.settings.base import PrefectBaseSettings, _build_settings_config
 
@@ -10,7 +11,7 @@ class ServerServicesCancellationCleanupSettings(PrefectBaseSettings):
     Settings for controlling the cancellation cleanup service
     """
 
-    model_config = _build_settings_config(
+    model_config: ClassVar[ConfigDict] = _build_settings_config(
         ("server", "services", "cancellation_cleanup")
     )
 
@@ -40,7 +41,9 @@ class ServerServicesEventPersisterSettings(PrefectBaseSettings):
     Settings for controlling the event persister service
     """
 
-    model_config = _build_settings_config(("server", "services", "event_persister"))
+    model_config: ClassVar[ConfigDict] = _build_settings_config(
+        ("server", "services", "event_persister")
+    )
 
     enabled: bool = Field(
         default=True,
@@ -80,7 +83,7 @@ class ServerServicesFlowRunNotificationsSettings(PrefectBaseSettings):
     Settings for controlling the flow run notifications service
     """
 
-    model_config = _build_settings_config(
+    model_config: ClassVar[ConfigDict] = _build_settings_config(
         ("server", "services", "flow_run_notifications")
     )
 
@@ -100,7 +103,9 @@ class ServerServicesForemanSettings(PrefectBaseSettings):
     Settings for controlling the foreman service
     """
 
-    model_config = _build_settings_config(("server", "services", "foreman"))
+    model_config: ClassVar[ConfigDict] = _build_settings_config(
+        ("server", "services", "foreman")
+    )
 
     enabled: bool = Field(
         default=True,
@@ -179,7 +184,9 @@ class ServerServicesLateRunsSettings(PrefectBaseSettings):
     Settings for controlling the late runs service
     """
 
-    model_config = _build_settings_config(("server", "services", "late_runs"))
+    model_config: ClassVar[ConfigDict] = _build_settings_config(
+        ("server", "services", "late_runs")
+    )
 
     enabled: bool = Field(
         default=True,
@@ -221,7 +228,9 @@ class ServerServicesSchedulerSettings(PrefectBaseSettings):
     Settings for controlling the scheduler service
     """
 
-    model_config = _build_settings_config(("server", "services", "scheduler"))
+    model_config: ClassVar[ConfigDict] = _build_settings_config(
+        ("server", "services", "scheduler")
+    )
 
     enabled: bool = Field(
         default=True,
@@ -344,7 +353,9 @@ class ServerServicesPauseExpirationsSettings(PrefectBaseSettings):
     Settings for controlling the pause expiration service
     """
 
-    model_config = _build_settings_config(("server", "services", "pause_expirations"))
+    model_config: ClassVar[ConfigDict] = _build_settings_config(
+        ("server", "services", "pause_expirations")
+    )
 
     enabled: bool = Field(
         default=True,
@@ -378,7 +389,9 @@ class ServerServicesTaskRunRecorderSettings(PrefectBaseSettings):
     Settings for controlling the task run recorder service
     """
 
-    model_config = _build_settings_config(("server", "services", "task_run_recorder"))
+    model_config: ClassVar[ConfigDict] = _build_settings_config(
+        ("server", "services", "task_run_recorder")
+    )
 
     enabled: bool = Field(
         default=True,
@@ -396,7 +409,9 @@ class ServerServicesTriggersSettings(PrefectBaseSettings):
     Settings for controlling the triggers service
     """
 
-    model_config = _build_settings_config(("server", "services", "triggers"))
+    model_config: ClassVar[ConfigDict] = _build_settings_config(
+        ("server", "services", "triggers")
+    )
 
     enabled: bool = Field(
         default=True,
@@ -414,7 +429,7 @@ class ServerServicesSettings(PrefectBaseSettings):
     Settings for controlling server services
     """
 
-    model_config = _build_settings_config(("server", "services"))
+    model_config: ClassVar[ConfigDict] = _build_settings_config(("server", "services"))
 
     cancellation_cleanup: ServerServicesCancellationCleanupSettings = Field(
         default_factory=ServerServicesCancellationCleanupSettings,

prefect/settings/models/server/tasks.py

@@ -1,6 +1,7 @@
 from datetime import timedelta
+from typing import ClassVar
 
-from pydantic import AliasChoices, AliasPath, Field
+from pydantic import AliasChoices, AliasPath, ConfigDict, Field
 
 from prefect.settings.base import PrefectBaseSettings, _build_settings_config
 
@@ -10,7 +11,9 @@ class ServerTasksSchedulingSettings(PrefectBaseSettings):
     Settings for controlling server-side behavior related to task scheduling
     """
 
-    model_config = _build_settings_config(("server", "tasks", "scheduling"))
+    model_config: ClassVar[ConfigDict] = _build_settings_config(
+        ("server", "tasks", "scheduling")
+    )
 
     max_scheduled_queue_size: int = Field(
         default=1000,
@@ -48,7 +51,7 @@ class ServerTasksSettings(PrefectBaseSettings):
     Settings for controlling server-side behavior related to tasks
     """
 
-    model_config = _build_settings_config(("server", "tasks"))
+    model_config: ClassVar[ConfigDict] = _build_settings_config(("server", "tasks"))
 
     tag_concurrency_slot_wait_seconds: float = Field(
         default=30,

prefect/settings/models/server/ui.py

@@ -1,12 +1,12 @@
-from typing import Optional
+from typing import ClassVar, Optional
 
-from pydantic import AliasChoices, AliasPath, Field
+from pydantic import AliasChoices, AliasPath, ConfigDict, Field
 
 from prefect.settings.base import PrefectBaseSettings, _build_settings_config
 
 
 class ServerUISettings(PrefectBaseSettings):
-    model_config = _build_settings_config(("server", "ui"))
+    model_config: ClassVar[ConfigDict] = _build_settings_config(("server", "ui"))
 
     enabled: bool = Field(
         default=True,

prefect/settings/models/tasks.py

@@ -1,12 +1,12 @@
-from typing import Optional, Union
+from typing import ClassVar, Optional, Union
 
-from pydantic import AliasChoices, AliasPath, Field
+from pydantic import AliasChoices, AliasPath, ConfigDict, Field
 
 from prefect.settings.base import PrefectBaseSettings, _build_settings_config
 
 
 class TasksRunnerSettings(PrefectBaseSettings):
-    model_config = _build_settings_config(("tasks", "runner"))
+    model_config: ClassVar[ConfigDict] = _build_settings_config(("tasks", "runner"))
 
     thread_pool_max_workers: Optional[int] = Field(
         default=None,
@@ -21,7 +21,7 @@ class TasksRunnerSettings(PrefectBaseSettings):
 
 
 class TasksSchedulingSettings(PrefectBaseSettings):
-    model_config = _build_settings_config(("tasks", "scheduling"))
+    model_config: ClassVar[ConfigDict] = _build_settings_config(("tasks", "scheduling"))
 
     default_storage_block: Optional[str] = Field(
         default=None,
@@ -45,7 +45,7 @@ class TasksSchedulingSettings(PrefectBaseSettings):
 
 
 class TasksSettings(PrefectBaseSettings):
-    model_config = _build_settings_config(("tasks",))
+    model_config: ClassVar[ConfigDict] = _build_settings_config(("tasks",))
 
     refresh_cache: bool = Field(
         default=False,

prefect/settings/models/testing.py

@@ -1,12 +1,12 @@
-from typing import Any, Optional
+from typing import Any, ClassVar, Optional
 
-from pydantic import AliasChoices, AliasPath, Field
+from pydantic import AliasChoices, AliasPath, ConfigDict, Field
 
 from prefect.settings.base import PrefectBaseSettings, _build_settings_config
 
 
 class TestingSettings(PrefectBaseSettings):
-    model_config = _build_settings_config(("testing",))
+    model_config: ClassVar[ConfigDict] = _build_settings_config(("testing",))
 
     test_mode: bool = Field(
         default=False,

prefect/settings/models/worker.py

@@ -1,10 +1,12 @@
-from pydantic import Field
+from typing import ClassVar
+
+from pydantic import ConfigDict, Field
 
 from prefect.settings.base import PrefectBaseSettings, _build_settings_config
 
 
 class WorkerWebserverSettings(PrefectBaseSettings):
-    model_config = _build_settings_config(("worker", "webserver"))
+    model_config: ClassVar[ConfigDict] = _build_settings_config(("worker", "webserver"))
 
     host: str = Field(
         default="0.0.0.0",
@@ -18,7 +20,7 @@ class WorkerWebserverSettings(PrefectBaseSettings):
 
 
 class WorkerSettings(PrefectBaseSettings):
-    model_config = _build_settings_config(("worker",))
+    model_config: ClassVar[ConfigDict] = _build_settings_config(("worker",))
 
     heartbeat_seconds: float = Field(
         default=30,

prefect/settings/profiles.py

@@ -1,7 +1,18 @@
 import inspect
 import warnings
 from pathlib import Path
-from typing import Annotated, Any, Dict, Iterable, List, Optional, Set, Tuple, Union
+from typing import (
+    Annotated,
+    Any,
+    ClassVar,
+    Dict,
+    Iterable,
+    List,
+    Optional,
+    Set,
+    Tuple,
+    Union,
+)
 
 import toml
 from pydantic import (
@@ -48,7 +59,9 @@ def _cast_settings(
 class Profile(BaseModel):
     """A user profile containing settings."""
 
-    model_config = ConfigDict(extra="ignore", arbitrary_types_allowed=True)
+    model_config: ClassVar[ConfigDict] = ConfigDict(
+        extra="ignore", arbitrary_types_allowed=True
+    )
 
     name: str
     settings: Annotated[Dict[Setting, Any], BeforeValidator(_cast_settings)] = Field(

prefect/states.py

@@ -29,7 +29,6 @@ from prefect.exceptions import (
 )
 from prefect.logging.loggers import get_logger, get_run_logger
 from prefect.results import (
-    BaseResult,
     R,
     ResultRecord,
     ResultRecordMetadata,
@@ -140,7 +139,7 @@ async def _get_state_result(
     ):
         raise await get_state_exception(state)
 
-    if isinstance(state.data, (BaseResult, ResultRecordMetadata)):
+    if isinstance(state.data, ResultRecordMetadata):
         result = await _get_state_result_data_with_retries(
             state, retry_result_failure=retry_result_failure
         )
@@ -326,7 +325,7 @@ async def return_value_to_state(
         state = retval
         # Unless the user has already constructed a result explicitly, use the store
         # to update the data to the correct type
-        if not isinstance(state.data, (BaseResult, ResultRecord, ResultRecordMetadata)):
+        if not isinstance(state.data, (ResultRecord, ResultRecordMetadata)):
             result_record = result_store.create_result_record(
                 state.data,
                 key=key,
@@ -402,7 +401,7 @@ async def return_value_to_state(
         data = retval
 
     # Otherwise, they just gave data and this is a completed retval
-    if isinstance(data, (BaseResult, ResultRecord)):
+    if isinstance(data, ResultRecord):
         return Completed(data=data)
     else:
         result_record = result_store.create_result_record(
@@ -457,9 +456,7 @@ async def get_state_exception(state: State) -> BaseException:
     else:
         raise ValueError(f"Expected failed or crashed state got {state!r}.")
 
-    if isinstance(state.data, BaseResult):
-        result = await _get_state_result_data_with_retries(state)
-    elif isinstance(state.data, ResultRecord):
+    if isinstance(state.data, ResultRecord):
         result = state.data.result
     elif isinstance(state.data, ResultRecordMetadata):
         record = await ResultRecord._from_metadata(state.data)

prefect/task_engine.py

@@ -9,18 +9,16 @@ from dataclasses import dataclass, field
 from functools import partial
 from textwrap import dedent
 from typing import (
+    TYPE_CHECKING,
     Any,
     AsyncGenerator,
     Callable,
     Coroutine,
-    Dict,
     Generator,
     Generic,
-    Iterable,
     Literal,
     Optional,
     Sequence,
-    Set,
     Type,
     TypeVar,
     Union,
@@ -32,7 +30,6 @@ import pendulum
 from opentelemetry import trace
 from typing_extensions import ParamSpec
 
-from prefect import Task
 from prefect.client.orchestration import PrefectClient, SyncPrefectClient, get_client
 from prefect.client.schemas import TaskRun
 from prefect.client.schemas.objects import State, TaskRunInput
@@ -55,10 +52,8 @@ from prefect.exceptions import (
     TerminationSignal,
     UpstreamTaskError,
 )
-from prefect.futures import PrefectFuture
 from prefect.logging.loggers import get_logger, patch_print, task_run_logger
 from prefect.results import (
-    BaseResult,
     ResultRecord,
     _format_user_supplied_storage_key,
     get_result_store,
@@ -95,6 +90,9 @@ from prefect.utilities.engine import (
 from prefect.utilities.math import clamped_poisson_interval
 from prefect.utilities.timeout import timeout, timeout_async
 
+if TYPE_CHECKING:
+    from prefect.tasks import OneOrManyFutureOrResult, Task
+
 P = ParamSpec("P")
 R = TypeVar("R")
 
@@ -107,13 +105,13 @@ class TaskRunTimeoutError(TimeoutError):
 
 @dataclass
 class BaseTaskRunEngine(Generic[P, R]):
-    task: Union[Task[P, R], Task[P, Coroutine[Any, Any, R]]]
+    task: Union["Task[P, R]", "Task[P, Coroutine[Any, Any, R]]"]
     logger: logging.Logger = field(default_factory=lambda: get_logger("engine"))
-    parameters: Optional[Dict[str, Any]] = None
+    parameters: Optional[dict[str, Any]] = None
     task_run: Optional[TaskRun] = None
     retries: int = 0
-    wait_for: Optional[Iterable[PrefectFuture]] = None
-    context: Optional[Dict[str, Any]] = None
+    wait_for: Optional["OneOrManyFutureOrResult[Any]"] = None
+    context: Optional[dict[str, Any]] = None
     # holds the return value from the user code
     _return_value: Union[R, Type[NotSet]] = NotSet
     # holds the exception raised by the user code, if any
@@ -210,6 +208,7 @@ class BaseTaskRunEngine(Generic[P, R]):
             )
             self.task_run.name = task_run_name
             self._task_name_set = True
+            self._telemetry.update_run_name(name=task_run_name)
 
     def _wait_for_dependencies(self):
         if not self.wait_for:
@@ -305,7 +304,7 @@ class SyncTaskRunEngine(BaseTaskRunEngine[P, R]):
 
     def can_retry(self, exc: Exception) -> bool:
         retry_condition: Optional[
-            Callable[[Task[P, Coroutine[Any, Any, R]], TaskRun, State], bool]
+            Callable[["Task[P, Coroutine[Any, Any, R]]", TaskRun, State], bool]
         ] = self.task.retry_condition_fn
         if not self.task_run:
             raise ValueError("Task run is not set")
@@ -448,13 +447,7 @@ class SyncTaskRunEngine(BaseTaskRunEngine[P, R]):
             self.task_run.run_count += 1
 
         if new_state.is_final():
-            if isinstance(state.data, BaseResult) 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 isinstance(state.data, ResultRecord):
+            if isinstance(state.data, ResultRecord):
                 result = state.data.result
             else:
                 result = state.data
@@ -473,13 +466,7 @@ class SyncTaskRunEngine(BaseTaskRunEngine[P, R]):
 
     def result(self, raise_on_failure: bool = True) -> "Union[R, State, None]":
         if self._return_value is not NotSet:
-            # if the return value is a BaseResult, we need to fetch it
-            if isinstance(self._return_value, BaseResult):
-                _result = self._return_value.get()
-                if asyncio.iscoroutine(_result):
-                    _result = run_coro_as_sync(_result)
-                return _result
-            elif isinstance(self._return_value, ResultRecord):
+            if isinstance(self._return_value, ResultRecord):
                 return self._return_value.result
             # otherwise, return the value as is
             return self._return_value
@@ -660,7 +647,7 @@ class SyncTaskRunEngine(BaseTaskRunEngine[P, R]):
     def initialize_run(
         self,
         task_run_id: Optional[UUID] = None,
-        dependencies: Optional[Dict[str, Set[TaskRunInput]]] = None,
+        dependencies: Optional[dict[str, set[TaskRunInput]]] = None,
     ) -> Generator["SyncTaskRunEngine", Any, Any]:
         """
         Enters a client context and creates a task run if needed.
@@ -700,7 +687,6 @@ class SyncTaskRunEngine(BaseTaskRunEngine[P, R]):
 
                         self._telemetry.start_span(
                             run=self.task_run,
-                            name=self.task.name,
                             client=self.client,
                             parameters=self.parameters,
                         )
@@ -753,12 +739,14 @@ class SyncTaskRunEngine(BaseTaskRunEngine[P, R]):
     def start(
         self,
         task_run_id: Optional[UUID] = None,
-        dependencies: Optional[Dict[str, Set[TaskRunInput]]] = None,
+        dependencies: Optional[dict[str, set[TaskRunInput]]] = None,
     ) -> Generator[None, None, None]:
         with self.initialize_run(task_run_id=task_run_id, dependencies=dependencies):
-            with trace.use_span(
-                self._telemetry.span
-            ) if self._telemetry.span else nullcontext():
+            with (
+                trace.use_span(self._telemetry.span)
+                if self._telemetry.span
+                else nullcontext()
+            ):
                 self.begin_run()
                 try:
                     yield
@@ -847,7 +835,7 @@ class AsyncTaskRunEngine(BaseTaskRunEngine[P, R]):
 
     async def can_retry(self, exc: Exception) -> bool:
         retry_condition: Optional[
-            Callable[[Task[P, Coroutine[Any, Any, R]], TaskRun, State], bool]
+            Callable[["Task[P, Coroutine[Any, Any, R]]", TaskRun, State], bool]
         ] = self.task.retry_condition_fn
         if not self.task_run:
             raise ValueError("Task run is not set")
@@ -989,14 +977,7 @@ class AsyncTaskRunEngine(BaseTaskRunEngine[P, R]):
             self.task_run.run_count += 1
 
         if new_state.is_final():
-            if (
-                isinstance(new_state.data, BaseResult)
-                and new_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 = await new_state.result(raise_on_failure=False, fetch=True)
-            elif isinstance(new_state.data, ResultRecord):
+            if isinstance(new_state.data, ResultRecord):
                 result = new_state.data.result
             else:
                 result = new_state.data
@@ -1016,10 +997,7 @@ class AsyncTaskRunEngine(BaseTaskRunEngine[P, R]):
 
     async def result(self, raise_on_failure: bool = True) -> "Union[R, State, None]":
         if self._return_value is not NotSet:
-            # if the return value is a BaseResult, we need to fetch it
-            if isinstance(self._return_value, BaseResult):
-                return await self._return_value.get()
-            elif isinstance(self._return_value, ResultRecord):
+            if isinstance(self._return_value, ResultRecord):
                 return self._return_value.result
             # otherwise, return the value as is
             return self._return_value
@@ -1199,7 +1177,7 @@ class AsyncTaskRunEngine(BaseTaskRunEngine[P, R]):
     async def initialize_run(
         self,
         task_run_id: Optional[UUID] = None,
-        dependencies: Optional[Dict[str, Set[TaskRunInput]]] = None,
+        dependencies: Optional[dict[str, set[TaskRunInput]]] = None,
     ) -> AsyncGenerator["AsyncTaskRunEngine", Any]:
         """
         Enters a client context and creates a task run if needed.
@@ -1237,7 +1215,6 @@ class AsyncTaskRunEngine(BaseTaskRunEngine[P, R]):
 
                         await self._telemetry.async_start_span(
                             run=self.task_run,
-                            name=self.task.name,
                             client=self.client,
                             parameters=self.parameters,
                         )
@@ -1290,14 +1267,16 @@ class AsyncTaskRunEngine(BaseTaskRunEngine[P, R]):
     async def start(
         self,
         task_run_id: Optional[UUID] = None,
-        dependencies: Optional[Dict[str, Set[TaskRunInput]]] = None,
+        dependencies: Optional[dict[str, set[TaskRunInput]]] = None,
     ) -> AsyncGenerator[None, None]:
         async with self.initialize_run(
             task_run_id=task_run_id, dependencies=dependencies
         ):
-            with trace.use_span(
-                self._telemetry.span
-            ) if self._telemetry.span else nullcontext():
+            with (
+                trace.use_span(self._telemetry.span)
+                if self._telemetry.span
+                else nullcontext()
+            ):
                 await self.begin_run()
                 try:
                     yield
@@ -1374,14 +1353,14 @@ class AsyncTaskRunEngine(BaseTaskRunEngine[P, R]):
 
 
 def run_task_sync(
-    task: Task[P, R],
+    task: "Task[P, R]",
     task_run_id: Optional[UUID] = None,
     task_run: Optional[TaskRun] = None,
-    parameters: Optional[Dict[str, Any]] = None,
-    wait_for: Optional[Iterable[PrefectFuture[R]]] = None,
+    parameters: Optional[dict[str, Any]] = None,
+    wait_for: Optional["OneOrManyFutureOrResult[Any]"] = None,
     return_type: Literal["state", "result"] = "result",
-    dependencies: Optional[Dict[str, Set[TaskRunInput]]] = None,
-    context: Optional[Dict[str, Any]] = None,
+    dependencies: Optional[dict[str, set[TaskRunInput]]] = None,
+    context: Optional[dict[str, Any]] = None,
 ) -> Union[R, State, None]:
     engine = SyncTaskRunEngine[P, R](
         task=task,
@@ -1401,14 +1380,14 @@ def run_task_sync(
 
 
 async def run_task_async(
-    task: Task[P, R],
+    task: "Task[P, R]",
     task_run_id: Optional[UUID] = None,
     task_run: Optional[TaskRun] = None,
-    parameters: Optional[Dict[str, Any]] = None,
-    wait_for: Optional[Iterable[PrefectFuture[R]]] = None,
+    parameters: Optional[dict[str, Any]] = None,
+    wait_for: Optional["OneOrManyFutureOrResult[Any]"] = None,
     return_type: Literal["state", "result"] = "result",
-    dependencies: Optional[Dict[str, Set[TaskRunInput]]] = None,
-    context: Optional[Dict[str, Any]] = None,
+    dependencies: Optional[dict[str, set[TaskRunInput]]] = None,
+    context: Optional[dict[str, Any]] = None,
 ) -> Union[R, State, None]:
     engine = AsyncTaskRunEngine[P, R](
         task=task,
@@ -1428,14 +1407,14 @@ async def run_task_async(
 
 
 def run_generator_task_sync(
-    task: Task[P, R],
+    task: "Task[P, R]",
     task_run_id: Optional[UUID] = None,
     task_run: Optional[TaskRun] = None,
-    parameters: Optional[Dict[str, Any]] = None,
-    wait_for: Optional[Iterable[PrefectFuture[R]]] = None,
+    parameters: Optional[dict[str, Any]] = None,
+    wait_for: Optional["OneOrManyFutureOrResult[Any]"] = None,
     return_type: Literal["state", "result"] = "result",
-    dependencies: Optional[Dict[str, Set[TaskRunInput]]] = None,
-    context: Optional[Dict[str, Any]] = None,
+    dependencies: Optional[dict[str, set[TaskRunInput]]] = None,
+    context: Optional[dict[str, Any]] = None,
 ) -> Generator[R, None, None]:
     if return_type != "result":
         raise ValueError("The return_type for a generator task must be 'result'")
@@ -1483,14 +1462,14 @@ def run_generator_task_sync(
 
 
 async def run_generator_task_async(
-    task: Task[P, R],
+    task: "Task[P, R]",
     task_run_id: Optional[UUID] = None,
     task_run: Optional[TaskRun] = None,
-    parameters: Optional[Dict[str, Any]] = None,
-    wait_for: Optional[Iterable[PrefectFuture[R]]] = None,
+    parameters: Optional[dict[str, Any]] = None,
+    wait_for: Optional["OneOrManyFutureOrResult[Any]"] = None,
     return_type: Literal["state", "result"] = "result",
-    dependencies: Optional[Dict[str, Set[TaskRunInput]]] = None,
-    context: Optional[Dict[str, Any]] = None,
+    dependencies: Optional[dict[str, set[TaskRunInput]]] = None,
+    context: Optional[dict[str, Any]] = None,
 ) -> AsyncGenerator[R, None]:
     if return_type != "result":
         raise ValueError("The return_type for a generator task must be 'result'")
@@ -1539,14 +1518,14 @@ async def run_generator_task_async(
 
 
 def run_task(
-    task: Task[P, Union[R, Coroutine[Any, Any, R]]],
+    task: "Task[P, Union[R, Coroutine[Any, Any, R]]]",
     task_run_id: Optional[UUID] = None,
     task_run: Optional[TaskRun] = None,
-    parameters: Optional[Dict[str, Any]] = None,
-    wait_for: Optional[Iterable[PrefectFuture[R]]] = None,
+    parameters: Optional[dict[str, Any]] = None,
+    wait_for: Optional["OneOrManyFutureOrResult[Any]"] = None,
     return_type: Literal["state", "result"] = "result",
-    dependencies: Optional[Dict[str, Set[TaskRunInput]]] = None,
-    context: Optional[Dict[str, Any]] = None,
+    dependencies: Optional[dict[str, set[TaskRunInput]]] = None,
+    context: Optional[dict[str, Any]] = None,
 ) -> Union[R, State, None, Coroutine[Any, Any, Union[R, State, None]]]:
     """
     Runs the provided task.