prefect-client 3.1.14__py3-none-any.whl → 3.2.0__py3-none-any.whl

prefect/flows.py

@@ -49,7 +49,6 @@ from typing_extensions import Literal, ParamSpec
 from prefect._experimental.sla.objects import SlaTypes
 from prefect._internal.concurrency.api import create_call, from_async
 from prefect.blocks.core import Block
-from prefect.client.schemas.actions import DeploymentScheduleCreate
 from prefect.client.schemas.filters import WorkerFilter, WorkerFilterStatus
 from prefect.client.schemas.objects import ConcurrencyLimitConfig, FlowRun
 from prefect.client.utilities import client_injector
@@ -69,6 +68,7 @@ from prefect.futures import PrefectFuture
 from prefect.logging import get_logger
 from prefect.logging.loggers import flow_run_logger
 from prefect.results import ResultSerializer, ResultStorage
+from prefect.schedules import Schedule
 from prefect.settings import (
     PREFECT_DEFAULT_WORK_POOL_NAME,
     PREFECT_FLOW_DEFAULT_RETRIES,
@@ -82,6 +82,7 @@ from prefect.types import BANNED_CHARACTERS, WITHOUT_BANNED_CHARACTERS
 from prefect.types.entrypoint import EntrypointType
 from prefect.utilities.annotations import NotSet
 from prefect.utilities.asyncutils import (
+    run_coro_as_sync,
     run_sync_in_worker_thread,
     sync_compatible,
 )
@@ -97,7 +98,7 @@ from prefect.utilities.filesystem import relative_path_to_current_platform
 from prefect.utilities.hashing import file_hash
 from prefect.utilities.importtools import import_object, safe_load_namespace
 
-from ._internal.compatibility.async_dispatch import is_in_async_context
+from ._internal.compatibility.async_dispatch import async_dispatch, is_in_async_context
 from ._internal.pydantic.v2_schema import is_v2_type
 from ._internal.pydantic.v2_validated_func import V2ValidatedFunction
 from ._internal.pydantic.v2_validated_func import (
@@ -119,8 +120,7 @@ class FlowStateHook(Protocol, Generic[P, R]):
 
     def __call__(
         self, flow: Flow[P, R], flow_run: FlowRun, state: State
-    ) -> Awaitable[None] | None:
-        ...
+    ) -> Awaitable[None] | None: ...
 
 
 if TYPE_CHECKING:
@@ -654,8 +654,7 @@ class Flow(Generic[P, R]):
                 serialized_parameters[key] = f"<{type(value).__name__}>"
         return serialized_parameters
 
-    @sync_compatible
-    async def to_deployment(
+    async def ato_deployment(
         self,
         name: str,
         interval: Optional[
@@ -669,6 +668,7 @@ class Flow(Generic[P, R]):
         cron: Optional[Union[Iterable[str], str]] = None,
         rrule: Optional[Union[Iterable[str], str]] = None,
         paused: Optional[bool] = None,
+        schedule: Optional[Schedule] = None,
         schedules: Optional["FlexibleScheduleList"] = None,
         concurrency_limit: Optional[Union[int, ConcurrencyLimitConfig, None]] = None,
         parameters: Optional[dict[str, Any]] = None,
@@ -684,7 +684,7 @@ class Flow(Generic[P, R]):
         _sla: Optional[Union[SlaTypes, list[SlaTypes]]] = None,  # experimental
     ) -> "RunnerDeployment":
         """
-        Creates a runner deployment object for this flow.
+        Asynchronously creates a runner deployment object for this flow.
 
         Args:
             name: The name to give the created deployment.
@@ -693,6 +693,8 @@ class Flow(Generic[P, R]):
             cron: A cron schedule of when to execute runs of this deployment.
             rrule: An rrule schedule of when to execute runs of this deployment.
             paused: Whether or not to set this deployment as paused.
+            schedule: A schedule object defining when to execute runs of this deployment.
+                Used to provide additional scheduling options like `timezone` or `parameters`.
             schedules: A list of schedule objects defining when to execute runs of this deployment.
                 Used to define multiple schedules or additional scheduling options such as `timezone`.
             concurrency_limit: The maximum number of runs of this deployment that can run at the same time.
@@ -740,7 +742,7 @@ class Flow(Generic[P, R]):
             _raise_on_name_with_banned_characters(name)
 
         if self._storage and self._entrypoint:
-            return await RunnerDeployment.from_storage(
+            return await RunnerDeployment.afrom_storage(
                 storage=self._storage,
                 entrypoint=self._entrypoint,
                 name=name,
@@ -749,6 +751,7 @@ class Flow(Generic[P, R]):
                 cron=cron,
                 rrule=rrule,
                 paused=paused,
+                schedule=schedule,
                 schedules=schedules,
                 concurrency_limit=concurrency_limit,
                 tags=tags,
@@ -761,7 +764,7 @@ class Flow(Generic[P, R]):
                 work_queue_name=work_queue_name,
                 job_variables=job_variables,
                 _sla=_sla,
-            )  # type: ignore # TODO: remove sync_compatible
+            )
         else:
             return RunnerDeployment.from_flow(
                 flow=self,
@@ -770,6 +773,147 @@ class Flow(Generic[P, R]):
                 cron=cron,
                 rrule=rrule,
                 paused=paused,
+                schedule=schedule,
+                schedules=schedules,
+                concurrency_limit=concurrency_limit,
+                tags=tags,
+                triggers=triggers,
+                parameters=parameters or {},
+                description=description,
+                version=version,
+                enforce_parameter_schema=enforce_parameter_schema,
+                work_pool_name=work_pool_name,
+                work_queue_name=work_queue_name,
+                job_variables=job_variables,
+                entrypoint_type=entrypoint_type,
+                _sla=_sla,
+            )
+
+    @async_dispatch(ato_deployment)
+    def to_deployment(
+        self,
+        name: str,
+        interval: Optional[
+            Union[
+                Iterable[Union[int, float, datetime.timedelta]],
+                int,
+                float,
+                datetime.timedelta,
+            ]
+        ] = None,
+        cron: Optional[Union[Iterable[str], str]] = None,
+        rrule: Optional[Union[Iterable[str], str]] = None,
+        paused: Optional[bool] = None,
+        schedule: Optional[Schedule] = None,
+        schedules: Optional["FlexibleScheduleList"] = None,
+        concurrency_limit: Optional[Union[int, ConcurrencyLimitConfig, None]] = None,
+        parameters: Optional[dict[str, Any]] = None,
+        triggers: Optional[list[Union[DeploymentTriggerTypes, TriggerTypes]]] = None,
+        description: Optional[str] = None,
+        tags: Optional[list[str]] = None,
+        version: Optional[str] = None,
+        enforce_parameter_schema: bool = True,
+        work_pool_name: Optional[str] = None,
+        work_queue_name: Optional[str] = None,
+        job_variables: Optional[dict[str, Any]] = None,
+        entrypoint_type: EntrypointType = EntrypointType.FILE_PATH,
+        _sla: Optional[Union[SlaTypes, list[SlaTypes]]] = None,  # experimental
+    ) -> "RunnerDeployment":
+        """
+        Creates a runner deployment object for this flow.
+
+        Args:
+            name: The name to give the created deployment.
+            interval: An interval on which to execute the new deployment. Accepts either a number
+                or a timedelta object. If a number is given, it will be interpreted as seconds.
+            cron: A cron schedule of when to execute runs of this deployment.
+            rrule: An rrule schedule of when to execute runs of this deployment.
+            paused: Whether or not to set this deployment as paused.
+            schedule: A schedule object defining when to execute runs of this deployment.
+                Used to provide additional scheduling options like `timezone` or `parameters`.
+            schedules: A list of schedule objects defining when to execute runs of this deployment.
+                Used to define multiple schedules or additional scheduling options such as `timezone`.
+            concurrency_limit: The maximum number of runs of this deployment that can run at the same time.
+            parameters: A dictionary of default parameter values to pass to runs of this deployment.
+            triggers: A list of triggers that will kick off runs of this deployment.
+            description: A description for the created deployment. Defaults to the flow's
+                description if not provided.
+            tags: A list of tags to associate with the created deployment for organizational
+                purposes.
+            version: A version for the created deployment. Defaults to the flow's version.
+            enforce_parameter_schema: Whether or not the Prefect API should enforce the
+                parameter schema for the created deployment.
+            work_pool_name: The name of the work pool to use for this deployment.
+            work_queue_name: The name of the work queue to use for this deployment's scheduled runs.
+                If not provided the default work queue for the work pool will be used.
+            job_variables: Settings used to override the values specified default base job template
+                of the chosen work pool. Refer to the base job template of the chosen work pool for
+            entrypoint_type: Type of entrypoint to use for the deployment. When using a module path
+                entrypoint, ensure that the module will be importable in the execution environment.
+            _sla: (Experimental) SLA configuration for the deployment. May be removed or modified at any time. Currently only supported on Prefect Cloud.
+
+        Examples:
+            Prepare two deployments and serve them:
+
+            ```python
+            from prefect import flow, serve
+
+            @flow
+            def my_flow(name):
+                print(f"hello {name}")
+
+            @flow
+            def my_other_flow(name):
+                print(f"goodbye {name}")
+
+            if __name__ == "__main__":
+                hello_deploy = my_flow.to_deployment("hello", tags=["dev"])
+                bye_deploy = my_other_flow.to_deployment("goodbye", tags=["dev"])
+                serve(hello_deploy, bye_deploy)
+            ```
+        """
+        from prefect.deployments.runner import RunnerDeployment
+
+        if not name.endswith(".py"):
+            _raise_on_name_with_banned_characters(name)
+
+        if self._storage and self._entrypoint:
+            return cast(
+                RunnerDeployment,
+                RunnerDeployment.from_storage(
+                    storage=self._storage,
+                    entrypoint=self._entrypoint,
+                    name=name,
+                    flow_name=self.name,
+                    interval=interval,
+                    cron=cron,
+                    rrule=rrule,
+                    paused=paused,
+                    schedule=schedule,
+                    schedules=schedules,
+                    concurrency_limit=concurrency_limit,
+                    tags=tags,
+                    triggers=triggers,
+                    parameters=parameters or {},
+                    description=description,
+                    version=version,
+                    enforce_parameter_schema=enforce_parameter_schema,
+                    work_pool_name=work_pool_name,
+                    work_queue_name=work_queue_name,
+                    job_variables=job_variables,
+                    _sla=_sla,
+                    _sync=True,  # pyright: ignore[reportCallIssue] _sync is valid because .from_storage is decorated with async_dispatch
+                ),
+            )
+        else:
+            return RunnerDeployment.from_flow(
+                flow=self,
+                name=name,
+                interval=interval,
+                cron=cron,
+                rrule=rrule,
+                paused=paused,
+                schedule=schedule,
                 schedules=schedules,
                 concurrency_limit=concurrency_limit,
                 tags=tags,
@@ -819,6 +963,7 @@ class Flow(Generic[P, R]):
         cron: Optional[Union[Iterable[str], str]] = None,
         rrule: Optional[Union[Iterable[str], str]] = None,
         paused: Optional[bool] = None,
+        schedule: Optional[Schedule] = None,
         schedules: Optional["FlexibleScheduleList"] = None,
         global_limit: Optional[Union[int, ConcurrencyLimitConfig, None]] = None,
         triggers: Optional[list[Union[DeploymentTriggerTypes, TriggerTypes]]] = None,
@@ -848,6 +993,8 @@ class Flow(Generic[P, R]):
                 Also accepts an iterable of rrule schedule strings to create multiple schedules.
             triggers: A list of triggers that will kick off runs of this deployment.
             paused: Whether or not to set this deployment as paused.
+            schedule: A schedule object defining when to execute runs of this deployment.
+                Used to provide additional scheduling options like `timezone` or `parameters`.
             schedules: A list of schedule objects defining when to execute runs of this deployment.
                 Used to define multiple schedules or additional scheduling options like `timezone`.
             global_limit: The maximum number of concurrent runs allowed across all served flow instances associated with the same deployment.
@@ -913,6 +1060,7 @@ class Flow(Generic[P, R]):
             cron=cron,
             rrule=rrule,
             paused=paused,
+            schedule=schedule,
             schedules=schedules,
             concurrency_limit=global_limit,
             parameters=parameters,
@@ -957,14 +1105,13 @@ class Flow(Generic[P, R]):
                 loop.stop()
 
     @classmethod
-    @sync_compatible
-    async def from_source(
+    async def afrom_source(
         cls,
         source: Union[str, "RunnerStorage", ReadableDeploymentStorage],
         entrypoint: str,
     ) -> "Flow[..., Any]":
         """
-        Loads a flow from a remote source.
+        Loads a flow from a remote source asynchronously.
 
         Args:
             source: Either a URL to a git repository or a storage object.
@@ -1070,6 +1217,115 @@ class Flow(Generic[P, R]):
 
         return flow
 
+    @classmethod
+    @async_dispatch(afrom_source)
+    def from_source(
+        cls,
+        source: Union[str, "RunnerStorage", ReadableDeploymentStorage],
+        entrypoint: str,
+    ) -> "Flow[..., Any]":
+        """
+        Loads a flow from a remote source.
+
+        Args:
+            source: Either a URL to a git repository or a storage object.
+            entrypoint:  The path to a file containing a flow and the name of the flow function in
+                the format `./path/to/file.py:flow_func_name`.
+
+        Returns:
+            A new `Flow` instance.
+
+        Examples:
+            Load a flow from a public git repository:
+
+
+            ```python
+            from prefect import flow
+            from prefect.runner.storage import GitRepository
+            from prefect.blocks.system import Secret
+
+            my_flow = flow.from_source(
+                source="https://github.com/org/repo.git",
+                entrypoint="flows.py:my_flow",
+            )
+
+            my_flow()
+            ```
+
+            Load a flow from a private git repository using an access token stored in a `Secret` block:
+
+            ```python
+            from prefect import flow
+            from prefect.runner.storage import GitRepository
+            from prefect.blocks.system import Secret
+
+            my_flow = flow.from_source(
+                source=GitRepository(
+                    url="https://github.com/org/repo.git",
+                    credentials={"access_token": Secret.load("github-access-token")}
+                ),
+                entrypoint="flows.py:my_flow",
+            )
+
+            my_flow()
+            ```
+
+            Load a flow from a local directory:
+
+            ``` python
+            # from_local_source.py
+
+            from pathlib import Path
+            from prefect import flow
+
+            @flow(log_prints=True)
+            def my_flow(name: str = "world"):
+                print(f"Hello {name}! I'm a flow from a Python script!")
+
+            if __name__ == "__main__":
+                my_flow.from_source(
+                    source=str(Path(__file__).parent),
+                    entrypoint="from_local_source.py:my_flow",
+                ).deploy(
+                    name="my-deployment",
+                    parameters=dict(name="Marvin"),
+                    work_pool_name="local",
+                )
+            ```
+        """
+
+        from prefect.runner.storage import (
+            BlockStorageAdapter,
+            LocalStorage,
+            RunnerStorage,
+            create_storage_from_source,
+        )
+
+        if isinstance(source, (Path, str)):
+            if isinstance(source, Path):
+                source = str(source)
+            storage = create_storage_from_source(source)
+        elif isinstance(source, RunnerStorage):
+            storage = source
+        elif hasattr(source, "get_directory"):
+            storage = BlockStorageAdapter(source)
+        else:
+            raise TypeError(
+                f"Unsupported source type {type(source).__name__!r}. Please provide a"
+                " URL to remote storage or a storage object."
+            )
+        with tempfile.TemporaryDirectory() as tmpdir:
+            if not isinstance(storage, LocalStorage):
+                storage.set_base_path(Path(tmpdir))
+                run_coro_as_sync(storage.pull_code())
+
+            full_entrypoint = str(storage.destination / entrypoint)
+            flow = load_flow_from_entrypoint(full_entrypoint)
+            flow._storage = storage
+            flow._entrypoint = entrypoint
+
+        return flow
+
     @sync_compatible
     async def deploy(
         self,
@@ -1084,7 +1340,8 @@ class Flow(Generic[P, R]):
         cron: Optional[str] = None,
         rrule: Optional[str] = None,
         paused: Optional[bool] = None,
-        schedules: Optional[list[DeploymentScheduleCreate]] = None,
+        schedule: Optional[Schedule] = None,
+        schedules: Optional[list[Schedule]] = None,
         concurrency_limit: Optional[Union[int, ConcurrencyLimitConfig, None]] = None,
         triggers: Optional[list[Union[DeploymentTriggerTypes, TriggerTypes]]] = None,
         parameters: Optional[dict[str, Any]] = None,
@@ -1131,6 +1388,8 @@ class Flow(Generic[P, R]):
                 Also accepts an iterable of rrule schedule strings to create multiple schedules.
             triggers: A list of triggers that will kick off runs of this deployment.
             paused: Whether or not to set this deployment as paused.
+            schedule: A schedule object defining when to execute runs of this deployment.
+                Used to provide additional scheduling options like `timezone` or `parameters`.
             schedules: A list of schedule objects defining when to execute runs of this deployment.
                 Used to define multiple schedules or additional scheduling options like `timezone`.
             concurrency_limit: The maximum number of runs that can be executed concurrently.
@@ -1215,6 +1474,7 @@ class Flow(Generic[P, R]):
             interval=interval,
             cron=cron,
             rrule=rrule,
+            schedule=schedule,
             schedules=schedules,
             concurrency_limit=concurrency_limit,
             paused=paused,
@@ -1292,16 +1552,14 @@ class Flow(Generic[P, R]):
     @overload
     def __call__(
         self: "Flow[P, Coroutine[Any, Any, T]]", *args: P.args, **kwargs: P.kwargs
-    ) -> Coroutine[Any, Any, T]:
-        ...
+    ) -> Coroutine[Any, Any, T]: ...
 
     @overload
     def __call__(
         self: "Flow[P, T]",
         *args: P.args,
         **kwargs: P.kwargs,
-    ) -> T:
-        ...
+    ) -> T: ...
 
     @overload
     def __call__(
@@ -1309,8 +1567,7 @@ class Flow(Generic[P, R]):
         *args: P.args,
         return_state: Literal[True],
         **kwargs: P.kwargs,
-    ) -> Awaitable[State[T]]:
-        ...
+    ) -> Awaitable[State[T]]: ...
 
     @overload
     def __call__(
@@ -1318,8 +1575,7 @@ class Flow(Generic[P, R]):
         *args: P.args,
         return_state: Literal[True],
         **kwargs: P.kwargs,
-    ) -> State[T]:
-        ...
+    ) -> State[T]: ...
 
     def __call__(
         self,
@@ -1458,8 +1714,7 @@ class Flow(Generic[P, R]):
 
 class FlowDecorator:
     @overload
-    def __call__(self, __fn: Callable[P, R]) -> Flow[P, R]:
-        ...
+    def __call__(self, __fn: Callable[P, R]) -> Flow[P, R]: ...
 
     @overload
     def __call__(
@@ -1485,8 +1740,7 @@ class FlowDecorator:
         on_cancellation: Optional[list[FlowStateHook[..., Any]]] = None,
         on_crashed: Optional[list[FlowStateHook[..., Any]]] = None,
         on_running: Optional[list[FlowStateHook[..., Any]]] = None,
-    ) -> Callable[[Callable[P, R]], Flow[P, R]]:
-        ...
+    ) -> Callable[[Callable[P, R]], Flow[P, R]]: ...
 
     @overload
     def __call__(
@@ -1512,8 +1766,7 @@ class FlowDecorator:
         on_cancellation: Optional[list[FlowStateHook[..., Any]]] = None,
         on_crashed: Optional[list[FlowStateHook[..., Any]]] = None,
         on_running: Optional[list[FlowStateHook[..., Any]]] = None,
-    ) -> Callable[[Callable[P, R]], Flow[P, R]]:
-        ...
+    ) -> Callable[[Callable[P, R]], Flow[P, R]]: ...
 
     def __call__(
         self,
@@ -1707,8 +1960,7 @@ class FlowDecorator:
         def from_source(
             source: Union[str, "RunnerStorage", ReadableDeploymentStorage],
             entrypoint: str,
-        ) -> Union["Flow[..., Any]", Coroutine[Any, Any, "Flow[..., Any]"]]:
-            ...
+        ) -> Union["Flow[..., Any]", Coroutine[Any, Any, "Flow[..., Any]"]]: ...
 
 
 flow: FlowDecorator = FlowDecorator()
@@ -1980,8 +2232,7 @@ def _display_serve_start_message(*args: "RunnerDeployment"):
     from rich.table import Table
 
     help_message_top = (
-        "[green]Your deployments are being served and polling for"
-        " scheduled runs!\n[/]"
+        "[green]Your deployments are being served and polling for scheduled runs!\n[/]"
     )
 
     table = Table(title="Deployments", show_header=False)

prefect/infrastructure/__init__.py

@@ -1,6 +1,7 @@
 """
 2024-06-27: This surfaces an actionable error message for moved or removed objects in Prefect 3.0 upgrade.
 """
+
 from typing import Any, Callable
 
 from prefect._internal.compatibility.migration import getattr_migration

prefect/infrastructure/base.py

@@ -1,6 +1,7 @@
 """
 2024-06-27: This surfaces an actionable error message for moved or removed objects in Prefect 3.0 upgrade.
 """
+
 from typing import Any, Callable
 
 from prefect._internal.compatibility.migration import getattr_migration

prefect/infrastructure/provisioners/__init__.py

@@ -22,20 +22,17 @@ _provisioners = {
 
 class Provisioner(Protocol):
     @property
-    def console(self) -> rich.console.Console:
-        ...
+    def console(self) -> rich.console.Console: ...
 
     @console.setter
-    def console(self, value: rich.console.Console) -> None:
-        ...
+    def console(self, value: rich.console.Console) -> None: ...
 
     async def provision(
         self,
         work_pool_name: str,
         base_job_template: Dict[str, Any],
         client: Optional["PrefectClient"] = None,
-    ) -> Dict[str, Any]:
-        ...
+    ) -> Dict[str, Any]: ...
 
 
 def get_infrastructure_provisioner_for_work_pool_type(

prefect/infrastructure/provisioners/coiled.py

@@ -118,9 +118,9 @@ class CoiledPushProvisioner:
                 block_type_id=credentials_block_type.id
             )
         )
-        assert (
-            credentials_block_schema is not None
-        ), f"Unable to find schema for block type {credentials_block_type.slug}"
+        assert credentials_block_schema is not None, (
+            f"Unable to find schema for block type {credentials_block_type.slug}"
+        )
 
         block_doc = await client.create_block_document(
             block_document=BlockDocumentCreate(

prefect/infrastructure/provisioners/container_instance.py

@@ -10,6 +10,7 @@ Classes:
     ContainerInstancePushProvisioner: A class for provisioning infrastructure using Azure Container Instances.
 
 """
+
 from __future__ import annotations
 
 import json

prefect/infrastructure/provisioners/ecs.py

@@ -341,9 +341,9 @@ class CredentialsBlockResource:
                     block_type_id=credentials_block_type.id
                 )
             )
-            assert (
-                credentials_block_schema is not None
-            ), f"Unable to find schema for block type {credentials_block_type.slug}"
+            assert credentials_block_schema is not None, (
+                f"Unable to find schema for block type {credentials_block_type.slug}"
+            )
 
             block_doc = await client.create_block_document(
                 block_document=BlockDocumentCreate(
@@ -597,9 +597,9 @@ class ClusterResource:
             )
             advance()
 
-        base_job_template["variables"]["properties"]["cluster"][
-            "default"
-        ] = self._cluster_name
+        base_job_template["variables"]["properties"]["cluster"]["default"] = (
+            self._cluster_name
+        )
 
     @property
     def next_steps(self) -> list[str]:

prefect/infrastructure/provisioners/modal.py

@@ -124,9 +124,9 @@ class ModalPushProvisioner:
                 block_type_id=credentials_block_type.id
             )
         )
-        assert (
-            credentials_block_schema is not None
-        ), f"Unable to find schema for block type {credentials_block_type.slug}"
+        assert credentials_block_schema is not None, (
+            f"Unable to find schema for block type {credentials_block_type.slug}"
+        )
 
         block_doc = await client.create_block_document(
             block_document=BlockDocumentCreate(

prefect/input/run_input.py

@@ -664,8 +664,7 @@ def receive_input(  # type: ignore[overload-overlap]
     key_prefix: Optional[str] = None,
     flow_run_id: Optional[UUID] = None,
     with_metadata: bool = False,
-) -> GetInputHandler[R]:
-    ...
+) -> GetInputHandler[R]: ...
 
 
 @overload
@@ -678,8 +677,7 @@ def receive_input(
     key_prefix: Optional[str] = None,
     flow_run_id: Optional[UUID] = None,
     with_metadata: bool = False,
-) -> GetAutomaticInputHandler[T]:
-    ...
+) -> GetAutomaticInputHandler[T]: ...
 
 
 def receive_input(
@@ -697,9 +695,9 @@ def receive_input(
     # the signature is the same as here:
     #   Union[Type[R], Type[T], pydantic.BaseModel],
     # Seems like a possible mypy bug, so we'll ignore the type check here.
-    input_cls: Union[
-        Type[AutomaticRunInput[T]], Type[R]
-    ] = run_input_subclass_from_type(input_type)  # type: ignore[arg-type]
+    input_cls: Union[Type[AutomaticRunInput[T]], Type[R]] = (
+        run_input_subclass_from_type(input_type)
+    )  # type: ignore[arg-type]
 
     if issubclass(input_cls, AutomaticRunInput):
         return input_cls.receive(