prefect-client 3.4.6.dev1__py3-none-any.whl → 3.4.7__py3-none-any.whl

prefect/server/api/logs.py

@@ -2,14 +2,21 @@
 Routes for interacting with log objects.
 """
 
-from typing import List
+from typing import Optional, Sequence
 
-from fastapi import Body, Depends, status
+from fastapi import Body, Depends, WebSocket, status
+from pydantic import TypeAdapter
+from starlette.status import WS_1002_PROTOCOL_ERROR
 
 import prefect.server.api.dependencies as dependencies
 import prefect.server.models as models
-import prefect.server.schemas as schemas
 from prefect.server.database import PrefectDBInterface, provide_database_interface
+from prefect.server.logs import stream
+from prefect.server.schemas.actions import LogCreate
+from prefect.server.schemas.core import Log
+from prefect.server.schemas.filters import LogFilter
+from prefect.server.schemas.sorting import LogSort
+from prefect.server.utilities import subscriptions
 from prefect.server.utilities.server import PrefectRouter
 
 router: PrefectRouter = PrefectRouter(prefix="/logs", tags=["Logs"])
@@ -17,7 +24,7 @@ router: PrefectRouter = PrefectRouter(prefix="/logs", tags=["Logs"])
 
 @router.post("/", status_code=status.HTTP_201_CREATED)
 async def create_logs(
-    logs: List[schemas.actions.LogCreate],
+    logs: Sequence[LogCreate],
     db: PrefectDBInterface = Depends(provide_database_interface),
 ) -> None:
     """
@@ -30,18 +37,66 @@ async def create_logs(
             await models.logs.create_logs(session=session, logs=batch)
 
 
+logs_adapter: TypeAdapter[Sequence[Log]] = TypeAdapter(Sequence[Log])
+
+
 @router.post("/filter")
 async def read_logs(
     limit: int = dependencies.LimitBody(),
     offset: int = Body(0, ge=0),
-    logs: schemas.filters.LogFilter = None,
-    sort: schemas.sorting.LogSort = Body(schemas.sorting.LogSort.TIMESTAMP_ASC),
+    logs: Optional[LogFilter] = None,
+    sort: LogSort = Body(LogSort.TIMESTAMP_ASC),
     db: PrefectDBInterface = Depends(provide_database_interface),
-) -> List[schemas.core.Log]:
+) -> Sequence[Log]:
     """
     Query for logs.
     """
     async with db.session_context() as session:
-        return await models.logs.read_logs(
-            session=session, log_filter=logs, offset=offset, limit=limit, sort=sort
+        return logs_adapter.validate_python(
+            await models.logs.read_logs(
+                session=session, log_filter=logs, offset=offset, limit=limit, sort=sort
+            )
         )
+
+
+@router.websocket("/out")
+async def stream_logs_out(websocket: WebSocket) -> None:
+    """Serve a WebSocket to stream live logs"""
+    websocket = await subscriptions.accept_prefect_socket(websocket)
+    if not websocket:
+        return
+
+    try:
+        # After authentication, the next message is expected to be a filter message, any
+        # other type of message will close the connection.
+        message = await websocket.receive_json()
+
+        if message["type"] != "filter":
+            return await websocket.close(
+                WS_1002_PROTOCOL_ERROR, reason="Expected 'filter' message"
+            )
+
+        try:
+            filter = LogFilter.model_validate(message["filter"])
+        except Exception as e:
+            return await websocket.close(
+                WS_1002_PROTOCOL_ERROR, reason=f"Invalid filter: {e}"
+            )
+
+        # No backfill support for logs - only live streaming
+        # Subscribe to the ongoing log stream
+        async with stream.logs(filter) as log_stream:
+            async for log in log_stream:
+                if not log:
+                    if await subscriptions.still_connected(websocket):
+                        continue
+                    break
+
+                await websocket.send_json(
+                    {"type": "log", "log": log.model_dump(mode="json")}
+                )
+
+    except subscriptions.NORMAL_DISCONNECT_EXCEPTIONS:  # pragma: no cover
+        pass  # it's fine if a client disconnects either normally or abnormally
+
+    return None

prefect/server/api/server.py

@@ -922,6 +922,8 @@ class SubprocessASGIServer:
                 self.server_process.wait(timeout=5)
             except subprocess.TimeoutExpired:
                 self.server_process.kill()
+                # Ensure the process is reaped to avoid ResourceWarning
+                self.server_process.wait()
             finally:
                 self.server_process = None
         if self.port in self._instances:

prefect/server/api/templates.py

@@ -8,11 +8,17 @@ from prefect.server.utilities.user_templates import (
     validate_user_template,
 )
 
-router: PrefectRouter = PrefectRouter(prefix="/templates", tags=["Automations"])
+router: PrefectRouter = PrefectRouter(tags=["Automations"])
 
 
+# deprecated and can be removed after the ui removes its dependency on it
+# use /templates/validate instead
 @router.post(
-    "/validate",
+    "/automations/templates/validate",
+    response_class=Response,
+)
+@router.post(
+    "/templates/validate",
     response_class=Response,
 )
 def validate_template(template: str = Body(default="")) -> Response:

prefect/settings/context.py

@@ -33,20 +33,23 @@ def temporary_settings(
     See `Settings.copy_with_update` for details on different argument behavior.
 
     Examples:
-        >>> from prefect.settings import PREFECT_API_URL
-        >>>
-        >>> with temporary_settings(updates={PREFECT_API_URL: "foo"}):
-        >>>    assert PREFECT_API_URL.value() == "foo"
-        >>>
-        >>>    with temporary_settings(set_defaults={PREFECT_API_URL: "bar"}):
-        >>>         assert PREFECT_API_URL.value() == "foo"
-        >>>
-        >>>    with temporary_settings(restore_defaults={PREFECT_API_URL}):
-        >>>         assert PREFECT_API_URL.value() is None
-        >>>
-        >>>         with temporary_settings(set_defaults={PREFECT_API_URL: "bar"})
-        >>>             assert PREFECT_API_URL.value() == "bar"
-        >>> assert PREFECT_API_URL.value() is None
+
+        ```python
+        from prefect.settings import PREFECT_API_URL
+
+        with temporary_settings(updates={PREFECT_API_URL: "foo"}):
+           assert PREFECT_API_URL.value() == "foo"
+
+           with temporary_settings(set_defaults={PREFECT_API_URL: "bar"}):
+                assert PREFECT_API_URL.value() == "foo"
+
+           with temporary_settings(restore_defaults={PREFECT_API_URL}):
+                assert PREFECT_API_URL.value() is None
+
+                with temporary_settings(set_defaults={PREFECT_API_URL: "bar"})
+                    assert PREFECT_API_URL.value() == "bar"
+        assert PREFECT_API_URL.value() is None
+        ```
     """
     import prefect.context
 

prefect/settings/models/server/logs.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from typing import ClassVar
+
+from pydantic import Field
+from pydantic_settings import SettingsConfigDict
+
+from prefect.settings.base import PrefectBaseSettings, build_settings_config
+
+
+class ServerLogsSettings(PrefectBaseSettings):
+    """
+    Settings for controlling behavior of the logs subsystem
+    """
+
+    model_config: ClassVar[SettingsConfigDict] = build_settings_config(
+        ("server", "logs")
+    )
+
+    stream_out_enabled: bool = Field(
+        default=False,
+        description="Whether or not to stream logs out to the API via websockets.",
+    )
+
+    stream_publishing_enabled: bool = Field(
+        default=False,
+        description="Whether or not to publish logs to the streaming system.",
+    )

prefect/settings/models/server/root.py

@@ -13,6 +13,7 @@ from .deployments import ServerDeploymentsSettings
 from .ephemeral import ServerEphemeralSettings
 from .events import ServerEventsSettings
 from .flow_run_graph import ServerFlowRunGraphSettings
+from .logs import ServerLogsSettings
 from .services import ServerServicesSettings
 from .tasks import ServerTasksSettings
 from .ui import ServerUISettings
@@ -127,6 +128,10 @@ class ServerSettings(PrefectBaseSettings):
         default_factory=ServerFlowRunGraphSettings,
         description="Settings for controlling flow run graph behavior",
     )
+    logs: ServerLogsSettings = Field(
+        default_factory=ServerLogsSettings,
+        description="Settings for controlling server logs behavior",
+    )
     services: ServerServicesSettings = Field(
         default_factory=ServerServicesSettings,
         description="Settings for controlling server services behavior",

prefect/settings/models/server/services.py

@@ -448,6 +448,32 @@ class ServerServicesTriggersSettings(ServicesBaseSetting):
         ),
     )
 
+    pg_notify_reconnect_interval_seconds: int = Field(
+        default=10,
+        description="""
+        The number of seconds to wait before reconnecting to the PostgreSQL NOTIFY/LISTEN 
+        connection after an error. Only used when using PostgreSQL as the database.
+        Defaults to `10`.
+        """,
+        validation_alias=AliasChoices(
+            AliasPath("pg_notify_reconnect_interval_seconds"),
+            "prefect_server_services_triggers_pg_notify_reconnect_interval_seconds",
+        ),
+    )
+
+    pg_notify_heartbeat_interval_seconds: int = Field(
+        default=5,
+        description="""
+        The number of seconds between heartbeat checks for the PostgreSQL NOTIFY/LISTEN 
+        connection to ensure it's still alive. Only used when using PostgreSQL as the database.
+        Defaults to `5`.
+        """,
+        validation_alias=AliasChoices(
+            AliasPath("pg_notify_heartbeat_interval_seconds"),
+            "prefect_server_services_triggers_pg_notify_heartbeat_interval_seconds",
+        ),
+    )
+
 
 class ServerServicesSettings(PrefectBaseSettings):
     """

prefect/task_engine.py

@@ -37,7 +37,7 @@ import prefect.types._datetime
 from prefect.cache_policies import CachePolicy
 from prefect.client.orchestration import PrefectClient, SyncPrefectClient, get_client
 from prefect.client.schemas import TaskRun
-from prefect.client.schemas.objects import State, TaskRunInput
+from prefect.client.schemas.objects import RunInput, State
 from prefect.concurrency.context import ConcurrencyContext
 from prefect.concurrency.v1.asyncio import concurrency as aconcurrency
 from prefect.concurrency.v1.context import ConcurrencyContext as ConcurrencyContextV1
@@ -96,7 +96,7 @@ from prefect.utilities.callables import call_with_parameters, parameters_to_args
 from prefect.utilities.collections import visit_collection
 from prefect.utilities.engine import (
     emit_task_run_state_change_event,
-    link_state_to_result,
+    link_state_to_task_run_result,
     resolve_to_final_result,
 )
 from prefect.utilities.math import clamped_poisson_interval
@@ -453,9 +453,7 @@ class SyncTaskRunEngine(BaseTaskRunEngine[P, R]):
             else:
                 result = state.data
 
-            link_state_to_result(new_state, result)
-            if asset_context := AssetContext.get():
-                asset_context.emit_events(new_state)
+            link_state_to_task_run_result(new_state, result)
 
         # emit a state change event
         self._last_event = emit_task_run_state_change_event(
@@ -641,15 +639,6 @@ class SyncTaskRunEngine(BaseTaskRunEngine[P, R]):
             else:
                 persist_result = should_persist_result()
 
-            asset_context = AssetContext.get()
-            if not asset_context:
-                asset_context = AssetContext.from_task_and_inputs(
-                    task=self.task,
-                    task_run_id=self.task_run.id,
-                    task_inputs=self.task_run.task_inputs,
-                )
-                stack.enter_context(asset_context)
-
             stack.enter_context(
                 TaskRunContext(
                     task=self.task,
@@ -672,11 +661,29 @@ class SyncTaskRunEngine(BaseTaskRunEngine[P, R]):
 
             yield
 
+    @contextmanager
+    def asset_context(self):
+        parent_asset_ctx = AssetContext.get()
+
+        if parent_asset_ctx and parent_asset_ctx.copy_to_child_ctx:
+            asset_ctx = parent_asset_ctx.model_copy()
+            asset_ctx.copy_to_child_ctx = False
+        else:
+            asset_ctx = AssetContext.from_task_and_inputs(
+                self.task, self.task_run.id, self.task_run.task_inputs
+            )
+
+        with asset_ctx as ctx:
+            try:
+                yield
+            finally:
+                ctx.emit_events(self.state)
+
     @contextmanager
     def initialize_run(
         self,
         task_run_id: Optional[UUID] = None,
-        dependencies: Optional[dict[str, set[TaskRunInput]]] = None,
+        dependencies: Optional[dict[str, set[RunInput]]] = None,
     ) -> Generator[Self, Any, Any]:
         """
         Enters a client context and creates a task run if needed.
@@ -770,7 +777,7 @@ 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[RunInput]]] = None,
     ) -> Generator[None, None, None]:
         with self.initialize_run(task_run_id=task_run_id, dependencies=dependencies):
             with (
@@ -1031,9 +1038,7 @@ class AsyncTaskRunEngine(BaseTaskRunEngine[P, R]):
             else:
                 result = new_state.data
 
-            link_state_to_result(new_state, result)
-            if asset_context := AssetContext.get():
-                asset_context.emit_events(new_state)
+            link_state_to_task_run_result(new_state, result)
 
         # emit a state change event
         self._last_event = emit_task_run_state_change_event(
@@ -1219,15 +1224,6 @@ class AsyncTaskRunEngine(BaseTaskRunEngine[P, R]):
             else:
                 persist_result = should_persist_result()
 
-            asset_context = AssetContext.get()
-            if not asset_context:
-                asset_context = AssetContext.from_task_and_inputs(
-                    task=self.task,
-                    task_run_id=self.task_run.id,
-                    task_inputs=self.task_run.task_inputs,
-                )
-                stack.enter_context(asset_context)
-
             stack.enter_context(
                 TaskRunContext(
                     task=self.task,
@@ -1249,11 +1245,29 @@ class AsyncTaskRunEngine(BaseTaskRunEngine[P, R]):
 
             yield
 
+    @asynccontextmanager
+    async def asset_context(self):
+        parent_asset_ctx = AssetContext.get()
+
+        if parent_asset_ctx and parent_asset_ctx.copy_to_child_ctx:
+            asset_ctx = parent_asset_ctx.model_copy()
+            asset_ctx.copy_to_child_ctx = False
+        else:
+            asset_ctx = AssetContext.from_task_and_inputs(
+                self.task, self.task_run.id, self.task_run.task_inputs
+            )
+
+        with asset_ctx as ctx:
+            try:
+                yield
+            finally:
+                ctx.emit_events(self.state)
+
     @asynccontextmanager
     async def initialize_run(
         self,
         task_run_id: Optional[UUID] = None,
-        dependencies: Optional[dict[str, set[TaskRunInput]]] = None,
+        dependencies: Optional[dict[str, set[RunInput]]] = None,
     ) -> AsyncGenerator[Self, Any]:
         """
         Enters a client context and creates a task run if needed.
@@ -1345,7 +1359,7 @@ 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[RunInput]]] = None,
     ) -> AsyncGenerator[None, None]:
         async with self.initialize_run(
             task_run_id=task_run_id, dependencies=dependencies
@@ -1451,7 +1465,7 @@ def run_task_sync(
     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,
+    dependencies: Optional[dict[str, set[RunInput]]] = None,
     context: Optional[dict[str, Any]] = None,
 ) -> Union[R, State, None]:
     engine = SyncTaskRunEngine[P, R](
@@ -1465,7 +1479,11 @@ def run_task_sync(
     with engine.start(task_run_id=task_run_id, dependencies=dependencies):
         while engine.is_running():
             run_coro_as_sync(engine.wait_until_ready())
-            with engine.run_context(), engine.transaction_context() as txn:
+            with (
+                engine.asset_context(),
+                engine.run_context(),
+                engine.transaction_context() as txn,
+            ):
                 engine.call_task_fn(txn)
 
     return engine.state if return_type == "state" else engine.result()
@@ -1478,7 +1496,7 @@ async def run_task_async(
     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,
+    dependencies: Optional[dict[str, set[RunInput]]] = None,
     context: Optional[dict[str, Any]] = None,
 ) -> Union[R, State, None]:
     engine = AsyncTaskRunEngine[P, R](
@@ -1492,7 +1510,11 @@ async def run_task_async(
     async with engine.start(task_run_id=task_run_id, dependencies=dependencies):
         while engine.is_running():
             await engine.wait_until_ready()
-            async with engine.run_context(), engine.transaction_context() as txn:
+            async with (
+                engine.asset_context(),
+                engine.run_context(),
+                engine.transaction_context() as txn,
+            ):
                 await engine.call_task_fn(txn)
 
     return engine.state if return_type == "state" else await engine.result()
@@ -1505,7 +1527,7 @@ def run_generator_task_sync(
     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,
+    dependencies: Optional[dict[str, set[RunInput]]] = None,
     context: Optional[dict[str, Any]] = None,
 ) -> Generator[R, None, None]:
     if return_type != "result":
@@ -1522,7 +1544,11 @@ def run_generator_task_sync(
     with engine.start(task_run_id=task_run_id, dependencies=dependencies):
         while engine.is_running():
             run_coro_as_sync(engine.wait_until_ready())
-            with engine.run_context(), engine.transaction_context() as txn:
+            with (
+                engine.asset_context(),
+                engine.run_context(),
+                engine.transaction_context() as txn,
+            ):
                 # TODO: generators should default to commit_mode=OFF
                 # because they are dynamic by definition
                 # for now we just prevent this branch explicitly
@@ -1542,7 +1568,7 @@ def run_generator_task_sync(
                             # dictionary in an unbounded way, so finding a
                             # way to periodically clean it up (using
                             # weakrefs or similar) would be good
-                            link_state_to_result(engine.state, gen_result)
+                            link_state_to_task_run_result(engine.state, gen_result)
                             yield gen_result
                     except StopIteration as exc:
                         engine.handle_success(exc.value, transaction=txn)
@@ -1560,7 +1586,7 @@ async def run_generator_task_async(
     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,
+    dependencies: Optional[dict[str, set[RunInput]]] = None,
     context: Optional[dict[str, Any]] = None,
 ) -> AsyncGenerator[R, None]:
     if return_type != "result":
@@ -1576,7 +1602,11 @@ async def run_generator_task_async(
     async with engine.start(task_run_id=task_run_id, dependencies=dependencies):
         while engine.is_running():
             await engine.wait_until_ready()
-            async with engine.run_context(), engine.transaction_context() as txn:
+            async with (
+                engine.asset_context(),
+                engine.run_context(),
+                engine.transaction_context() as txn,
+            ):
                 # TODO: generators should default to commit_mode=OFF
                 # because they are dynamic by definition
                 # for now we just prevent this branch explicitly
@@ -1597,7 +1627,7 @@ async def run_generator_task_async(
                             # dictionary in an unbounded way, so finding a
                             # way to periodically clean it up (using
                             # weakrefs or similar) would be good
-                            link_state_to_result(engine.state, gen_result)
+                            link_state_to_task_run_result(engine.state, gen_result)
                             yield gen_result
                     except (StopAsyncIteration, GeneratorExit) as exc:
                         await engine.handle_success(None, transaction=txn)
@@ -1617,7 +1647,7 @@ def run_task(
     parameters: Optional[dict[str, Any]] = None,
     wait_for: Optional["OneOrManyFutureOrResult[Any]"] = None,
     return_type: Literal["state"] = "state",
-    dependencies: Optional[dict[str, set[TaskRunInput]]] = None,
+    dependencies: Optional[dict[str, set[RunInput]]] = None,
     context: Optional[dict[str, Any]] = None,
 ) -> State[R]: ...
 
@@ -1630,7 +1660,7 @@ def run_task(
     parameters: Optional[dict[str, Any]] = None,
     wait_for: Optional["OneOrManyFutureOrResult[Any]"] = None,
     return_type: Literal["result"] = "result",
-    dependencies: Optional[dict[str, set[TaskRunInput]]] = None,
+    dependencies: Optional[dict[str, set[RunInput]]] = None,
     context: Optional[dict[str, Any]] = None,
 ) -> R: ...
 
@@ -1642,7 +1672,7 @@ def run_task(
     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,
+    dependencies: Optional[dict[str, set[RunInput]]] = None,
     context: Optional[dict[str, Any]] = None,
 ) -> Union[R, State, None, Coroutine[Any, Any, Union[R, State, None]]]:
     """

prefect/task_runners.py

@@ -19,7 +19,7 @@ from typing import (
 from typing_extensions import ParamSpec, Self, TypeVar
 
 from prefect._internal.uuid7 import uuid7
-from prefect.client.schemas.objects import TaskRunInput
+from prefect.client.schemas.objects import RunInput
 from prefect.exceptions import MappingLengthMismatch, MappingMissingIterable
 from prefect.futures import (
     PrefectConcurrentFuture,
@@ -81,7 +81,7 @@ class TaskRunner(abc.ABC, Generic[F]):
         task: "Task[P, Coroutine[Any, Any, R]]",
         parameters: dict[str, Any],
         wait_for: Iterable[PrefectFuture[Any]] | None = None,
-        dependencies: dict[str, set[TaskRunInput]] | None = None,
+        dependencies: dict[str, set[RunInput]] | None = None,
     ) -> F: ...
 
     @overload
@@ -91,7 +91,7 @@ class TaskRunner(abc.ABC, Generic[F]):
         task: "Task[Any, R]",
         parameters: dict[str, Any],
         wait_for: Iterable[PrefectFuture[Any]] | None = None,
-        dependencies: dict[str, set[TaskRunInput]] | None = None,
+        dependencies: dict[str, set[RunInput]] | None = None,
     ) -> F: ...
 
     @abc.abstractmethod
@@ -100,7 +100,7 @@ class TaskRunner(abc.ABC, Generic[F]):
         task: "Task[P, R]",
         parameters: dict[str, Any],
         wait_for: Iterable[PrefectFuture[Any]] | None = None,
-        dependencies: dict[str, set[TaskRunInput]] | None = None,
+        dependencies: dict[str, set[RunInput]] | None = None,
     ) -> F: ...
 
     def map(
@@ -262,7 +262,7 @@ class ThreadPoolTaskRunner(TaskRunner[PrefectConcurrentFuture[R]]):
         task: "Task[P, Coroutine[Any, Any, R]]",
         parameters: dict[str, Any],
         wait_for: Iterable[PrefectFuture[Any]] | None = None,
-        dependencies: dict[str, set[TaskRunInput]] | None = None,
+        dependencies: dict[str, set[RunInput]] | None = None,
     ) -> PrefectConcurrentFuture[R]: ...
 
     @overload
@@ -271,7 +271,7 @@ class ThreadPoolTaskRunner(TaskRunner[PrefectConcurrentFuture[R]]):
         task: "Task[Any, R]",
         parameters: dict[str, Any],
         wait_for: Iterable[PrefectFuture[Any]] | None = None,
-        dependencies: dict[str, set[TaskRunInput]] | None = None,
+        dependencies: dict[str, set[RunInput]] | None = None,
     ) -> PrefectConcurrentFuture[R]: ...
 
     def submit(
@@ -279,7 +279,7 @@ class ThreadPoolTaskRunner(TaskRunner[PrefectConcurrentFuture[R]]):
         task: "Task[P, R | Coroutine[Any, Any, R]]",
         parameters: dict[str, Any],
         wait_for: Iterable[PrefectFuture[Any]] | None = None,
-        dependencies: dict[str, set[TaskRunInput]] | None = None,
+        dependencies: dict[str, set[RunInput]] | None = None,
     ) -> PrefectConcurrentFuture[R]:
         """
         Submit a task to the task run engine running in a separate thread.
@@ -415,7 +415,7 @@ class PrefectTaskRunner(TaskRunner[PrefectDistributedFuture[R]]):
         task: "Task[P, Coroutine[Any, Any, R]]",
         parameters: dict[str, Any],
         wait_for: Iterable[PrefectFuture[Any]] | None = None,
-        dependencies: dict[str, set[TaskRunInput]] | None = None,
+        dependencies: dict[str, set[RunInput]] | None = None,
     ) -> PrefectDistributedFuture[R]: ...
 
     @overload
@@ -424,7 +424,7 @@ class PrefectTaskRunner(TaskRunner[PrefectDistributedFuture[R]]):
         task: "Task[Any, R]",
         parameters: dict[str, Any],
         wait_for: Iterable[PrefectFuture[Any]] | None = None,
-        dependencies: dict[str, set[TaskRunInput]] | None = None,
+        dependencies: dict[str, set[RunInput]] | None = None,
     ) -> PrefectDistributedFuture[R]: ...
 
     def submit(
@@ -432,7 +432,7 @@ class PrefectTaskRunner(TaskRunner[PrefectDistributedFuture[R]]):
         task: "Task[P, R]",
         parameters: dict[str, Any],
         wait_for: Iterable[PrefectFuture[Any]] | None = None,
-        dependencies: dict[str, set[TaskRunInput]] | None = None,
+        dependencies: dict[str, set[RunInput]] | None = None,
     ) -> PrefectDistributedFuture[R]:
         """
         Submit a task to the task run engine running in a separate thread.