prefect-client 2.14.18__py3-none-any.whl → 2.14.20__py3-none-any.whl

prefect/client/orchestration.py

@@ -1961,7 +1961,7 @@ class PrefectClient:
     async def create_task_run(
         self,
         task: "TaskObject",
-        flow_run_id: UUID,
+        flow_run_id: Optional[UUID],
         dynamic_key: str,
         name: str = None,
         extra_tags: Iterable[str] = None,

prefect/client/schemas/filters.py

@@ -316,6 +316,19 @@ class FlowRunFilter(PrefectBaseModel, OperatorMixin):
     )
 
 
+class TaskRunFilterFlowRunId(PrefectBaseModel):
+    """Filter by `TaskRun.flow_run_id`."""
+
+    any_: Optional[List[UUID]] = Field(
+        default=None, description="A list of flow run ids to include"
+    )
+
+    is_null_: bool = Field(
+        default=False,
+        description="If true, only include task runs without a flow run id",
+    )
+
+
 class TaskRunFilterId(PrefectBaseModel):
     """Filter by `TaskRun.id`."""
 
@@ -428,6 +441,9 @@ class TaskRunFilter(PrefectBaseModel, OperatorMixin):
     subflow_runs: Optional[TaskRunFilterSubFlowRuns] = Field(
         default=None, description="Filter criteria for `TaskRun.subflow_run`"
     )
+    flow_run_id: Optional[TaskRunFilterFlowRunId] = Field(
+        default=None, description="Filter criteria for `TaskRun.flow_run_id`"
+    )
 
 
 class DeploymentFilterId(PrefectBaseModel):

prefect/client/schemas/objects.py

@@ -113,6 +113,7 @@ class StateDetails(PrefectBaseModel):
     refresh_cache: bool = None
     retriable: bool = None
     transition_id: Optional[UUID] = None
+    task_parameters_id: Optional[UUID] = None
 
 
 class State(ObjectBaseModel, Generic[R]):

prefect/client/subscriptions.py

@@ -0,0 +1,82 @@
+import asyncio
+from typing import Generic, Type, TypeVar
+
+import orjson
+import websockets
+import websockets.exceptions
+from starlette.status import WS_1008_POLICY_VIOLATION
+from typing_extensions import Self
+
+from prefect._internal.schemas.bases import IDBaseModel
+from prefect.settings import PREFECT_API_KEY, PREFECT_API_URL
+
+S = TypeVar("S", bound=IDBaseModel)
+
+
+class Subscription(Generic[S]):
+    def __init__(self, model: Type[S], path: str):
+        self.model = model
+
+        base_url = PREFECT_API_URL.value().replace("http", "ws", 1)
+        self.subscription_url = f"{base_url}{path}"
+
+        self._connect = websockets.connect(
+            self.subscription_url,
+            subprotocols=["prefect"],
+        )
+        self._websocket = None
+
+    def __aiter__(self) -> Self:
+        return self
+
+    async def __anext__(self) -> S:
+        while True:
+            try:
+                await self._ensure_connected()
+                message = await self._websocket.recv()
+
+                message_data = orjson.loads(message)
+
+                if message_data.get("type") == "ping":
+                    await self._websocket.send(orjson.dumps({"type": "pong"}).decode())
+                    continue
+
+                return self.model.parse_raw(message)
+            except (
+                ConnectionRefusedError,
+                websockets.exceptions.ConnectionClosedError,
+            ):
+                self._websocket = None
+                if hasattr(self._connect, "protocol"):
+                    await self._connect.__aexit__(None, None, None)
+                await asyncio.sleep(0.5)
+
+    async def _ensure_connected(self):
+        if self._websocket:
+            return
+
+        websocket = await self._connect.__aenter__()
+
+        await websocket.send(
+            orjson.dumps({"type": "auth", "token": PREFECT_API_KEY.value()}).decode()
+        )
+
+        try:
+            auth = orjson.loads(await websocket.recv())
+            assert auth["type"] == "auth_success"
+        except (
+            AssertionError,
+            websockets.exceptions.ConnectionClosedError,
+        ) as e:
+            if isinstance(e, AssertionError) or e.code == WS_1008_POLICY_VIOLATION:
+                raise Exception(
+                    "Unable to authenticate to the subscription. Please "
+                    "ensure the provided `PREFECT_API_KEY` you are using is "
+                    "valid for this environment."
+                ) from e
+            raise
+        else:
+            self._websocket = websocket
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}[{self.model.__name__}]"

prefect/context.py

@@ -214,7 +214,7 @@ class RunContext(ContextModel):
     client: PrefectClient
 
 
-class FlowRunContext(RunContext):
+class EngineContext(RunContext):
     """
     The context for a flow run. Data in this context is only available from within a
     flow run function.
@@ -233,6 +233,7 @@ class FlowRunContext(RunContext):
 
     flow: Optional["Flow"] = None
     flow_run: Optional[FlowRun] = None
+    autonomous_task_run: Optional[TaskRun] = None
     task_runner: BaseTaskRunner
     log_prints: bool = False
     parameters: Dict[str, Any]
@@ -266,6 +267,9 @@ class FlowRunContext(RunContext):
     __var__ = ContextVar("flow_run")
 
 
+FlowRunContext = EngineContext  # for backwards compatibility
+
+
 class TaskRunContext(RunContext):
     """
     The context for a task run. Data in this context is only available from within a

prefect/engine.py

@@ -155,7 +155,7 @@ from prefect.exceptions import (
 )
 from prefect.flows import Flow, load_flow_from_entrypoint
 from prefect.futures import PrefectFuture, call_repr, resolve_futures_to_states
-from prefect.input import RunInput, keyset_from_paused_state
+from prefect.input import keyset_from_paused_state
 from prefect.input.run_input import run_input_subclass_from_type
 from prefect.logging.configuration import setup_logging
 from prefect.logging.handlers import APILogHandler
@@ -169,6 +169,7 @@ from prefect.logging.loggers import (
 from prefect.results import BaseResult, ResultFactory, UnknownResult
 from prefect.settings import (
     PREFECT_DEBUG_MODE,
+    PREFECT_EXPERIMENTAL_ENABLE_TASK_SCHEDULING,
     PREFECT_LOGGING_LOG_PRINTS,
     PREFECT_TASK_INTROSPECTION_WARN_THRESHOLD,
     PREFECT_TASKS_REFRESH_CACHE,
@@ -179,6 +180,7 @@ from prefect.states import (
     Paused,
     Pending,
     Running,
+    Scheduled,
     State,
     Suspended,
     exception_to_crashed_state,
@@ -210,9 +212,10 @@ from prefect.utilities.pydantic import PartialModel
 from prefect.utilities.text import truncated_to
 
 R = TypeVar("R")
-T = TypeVar("T", bound=RunInput)
+T = TypeVar("T")
 EngineReturnType = Literal["future", "state", "result"]
 
+NUM_CHARS_DYNAMIC_KEY = 8
 
 API_HEALTHCHECKS = {}
 UNTRACKABLE_TYPES = {bool, type(None), type(...), type(NotImplemented)}
@@ -984,18 +987,6 @@ async def pause_flow_run(
     ...
 
 
-@overload
-async def pause_flow_run(
-    wait_for_input: Type[Any],
-    flow_run_id: UUID = None,
-    timeout: int = 3600,
-    poll_interval: int = 10,
-    reschedule: bool = False,
-    key: str = None,
-) -> Any:
-    ...
-
-
 @sync_compatible
 @deprecated_parameter(
     "flow_run_id", start_date="Dec 2023", help="Use `suspend_flow_run` instead."
@@ -1010,13 +1001,13 @@ async def pause_flow_run(
     "wait_for_input", group="flow_run_input", when=lambda y: y is not None
 )
 async def pause_flow_run(
-    wait_for_input: Optional[Union[Type[T], Type[Any]]] = None,
+    wait_for_input: Optional[Type[T]] = None,
     flow_run_id: UUID = None,
     timeout: int = 3600,
     poll_interval: int = 10,
     reschedule: bool = False,
     key: str = None,
-):
+) -> Optional[T]:
     """
     Pauses the current flow run by blocking execution until resumed.
 
@@ -1099,8 +1090,8 @@ async def _in_process_pause(
     reschedule=False,
     key: str = None,
     client=None,
-    wait_for_input: Optional[Union[Type[RunInput], Type[Any]]] = None,
-) -> Optional[RunInput]:
+    wait_for_input: Optional[T] = None,
+) -> Optional[T]:
     if TaskRunContext.get():
         raise RuntimeError("Cannot pause task runs.")
 
@@ -1231,29 +1222,18 @@ async def suspend_flow_run(
     ...
 
 
-@overload
-async def suspend_flow_run(
-    wait_for_input: Type[Any],
-    flow_run_id: Optional[UUID] = None,
-    timeout: Optional[int] = 3600,
-    key: Optional[str] = None,
-    client: PrefectClient = None,
-) -> Any:
-    ...
-
-
 @sync_compatible
 @inject_client
 @experimental_parameter(
     "wait_for_input", group="flow_run_input", when=lambda y: y is not None
 )
 async def suspend_flow_run(
-    wait_for_input: Optional[Union[Type[T], Type[Any]]] = None,
+    wait_for_input: Optional[Type[T]] = None,
     flow_run_id: Optional[UUID] = None,
     timeout: Optional[int] = 3600,
     key: Optional[str] = None,
     client: PrefectClient = None,
-):
+) -> Optional[T]:
     """
     Suspends a flow run by stopping code execution until resumed.
 
@@ -1382,16 +1362,19 @@ def enter_task_run_engine(
     return_type: EngineReturnType,
     task_runner: Optional[BaseTaskRunner],
     mapped: bool,
-) -> Union[PrefectFuture, Awaitable[PrefectFuture]]:
-    """
-    Sync entrypoint for task calls
-    """
+) -> Union[PrefectFuture, Awaitable[PrefectFuture], TaskRun]:
+    """Sync entrypoint for task calls"""
 
     flow_run_context = FlowRunContext.get()
+
     if not flow_run_context:
+        if PREFECT_EXPERIMENTAL_ENABLE_TASK_SCHEDULING.value():
+            return _create_autonomous_task_run(task=task, parameters=parameters)
+
         raise RuntimeError(
-            "Tasks cannot be run outside of a flow. To call the underlying task"
-            " function outside of a flow use `task.fn()`."
+            "Tasks cannot be run outside of a flow"
+            " - if you meant to submit an autonomous task, you need to set"
+            " `prefect config set PREFECT_EXPERIMENTAL_ENABLE_TASK_SCHEDULING=true`"
         )
 
     if TaskRunContext.get():
@@ -1603,14 +1586,22 @@ async def create_task_run_future(
 
     # Generate a name for the future
     dynamic_key = _dynamic_key_for_task_run(flow_run_context, task)
-    task_run_name = f"{task.name}-{dynamic_key}"
+    task_run_name = (
+        f"{task.name}-{dynamic_key}"
+        if flow_run_context and flow_run_context.flow_run
+        else f"{task.name}-{dynamic_key[:NUM_CHARS_DYNAMIC_KEY]}"  # autonomous task run
+    )
 
     # Generate a future
     future = PrefectFuture(
         name=task_run_name,
         key=uuid4(),
         task_runner=task_runner,
-        asynchronous=task.isasync and flow_run_context.flow.isasync,
+        asynchronous=(
+            task.isasync and flow_run_context.flow.isasync
+            if flow_run_context and flow_run_context.flow
+            else task.isasync
+        ),
     )
 
     # Create and submit the task run in the background
@@ -1650,14 +1641,18 @@ async def create_task_run_then_submit(
     task_runner: BaseTaskRunner,
     extra_task_inputs: Dict[str, Set[TaskRunInput]],
 ) -> None:
-    task_run = await create_task_run(
-        task=task,
-        name=task_run_name,
-        flow_run_context=flow_run_context,
-        parameters=parameters,
-        dynamic_key=task_run_dynamic_key,
-        wait_for=wait_for,
-        extra_task_inputs=extra_task_inputs,
+    task_run = (
+        await create_task_run(
+            task=task,
+            name=task_run_name,
+            flow_run_context=flow_run_context,
+            parameters=parameters,
+            dynamic_key=task_run_dynamic_key,
+            wait_for=wait_for,
+            extra_task_inputs=extra_task_inputs,
+        )
+        if not flow_run_context.autonomous_task_run
+        else flow_run_context.autonomous_task_run
     )
 
     # Attach the task run to the future to support `get_state` operations
@@ -1698,7 +1693,7 @@ async def create_task_run(
     task_run = await flow_run_context.client.create_task_run(
         task=task,
         name=name,
-        flow_run_id=flow_run_context.flow_run.id,
+        flow_run_id=flow_run_context.flow_run.id if flow_run_context.flow_run else None,
         dynamic_key=dynamic_key,
         state=Pending(),
         extra_tags=TagsContext.get().current_tags,
@@ -1721,7 +1716,10 @@ async def submit_task_run(
 ) -> PrefectFuture:
     logger = get_run_logger(flow_run_context)
 
-    if task_runner.concurrency_type == TaskConcurrencyType.SEQUENTIAL:
+    if (
+        task_runner.concurrency_type == TaskConcurrencyType.SEQUENTIAL
+        and not flow_run_context.autonomous_task_run
+    ):
         logger.info(f"Executing {task_run.name!r} immediately...")
 
     future = await task_runner.submit(
@@ -1799,7 +1797,7 @@ async def begin_task_run(
             # worker, the flow run timeout will not be raised in the worker process.
             interruptible = maybe_flow_run_context.timeout_scope is not None
         else:
-            # Otherwise, retrieve a new client
+            # Otherwise, retrieve a new clien`t
             client = await stack.enter_async_context(get_client())
             interruptible = False
             await stack.enter_async_context(anyio.create_task_group())
@@ -2153,7 +2151,6 @@ async def orchestrate_task_run(
                     await _check_task_failure_retriable(task, task_run, terminal_state)
                 )
             state = await propose_state(client, terminal_state, task_run_id=task_run.id)
-
             last_event = _emit_task_run_state_change_event(
                 task_run=task_run,
                 initial_state=last_state,
@@ -2203,7 +2200,7 @@ async def orchestrate_task_run(
         level=logging.INFO if state.is_completed() else logging.ERROR,
         msg=f"Finished in state {display_state}",
     )
-
+    logger.warning(f"Task run {task_run.name!r} finished in state {display_state}")
     return state
 
 
@@ -2572,7 +2569,12 @@ async def propose_state(
 
 
 def _dynamic_key_for_task_run(context: FlowRunContext, task: Task) -> int:
-    if task.task_key not in context.task_run_dynamic_keys:
+    if context.flow_run is None:  # this is an autonomous task run
+        context.task_run_dynamic_keys[task.task_key] = getattr(
+            task, "dynamic_key", str(uuid4())
+        )
+
+    elif task.task_key not in context.task_run_dynamic_keys:
         context.task_run_dynamic_keys[task.task_key] = 0
     else:
         context.task_run_dynamic_keys[task.task_key] += 1
@@ -2912,6 +2914,34 @@ def _emit_task_run_state_change_event(
     )
 
 
+@sync_compatible
+async def _create_autonomous_task_run(
+    task: Task, parameters: Dict[str, Any]
+) -> TaskRun:
+    async with get_client() as client:
+        scheduled = Scheduled()
+        if parameters:
+            parameters_id = uuid4()
+            scheduled.state_details.task_parameters_id = parameters_id
+
+            # TODO: We want to use result storage for parameters, but we'll need
+            # a better way to use it than this.
+            task.persist_result = True
+            factory = await ResultFactory.from_task(task, client=client)
+            await factory.store_parameters(parameters_id, parameters)
+
+        task_run = await client.create_task_run(
+            task=task,
+            flow_run_id=None,
+            dynamic_key=f"{task.task_key}-{str(uuid4())[:NUM_CHARS_DYNAMIC_KEY]}",
+            state=scheduled,
+        )
+
+        engine_logger.debug(f"Submitted run of task {task.name!r} for execution")
+
+    return task_run
+
+
 if __name__ == "__main__":
     try:
         flow_run_id = UUID(

prefect/filesystems.py

@@ -683,12 +683,27 @@ class Azure(WritableFileSystem, WritableDeploymentStorage):
             " require ADLFS to use DefaultAzureCredentials."
         ),
     )
-
+    azure_storage_container: Optional[SecretStr] = Field(
+        default=None,
+        title="Azure storage container",
+        description=(
+            "Blob Container in Azure Storage Account. If set the 'bucket_path' will"
+            " be interpreted using the following URL format:"
+            "'az://<container>@<storage_account>.dfs.core.windows.net/<bucket_path>'."
+        ),
+    )
     _remote_file_system: RemoteFileSystem = None
 
     @property
     def basepath(self) -> str:
-        return f"az://{self.bucket_path}"
+        if self.azure_storage_container:
+            return (
+                f"az://{self.azure_storage_container.get_secret_value()}"
+                f"@{self.azure_storage_account_name.get_secret_value()}"
+                f".dfs.core.windows.net/{self.bucket_path}"
+            )
+        else:
+            return f"az://{self.bucket_path}"
 
     @property
     def filesystem(self) -> RemoteFileSystem:
@@ -713,7 +728,7 @@ class Azure(WritableFileSystem, WritableDeploymentStorage):
             )
         settings["anon"] = self.azure_storage_anon
         self._remote_file_system = RemoteFileSystem(
-            basepath=f"az://{self.bucket_path}", settings=settings
+            basepath=self.basepath, settings=settings
         )
         return self._remote_file_system
 

prefect/flows.py

@@ -65,7 +65,6 @@ else:
     V2ValidationError = None
 
 from rich.console import Console
-from rich.panel import Panel
 from typing_extensions import Literal, ParamSpec
 
 from prefect._internal.schemas.validators import raise_on_name_with_banned_characters
@@ -785,7 +784,7 @@ class Flow(Generic[P, R]):
                 )
 
             console = Console()
-            console.print(Panel(help_message))
+            console.print(help_message, soft_wrap=True)
         await runner.start(webserver=webserver)
 
     @classmethod

prefect/input/run_input.py

@@ -70,6 +70,8 @@ from typing import (
     Type,
     TypeVar,
     Union,
+    cast,
+    overload,
 )
 from uuid import UUID, uuid4
 
@@ -93,8 +95,12 @@ if TYPE_CHECKING:
 if HAS_PYDANTIC_V2:
     from prefect._internal.pydantic.v2_schema import create_v2_schema
 
-T = TypeVar("T", bound="RunInput")
-Keyset = Dict[Union[Literal["response"], Literal["schema"]], str]
+R = TypeVar("R", bound="RunInput")
+T = TypeVar("T")
+
+Keyset = Dict[
+    Union[Literal["description"], Literal["response"], Literal["schema"]], str
+]
 
 
 def keyset_from_paused_state(state: "State") -> Keyset:
@@ -123,6 +129,7 @@ def keyset_from_base_key(base_key: str) -> Keyset:
         - Dict[str, str]: the keyset
     """
     return {
+        "description": f"{base_key}-description",
         "response": f"{base_key}-response",
         "schema": f"{base_key}-schema",
     }
@@ -138,6 +145,7 @@ class RunInput(pydantic.BaseModel):
     class Config:
         extra = "forbid"
 
+    _description: Optional[str] = pydantic.PrivateAttr(default=None)
     _metadata: RunInputMetadata = pydantic.PrivateAttr()
 
     @property
@@ -168,6 +176,14 @@ class RunInput(pydantic.BaseModel):
             key=keyset["schema"], value=schema, flow_run_id=flow_run_id
         )
 
+        description = cls._description if isinstance(cls._description, str) else None
+        if description:
+            await create_flow_run_input(
+                key=keyset["description"],
+                value=description,
+                flow_run_id=flow_run_id,
+            )
+
     @classmethod
     @sync_compatible
     async def load(cls, keyset: Keyset, flow_run_id: Optional[UUID] = None):
@@ -206,18 +222,27 @@ class RunInput(pydantic.BaseModel):
         return instance
 
     @classmethod
-    def with_initial_data(cls: Type[T], **kwargs: Any) -> Type[T]:
+    def with_initial_data(
+        cls: Type[R], description: Optional[str] = None, **kwargs: Any
+    ) -> Type[R]:
         """
         Create a new `RunInput` subclass with the given initial data as field
         defaults.
 
         Args:
-            - kwargs (Any): the initial data
+            - description (str, optional): a description to show when resuming
+                a flow run that requires input
+            - kwargs (Any): the initial data to populate the subclass
         """
         fields = {}
         for key, value in kwargs.items():
             fields[key] = (type(value), value)
-        return pydantic.create_model(cls.__name__, **fields, __base__=cls)
+        model = pydantic.create_model(cls.__name__, **fields, __base__=cls)
+
+        if description is not None:
+            model._description = description
+
+        return model
 
     @sync_compatible
     async def respond(
@@ -295,12 +320,12 @@ class RunInput(pydantic.BaseModel):
         return type(f"{model_cls.__name__}RunInput", (RunInput, model_cls), {})  # type: ignore
 
 
-class AutomaticRunInput(RunInput):
-    value: Any
+class AutomaticRunInput(RunInput, Generic[T]):
+    value: T
 
     @classmethod
     @sync_compatible
-    async def load(cls, keyset: Keyset, flow_run_id: Optional[UUID] = None):
+    async def load(cls, keyset: Keyset, flow_run_id: Optional[UUID] = None) -> T:
         """
         Load the run input response from the given key.
 
@@ -312,7 +337,7 @@ class AutomaticRunInput(RunInput):
         return instance.value
 
     @classmethod
-    def subclass_from_type(cls, _type: Type[T]) -> Type["AutomaticRunInput"]:
+    def subclass_from_type(cls, _type: Type[T]) -> Type["AutomaticRunInput[T]"]:
         """
         Create a new `AutomaticRunInput` subclass from the given type.
         """
@@ -353,33 +378,30 @@ class AutomaticRunInput(RunInput):
         return GetAutomaticInputHandler(run_input_cls=cls, *args, **kwargs)
 
 
-def run_input_subclass_from_type(_type: Type[T]) -> Type[RunInput]:
+def run_input_subclass_from_type(
+    _type: Union[Type[R], Type[T], pydantic.BaseModel]
+) -> Union[Type[AutomaticRunInput[T]], Type[R]]:
     """
     Create a new `RunInput` subclass from the given type.
     """
     try:
-        is_class = issubclass(_type, object)
+        if issubclass(_type, RunInput):
+            return cast(Type[R], _type)
+        elif issubclass(_type, pydantic.BaseModel):
+            return cast(Type[R], RunInput.subclass_from_base_model_type(_type))
     except TypeError:
-        is_class = False
-
-    if not is_class:
-        # Could be something like a typing._GenericAlias, so pass it through to
-        # Pydantic to see if we can create a model from it.
-        return AutomaticRunInput.subclass_from_type(_type)
-    if issubclass(_type, RunInput):
-        return _type
-    elif issubclass(_type, pydantic.BaseModel):
-        return RunInput.subclass_from_base_model_type(_type)
-    else:
-        # As a fall-through for a type that isn't a `RunInput` subclass or
-        # `pydantic.BaseModel` subclass, pass it through to Pydantic.
-        return AutomaticRunInput.subclass_from_type(_type)
+        pass
+
+    # Could be something like a typing._GenericAlias or any other type that
+    # isn't a `RunInput` subclass or `pydantic.BaseModel` subclass. Try passing
+    # it to AutomaticRunInput to see if we can create a model from it.
+    return cast(Type[AutomaticRunInput[T]], AutomaticRunInput.subclass_from_type(_type))
 
 
-class GetInputHandler(Generic[T]):
+class GetInputHandler(Generic[R]):
     def __init__(
         self,
-        run_input_cls: Type[T],
+        run_input_cls: Type[R],
         key_prefix: str,
         timeout: Optional[float] = 3600,
         poll_interval: float = 10,
@@ -401,7 +423,7 @@ class GetInputHandler(Generic[T]):
     def __iter__(self):
         return self
 
-    def __next__(self) -> T:
+    def __next__(self) -> R:
         try:
             return self.next()
         except TimeoutError:
@@ -412,7 +434,7 @@ class GetInputHandler(Generic[T]):
     def __aiter__(self):
         return self
 
-    async def __anext__(self) -> T:
+    async def __anext__(self) -> R:
         try:
             return await self.next()
         except TimeoutError:
@@ -433,11 +455,11 @@ class GetInputHandler(Generic[T]):
 
         return flow_run_inputs
 
-    def to_instance(self, flow_run_input: "FlowRunInput") -> T:
+    def to_instance(self, flow_run_input: "FlowRunInput") -> R:
         return self.run_input_cls.load_from_flow_run_input(flow_run_input)
 
     @sync_compatible
-    async def next(self) -> T:
+    async def next(self) -> R:
         flow_run_inputs = await self.filter_for_inputs()
         if flow_run_inputs:
             return self.to_instance(flow_run_inputs[0])
@@ -450,12 +472,22 @@ class GetInputHandler(Generic[T]):
                     return self.to_instance(flow_run_inputs[0])
 
 
-class GetAutomaticInputHandler(GetInputHandler):
+class GetAutomaticInputHandler(GetInputHandler, Generic[T]):
     def __init__(self, *args, **kwargs):
         self.with_metadata = kwargs.pop("with_metadata", False)
         super().__init__(*args, **kwargs)
 
-    def to_instance(self, flow_run_input: "FlowRunInput") -> Any:
+    def __next__(self) -> T:
+        return cast(T, super().__next__())
+
+    async def __anext__(self) -> T:
+        return cast(T, await super().__anext__())
+
+    @sync_compatible
+    async def next(self) -> T:
+        return cast(T, await super().next())
+
+    def to_instance(self, flow_run_input: "FlowRunInput") -> T:
         run_input = self.run_input_cls.load_from_flow_run_input(flow_run_input)
 
         if self.with_metadata:
@@ -500,8 +532,9 @@ async def send_input(
     )
 
 
+@overload
 def receive_input(
-    input_type: type,
+    input_type: Type[R],
     timeout: Optional[float] = 3600,
     poll_interval: float = 10,
     raise_timeout_error: bool = False,
@@ -509,14 +542,52 @@ def receive_input(
     key_prefix: Optional[str] = None,
     flow_run_id: Optional[UUID] = None,
     with_metadata: bool = False,
-):
+) -> GetInputHandler[R]:
+    ...
+
+
+@overload
+def receive_input(
+    input_type: Type[T],
+    timeout: Optional[float] = 3600,
+    poll_interval: float = 10,
+    raise_timeout_error: bool = False,
+    exclude_keys: Optional[Set[str]] = None,
+    key_prefix: Optional[str] = None,
+    flow_run_id: Optional[UUID] = None,
+    with_metadata: bool = False,
+) -> GetAutomaticInputHandler[T]:
+    ...
+
+
+def receive_input(
+    input_type: Union[Type[R], Type[T]],
+    timeout: Optional[float] = 3600,
+    poll_interval: float = 10,
+    raise_timeout_error: bool = False,
+    exclude_keys: Optional[Set[str]] = None,
+    key_prefix: Optional[str] = None,
+    flow_run_id: Optional[UUID] = None,
+    with_metadata: bool = False,
+) -> Union[GetAutomaticInputHandler[T], GetInputHandler[R]]:
     input_cls = run_input_subclass_from_type(input_type)
-    return input_cls.receive(
-        timeout=timeout,
-        poll_interval=poll_interval,
-        raise_timeout_error=raise_timeout_error,
-        exclude_keys=exclude_keys,
-        key_prefix=key_prefix,
-        flow_run_id=flow_run_id,
-        with_metadata=with_metadata,
-    )
+
+    if issubclass(input_cls, AutomaticRunInput):
+        return input_cls.receive(
+            timeout=timeout,
+            poll_interval=poll_interval,
+            raise_timeout_error=raise_timeout_error,
+            exclude_keys=exclude_keys,
+            key_prefix=key_prefix,
+            flow_run_id=flow_run_id,
+            with_metadata=with_metadata,
+        )
+    else:
+        return input_cls.receive(
+            timeout=timeout,
+            poll_interval=poll_interval,
+            raise_timeout_error=raise_timeout_error,
+            exclude_keys=exclude_keys,
+            key_prefix=key_prefix,
+            flow_run_id=flow_run_id,
+        )

prefect/results.py

@@ -5,6 +5,7 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
+    Dict,
     Generic,
     Optional,
     Tuple,
@@ -12,6 +13,7 @@ from typing import (
     TypeVar,
     Union,
 )
+from uuid import UUID
 
 from typing_extensions import Self
 
@@ -51,7 +53,7 @@ if TYPE_CHECKING:
 
 ResultStorage = Union[WritableFileSystem, str]
 ResultSerializer = Union[Serializer, str]
-LITERAL_TYPES = {type(None), bool}
+LITERAL_TYPES = {type(None), bool, UUID}
 
 
 def DEFAULT_STORAGE_KEY_FN():
@@ -383,6 +385,27 @@ class ResultFactory(pydantic.BaseModel):
             cache_object=should_cache_object,
         )
 
+    @sync_compatible
+    async def store_parameters(self, identifier: UUID, parameters: Dict[str, Any]):
+        assert (
+            self.storage_block_id is not None
+        ), "Unexpected storage block ID. Was it persisted?"
+        data = self.serializer.dumps(parameters)
+        blob = PersistedResultBlob(serializer=self.serializer, data=data)
+        await self.storage_block.write_path(
+            f"parameters/{identifier}", content=blob.to_bytes()
+        )
+
+    @sync_compatible
+    async def read_parameters(self, identifier: UUID) -> Dict[str, Any]:
+        assert (
+            self.storage_block_id is not None
+        ), "Unexpected storage block ID. Was it persisted?"
+        blob = PersistedResultBlob.parse_raw(
+            await self.storage_block.read_path(f"parameters/{identifier}")
+        )
+        return self.serializer.loads(blob.data)
+
 
 @add_type_dispatch
 class BaseResult(pydantic.BaseModel, abc.ABC, Generic[R]):

prefect/runner/runner.py

@@ -52,7 +52,6 @@ import anyio.abc
 import pendulum
 import sniffio
 from rich.console import Console, Group
-from rich.panel import Panel
 from rich.table import Table
 
 from prefect._internal.concurrency.api import (
@@ -1260,7 +1259,9 @@ async def serve(
             )
 
         console = Console()
-        console.print(Panel(Group(help_message_top, table, help_message_bottom)))
+        console.print(
+            Group(help_message_top, table, help_message_bottom), soft_wrap=True
+        )
 
     await runner.start()
 

prefect/settings.py

@@ -1408,6 +1408,13 @@ PREFECT_WORKER_WEBSERVER_PORT = Setting(
 """
 The port the worker's webserver should bind to.
 """
+PREFECT_TASK_SCHEDULING_DELETE_FAILED_SUBMISSIONS = Setting(
+    bool,
+    default=True,
+)
+"""
+Whether or not to delete failed task submissions from the database.
+"""
 
 PREFECT_EXPERIMENTAL_ENABLE_EXTRA_RUNNER_ENDPOINTS = Setting(bool, default=False)
 """
@@ -1435,6 +1442,11 @@ PREFECT_EXPERIMENTAL_WARN_WORKSPACE_DASHBOARD = Setting(bool, default=False)
 Whether or not to warn when the experimental workspace dashboard is enabled.
 """
 
+PREFECT_EXPERIMENTAL_ENABLE_TASK_SCHEDULING = Setting(bool, default=False)
+"""
+Whether or not to enable experimental task scheduling.
+"""
+
 # Defaults -----------------------------------------------------------------------------
 
 PREFECT_DEFAULT_RESULT_STORAGE_BLOCK = Setting(

prefect/task_engine.py

@@ -0,0 +1,70 @@
+from contextlib import AsyncExitStack
+from typing import (
+    Any,
+    Dict,
+    Iterable,
+    Optional,
+    Type,
+)
+
+import anyio
+from anyio import start_blocking_portal
+from typing_extensions import Literal
+
+from prefect._internal.concurrency.api import create_call, from_async, from_sync
+from prefect.client.orchestration import get_client
+from prefect.client.schemas.objects import TaskRun
+from prefect.context import EngineContext
+from prefect.engine import (
+    begin_task_map,
+    get_task_call_return_value,
+)
+from prefect.futures import PrefectFuture
+from prefect.results import ResultFactory
+from prefect.task_runners import BaseTaskRunner, SequentialTaskRunner
+from prefect.tasks import Task
+from prefect.utilities.asyncutils import sync_compatible
+
+EngineReturnType = Literal["future", "state", "result"]
+
+
+@sync_compatible
+async def submit_autonomous_task_to_engine(
+    task: Task,
+    task_run: TaskRun,
+    parameters: Optional[Dict] = None,
+    wait_for: Optional[Iterable[PrefectFuture]] = None,
+    mapped: bool = False,
+    return_type: EngineReturnType = "future",
+    task_runner: Optional[Type[BaseTaskRunner]] = None,
+) -> Any:
+    parameters = parameters or {}
+    async with AsyncExitStack() as stack:
+        with EngineContext(
+            flow=None,
+            flow_run=None,
+            autonomous_task_run=task_run,
+            task_runner=await stack.enter_async_context(
+                (task_runner if task_runner else SequentialTaskRunner()).start()
+            ),
+            client=await stack.enter_async_context(get_client()),
+            parameters=parameters,
+            result_factory=await ResultFactory.from_task(task),
+            background_tasks=await stack.enter_async_context(anyio.create_task_group()),
+            sync_portal=(
+                stack.enter_context(start_blocking_portal()) if task.isasync else None
+            ),
+        ) as flow_run_context:
+            begin_run = create_call(
+                begin_task_map if mapped else get_task_call_return_value,
+                task=task,
+                flow_run_context=flow_run_context,
+                parameters=parameters,
+                wait_for=wait_for,
+                return_type=return_type,
+                task_runner=task_runner,
+            )
+            if task.isasync:
+                return await from_async.wait_for_call_in_loop_thread(begin_run)
+            else:
+                return from_sync.wait_for_call_in_loop_thread(begin_run)

prefect/task_server.py

@@ -0,0 +1,208 @@
+import asyncio
+import signal
+import sys
+from functools import partial
+from typing import Iterable, Optional
+
+import anyio
+import anyio.abc
+import pendulum
+
+from prefect import Task, get_client
+from prefect._internal.concurrency.api import create_call, from_sync
+from prefect.client.schemas.objects import TaskRun
+from prefect.client.subscriptions import Subscription
+from prefect.logging.loggers import get_logger
+from prefect.results import ResultFactory
+from prefect.settings import (
+    PREFECT_EXPERIMENTAL_ENABLE_TASK_SCHEDULING,
+    PREFECT_TASK_SCHEDULING_DELETE_FAILED_SUBMISSIONS,
+)
+from prefect.task_engine import submit_autonomous_task_to_engine
+from prefect.utilities.asyncutils import asyncnullcontext, sync_compatible
+from prefect.utilities.collections import distinct
+from prefect.utilities.processutils import _register_signal
+
+logger = get_logger("task_server")
+
+
+class TaskServer:
+    """This class is responsible for serving tasks that may be executed autonomously
+    (i.e., without a parent flow run).
+
+    When `start()` is called, the task server will subscribe to the task run scheduling
+    topic and poll for scheduled task runs. When a scheduled task run is found, it
+    will submit the task run to the engine for execution, using `submit_autonomous_task_to_engine`
+    to construct a minimal `EngineContext` for the task run.
+
+    Args:
+        - tasks: A list of tasks to serve. These tasks will be submitted to the engine
+            when a scheduled task run is found.
+        - tags: A list of tags to apply to the task server. Defaults to `["autonomous"]`.
+    """
+
+    def __init__(
+        self,
+        *tasks: Task,
+        tags: Optional[Iterable[str]] = None,
+    ):
+        self.tasks: list[Task] = tasks
+        self.tags: Iterable[str] = tags or ["autonomous"]
+        self.last_polled: Optional[pendulum.DateTime] = None
+        self.started = False
+        self.stopping = False
+
+        self._client = get_client()
+
+        if not asyncio.get_event_loop().is_running():
+            raise RuntimeError(
+                "TaskServer must be initialized within an async context."
+            )
+
+        self._runs_task_group: anyio.abc.TaskGroup = anyio.create_task_group()
+
+    def handle_sigterm(self, signum, frame):
+        """
+        Shuts down the task server when a SIGTERM is received.
+        """
+        logger.info("SIGTERM received, initiating graceful shutdown...")
+        from_sync.call_in_loop_thread(create_call(self.stop))
+
+        sys.exit(0)
+
+    @sync_compatible
+    async def start(self) -> None:
+        """
+        Starts a task server, which runs the tasks provided in the constructor.
+        """
+        _register_signal(signal.SIGTERM, self.handle_sigterm)
+
+        async with asyncnullcontext() if self.started else self:
+            await self._subscribe_to_task_scheduling()
+
+    @sync_compatible
+    async def stop(self):
+        """Stops the task server's polling cycle."""
+        if not self.started:
+            raise RuntimeError(
+                "Task server has not yet started. Please start the task server by"
+                " calling .start()"
+            )
+
+        logger.info("Stopping task server...")
+        self.started = False
+        self.stopping = True
+
+    async def _subscribe_to_task_scheduling(self):
+        subscription = Subscription(TaskRun, "/task_runs/subscriptions/scheduled")
+        logger.debug(f"Created: {subscription}")
+        async for task_run in subscription:
+            logger.info(f"Received task run: {task_run.id} - {task_run.name}")
+            await self._submit_pending_task_run(task_run)
+
+    async def _submit_pending_task_run(self, task_run: TaskRun):
+        logger.debug(
+            f"Found task run: {task_run.name!r} in state: {task_run.state.name!r}"
+        )
+
+        task = next((t for t in self.tasks if t.name in task_run.task_key), None)
+
+        if not task:
+            if PREFECT_TASK_SCHEDULING_DELETE_FAILED_SUBMISSIONS.value():
+                logger.warning(
+                    f"Task {task_run.name!r} not found in task server registry."
+                )
+                await self._client._client.delete(f"/task_runs/{task_run.id}")
+
+            return
+
+        # The ID of the parameters for this run are stored in the Scheduled state's
+        # state_details. If there is no parameters_id, then the task was created
+        # without parameters.
+        parameters = {}
+        if hasattr(task_run.state.state_details, "task_parameters_id"):
+            parameters_id = task_run.state.state_details.task_parameters_id
+            task.persist_result = True
+            factory = await ResultFactory.from_task(task)
+            try:
+                parameters = await factory.read_parameters(parameters_id)
+            except Exception as exc:
+                logger.exception(
+                    f"Failed to read parameters for task run {task_run.id!r}",
+                    exc_info=exc,
+                )
+                if PREFECT_TASK_SCHEDULING_DELETE_FAILED_SUBMISSIONS.value():
+                    logger.info(
+                        f"Deleting task run {task_run.id!r} because it failed to submit"
+                    )
+                    await self._client._client.delete(f"/task_runs/{task_run.id}")
+                return
+
+        logger.debug(
+            f"Submitting run {task_run.name!r} of task {task.name!r} to engine"
+        )
+
+        task_run.tags = distinct(task_run.tags + list(self.tags))
+
+        self._runs_task_group.start_soon(
+            partial(
+                submit_autonomous_task_to_engine,
+                task=task,
+                task_run=task_run,
+                parameters=parameters,
+            )
+        )
+
+    async def __aenter__(self):
+        logger.debug("Starting task server...")
+        self._client = get_client()
+        await self._client.__aenter__()
+        await self._runs_task_group.__aenter__()
+
+        self.started = True
+        return self
+
+    async def __aexit__(self, *exc_info):
+        logger.debug("Stopping task server...")
+        self.started = False
+        if self._runs_task_group:
+            await self._runs_task_group.__aexit__(*exc_info)
+        if self._client:
+            await self._client.__aexit__(*exc_info)
+
+
+@sync_compatible
+async def serve(*tasks: Task, tags: Optional[Iterable[str]] = None):
+    """Serve the provided tasks so that they may be executed autonomously.
+
+    Args:
+        - tasks: A list of tasks to serve. When a scheduled task run is found for a
+            given task, the task run will be submitted to the engine for execution.
+        - tags: A list of tags to apply to the task server. Defaults to `["autonomous"]`.
+
+    Example:
+        ```python
+        from prefect import task
+        from prefect.task_server import serve
+
+        @task(log_prints=True)
+        def say(message: str):
+            print(message)
+
+        @task(log_prints=True)
+        def yell(message: str):
+            print(message.upper())
+
+        # starts a long-lived process that listens scheduled runs of these tasks
+        if __name__ == "__main__":
+            serve(say, yell)
+        ```
+    """
+    if not PREFECT_EXPERIMENTAL_ENABLE_TASK_SCHEDULING.value():
+        raise RuntimeError(
+            "To enable task scheduling, set PREFECT_EXPERIMENTAL_ENABLE_TASK_SCHEDULING"
+            " to True."
+        )
+
+    task_server = TaskServer(*tasks, tags=tags)
+    await task_server.start()

prefect/tasks.py

@@ -660,18 +660,35 @@ class Task(Generic[P, R]):
     ) -> State[T]:
         ...
 
+    @overload
+    def submit(
+        self: "Task[P, T]",
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> TaskRun:
+        ...
+
+    @overload
+    def submit(
+        self: "Task[P, Coroutine[Any, Any, T]]",
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> Awaitable[TaskRun]:
+        ...
+
     def submit(
         self,
         *args: Any,
         return_state: bool = False,
         wait_for: Optional[Iterable[PrefectFuture]] = None,
         **kwargs: Any,
-    ) -> Union[PrefectFuture, Awaitable[PrefectFuture]]:
+    ) -> Union[PrefectFuture, Awaitable[PrefectFuture], TaskRun, Awaitable[TaskRun]]:
         """
-        Submit a run of the task to a worker.
+        Submit a run of the task to the engine.
+
+        If writing an async task, this call must be awaited.
 
-        Must be called within a flow function. If writing an async task, this call must
-        be awaited.
+        If called from within a flow function,
 
         Will create a new task run in the backing API and submit the task to the flow's
         task runner. This call only blocks execution while the task is being submitted,

{prefect_client-2.14.18.dist-info → prefect_client-2.14.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prefect-client
-Version: 2.14.18
+Version: 2.14.20
 Summary: Workflow orchestration and management.
 Home-page: https://www.prefect.io
 Author: Prefect Technologies, Inc.

{prefect_client-2.14.18.dist-info → prefect_client-2.14.20.dist-info}/RECORD

@@ -2,23 +2,25 @@ prefect/.prefectignore,sha256=awSprvKT0vI8a64mEOLrMxhxqcO-b0ERQeYpA2rNKVQ,390
 prefect/__init__.py,sha256=CbIj8-fhzFJKbvXPadpc73SwIhNXiR_SVzQW4_k52jY,5339
 prefect/_version.py,sha256=fQguBh1dzT7Baahj504O5RrsLlSyg3Zrx42OpgdPnFc,22378
 prefect/agent.py,sha256=b557LEcKxcBrgAGOlEDlOPclAkucDj1RhzywBSYxYpI,27487
-prefect/context.py,sha256=xhoSciNLWeL5QpcfjDbyChArUWkyqvSRsLbZW2NeTBM,17975
-prefect/engine.py,sha256=tx23p3kuHlybQ6jT0Qst59rVIF_GMZX_gMZOQI4UAEs,107280
+prefect/context.py,sha256=vg88xl2Awzf755FJM9jHlNEJB_bvbdxIUHkKmTELvBQ,18088
+prefect/engine.py,sha256=HCOhrvZuap10vGEXHhT5I36X9FIXvHQ64HyGsAwSAUE,108831
 prefect/exceptions.py,sha256=84rpsDLp0cn_v2gE1TnK_NZXh27NJtzgZQtARVKyVEE,10953
-prefect/filesystems.py,sha256=X0M8_jddar7j1JtdEZgyDTX_8EVNJUYYs-Dat48GUhE,34101
+prefect/filesystems.py,sha256=AXFFsga4JIp06Hsw7970B6Z0s5HlR7UpUfqAFZl11k4,34782
 prefect/flow_runs.py,sha256=-XcKLrAZG35PnQxp5ReWDQ97kdgaNEtuB3fdwWZb9T0,2801
-prefect/flows.py,sha256=MhZ_zOkRytWtysuZC2XZOzrUcNLzWdO0ILH6zuUUIN8,64828
+prefect/flows.py,sha256=-S8boTTBuqQohcZN5Q3HyQCf9qRoKCRGnaSu9SFJ7Ug,64808
 prefect/futures.py,sha256=uqNlykBSRrXQO1pQ6mZWLMqwkFCLhvMLrEFR4eHs--I,12589
 prefect/manifests.py,sha256=xfwEEozSEqPK2Lro4dfgdTnjVbQx-aCECNBnf7vO7ZQ,808
 prefect/plugins.py,sha256=0C-D3-dKi06JZ44XEGmLjCiAkefbE_lKX-g3urzdbQ4,4163
 prefect/profiles.toml,sha256=1Tz7nKBDTDXL_6KPJSeB7ok0Vx_aQJ_p0AUmbnzDLzw,39
 prefect/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-prefect/results.py,sha256=Ko7Wv30ebXfV-9bsMKPkPYX-5a_SmrcbFB5Spbh1ZRI,21382
+prefect/results.py,sha256=w_tVJ9i_XB1jgJuu56L504ecPBw5eeGtkWwLADIeDKk,22288
 prefect/serializers.py,sha256=sSbe40Ipj-d6VuzBae5k2ao9lkMUZpIXcLtD7f2a7cE,10852
-prefect/settings.py,sha256=-85BhuRAWtT1hDf0QijLpNnAOGJMKdPVmMdloUmtc7o,65540
+prefect/settings.py,sha256=urRa3rG-jD1BuRjQ2Hm6ROk4-ofKtmPqgjtFD67zoxk,65846
 prefect/states.py,sha256=-Ud4AUom3Qu-HQ4hOLvfVZuuF-b_ibaqtzmL7V949Ac,20839
+prefect/task_engine.py,sha256=IqImIWtqT_DXBPKdpbWnq8dyxYXerF68wGIPGFcH98s,2475
 prefect/task_runners.py,sha256=HXUg5UqhZRN2QNBqMdGE1lKhwFhT8TaRN75ScgLbnw8,11012
-prefect/tasks.py,sha256=n3_vr_cIsFAA5M6anvMlNvsk3jCvmuut_6NXr579VAY,46705
+prefect/task_server.py,sha256=xZDW2-xZ9S23yv_ijgrcQCdJUmPlgPrtpTqbZFwW1Lw,7450
+prefect/tasks.py,sha256=lDTr2puBBKj53cAcc96rFCyZkeX0VQh83eYGszyyb0I,47049
 prefect/variables.py,sha256=57h-cJ15ZXWrdQiOnoEQmUVlAe59hmIaa57ZcGNBzao,914
 prefect/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prefect/_internal/_logging.py,sha256=HvNHY-8P469o5u4LYEDBTem69XZEt1QUeUaLToijpak,810
@@ -104,12 +106,13 @@ prefect/client/base.py,sha256=19VMAsq6Wvp1ZUwAb2OAT4pMQ0CFWsHBwqY3kZfPR2w,12209
 prefect/client/cloud.py,sha256=vlGivNaOIS0YNc0OnVKEx2L88SRU8pal8GYMoPHXyrU,3955
 prefect/client/collections.py,sha256=I9EgbTg4Fn57gn8vwP_WdDmgnATbx9gfkm2jjhCORjw,1037
 prefect/client/constants.py,sha256=Z_GG8KF70vbbXxpJuqW5pLnwzujTVeHbcYYRikNmGH0,29
-prefect/client/orchestration.py,sha256=WAAhy6VExuFFWwL5QWeit7JJg85yyFjoVF0ZXs2PzKw,103696
+prefect/client/orchestration.py,sha256=i8vGi2x-soE_POndRFRlsq5EoIn2bRHBS_D8QsNkzNg,103706
+prefect/client/subscriptions.py,sha256=eaoM0aqa7TUIXIhoJ29qlPSg_9R94O6KI48-BvNkcgU,2624
 prefect/client/utilities.py,sha256=ejALWrVYuqW-A2zKJkAuRXDkhZ5e8fsiEkn-wI1tzF0,1998
 prefect/client/schemas/__init__.py,sha256=KlyqFV-hMulMkNstBn_0ijoHoIwJZaBj6B1r07UmgvE,607
 prefect/client/schemas/actions.py,sha256=R4MUsb_1GuEsYLoLnU8jIfCBobJJFbDydaZE24mkqTc,25206
-prefect/client/schemas/filters.py,sha256=7RIrMpiuFL2XVh8rzLzKTkgvFyzUDGbUYDfDXJQGRMs,35026
-prefect/client/schemas/objects.py,sha256=7qgr9oSNKSDeMIsvXL65PqkwGaEAjpnj_nbW7Fy-_UM,53842
+prefect/client/schemas/filters.py,sha256=r6gnxZREnmE8Glt2SF6vPxHr0SIeiFBjTrrN32cw-Mo,35514
+prefect/client/schemas/objects.py,sha256=meib2ZRmECf_Gn3TJL8l8_Yf8VFWbJK-IvBvrjRQWoE,53888
 prefect/client/schemas/responses.py,sha256=nSYhg2Kl477RdczNsA731vpcJqF93WDnM6eMya3F7qI,9152
 prefect/client/schemas/schedules.py,sha256=ncGWmmBzZvf5G4AL27E0kWGiJxGX-haR2_-GUNvFlv4,14829
 prefect/client/schemas/sorting.py,sha256=Y-ea8k_vTUKAPKIxqGebwLSXM7x1s5mJ_4-sDd1Ivi8,2276
@@ -150,7 +153,7 @@ prefect/infrastructure/provisioners/ecs.py,sha256=qFHRLMuU0HduCEcuU0ZiEhnKeGFnk1
 prefect/infrastructure/provisioners/modal.py,sha256=mLblDjWWszXXMXWXYzkR_5s3nFFL6c3GvVX-VmIeU5A,9035
 prefect/input/__init__.py,sha256=TPJ9UfG9_SiBze23sQwU1MnWI8AgyEMNihotgTebFQ0,627
 prefect/input/actions.py,sha256=yITDUOsnNyslJKDinae6zKcX_1_3QMw8SFu7aTynjPM,3894
-prefect/input/run_input.py,sha256=rw961W_Tr1pcw-XpjqtKOb7RXv80n43L8sURex0u5NU,15850
+prefect/input/run_input.py,sha256=qVb8hPcM9fazrMLT7XDHNFAB-CD6fQvnwvrDod3aOdo,18022
 prefect/logging/__init__.py,sha256=EnbHzgJE_-e4VM3jG5s7MCABYvZ7UGjntC6NfSdTqLg,112
 prefect/logging/configuration.py,sha256=Qy0r7_j7b8_klsBEn2_f-eSrTQ_EzaBrFwGnwdtgcK8,3436
 prefect/logging/formatters.py,sha256=pJKHSo_D_DXXor8R7dnPBCOSwQMhRKfP-35UHdIcOyE,4081
@@ -165,7 +168,7 @@ prefect/packaging/file.py,sha256=LdYUpAJfBzaYABCwVs4jMKVyo2DC6psEFGpwJ-iKUd4,227
 prefect/packaging/orion.py,sha256=ctWh8s3UztYfOTsZ0sfumebI0dbNDOTriDNXohtEC-k,1935
 prefect/packaging/serializers.py,sha256=1x5GjcBSYrE-YMmrpYYZi2ObTs7MM6YEM3LS0e6mHAk,6321
 prefect/runner/__init__.py,sha256=d3DFUXy5BYd8Z4cppNN_6RTSddmr-KfnQ5Yw5vh8WL8,96
-prefect/runner/runner.py,sha256=4p_8fiobD_BMW3z55kAAxwAP7mrRjQovTc-oNJzLUGo,47324
+prefect/runner/runner.py,sha256=naKqAUl5cboL0xedksuNWgabAzAAy-AxNcL25N_C8KQ,47326
 prefect/runner/server.py,sha256=AqbvszD2OQkQe_5ydlyXZGYriSZiYDE7vpbRATstJ-Q,10648
 prefect/runner/storage.py,sha256=iZey8Am51c1fZFpS9iVXWYpKiM_lSocvaJEOZVExhvA,22428
 prefect/runner/submit.py,sha256=w53VdsqfwjW-M3e8hUAAoVlNrXsvGuuyGpEN0wi3vX0,8537
@@ -210,8 +213,8 @@ prefect/workers/block.py,sha256=lvKlaWdA-DCCXDX23HHK9M5urEq4x2wmpKtU9ft3a7k,7767
 prefect/workers/process.py,sha256=Kxj_eZYh6R8t8253LYIIafiG7dodCF8RZABwd3Ng_R0,10253
 prefect/workers/server.py,sha256=WVZJxR8nTMzK0ov0BD0xw5OyQpT26AxlXbsGQ1OrxeQ,1551
 prefect/workers/utilities.py,sha256=VfPfAlGtTuDj0-Kb8WlMgAuOfgXCdrGAnKMapPSBrwc,2483
-prefect_client-2.14.18.dist-info/LICENSE,sha256=MCxsn8osAkzfxKC4CC_dLcUkU8DZLkyihZ8mGs3Ah3Q,11357
-prefect_client-2.14.18.dist-info/METADATA,sha256=_7W3nhKUiFZfTg4ksneghl3waJPEPHX7pYMUMZutTz4,8143
-prefect_client-2.14.18.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-prefect_client-2.14.18.dist-info/top_level.txt,sha256=MJZYJgFdbRc2woQCeB4vM6T33tr01TmkEhRcns6H_H4,8
-prefect_client-2.14.18.dist-info/RECORD,,
+prefect_client-2.14.20.dist-info/LICENSE,sha256=MCxsn8osAkzfxKC4CC_dLcUkU8DZLkyihZ8mGs3Ah3Q,11357
+prefect_client-2.14.20.dist-info/METADATA,sha256=-tM7M4vqRCG31YMFta1-ZuXEOKVNlXRwmvQSBOuPrX0,8143
+prefect_client-2.14.20.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+prefect_client-2.14.20.dist-info/top_level.txt,sha256=MJZYJgFdbRc2woQCeB4vM6T33tr01TmkEhRcns6H_H4,8
+prefect_client-2.14.20.dist-info/RECORD,,