prefect-client 2.14.21__py3-none-any.whl → 2.15.0__py3-none-any.whl

prefect/_vendor/starlette/types.py

@@ -0,0 +1,30 @@
+import typing
+
+if typing.TYPE_CHECKING:
+    from prefect._vendor.starlette.requests import Request
+    from prefect._vendor.starlette.responses import Response
+    from prefect._vendor.starlette.websockets import WebSocket
+
+AppType = typing.TypeVar("AppType")
+
+Scope = typing.MutableMapping[str, typing.Any]
+Message = typing.MutableMapping[str, typing.Any]
+
+Receive = typing.Callable[[], typing.Awaitable[Message]]
+Send = typing.Callable[[Message], typing.Awaitable[None]]
+
+ASGIApp = typing.Callable[[Scope, Receive, Send], typing.Awaitable[None]]
+
+StatelessLifespan = typing.Callable[[AppType], typing.AsyncContextManager[None]]
+StatefulLifespan = typing.Callable[
+    [AppType], typing.AsyncContextManager[typing.Mapping[str, typing.Any]]
+]
+Lifespan = typing.Union[StatelessLifespan[AppType], StatefulLifespan[AppType]]
+
+HTTPExceptionHandler = typing.Callable[
+    ["Request", Exception], typing.Union["Response", typing.Awaitable["Response"]]
+]
+WebSocketExceptionHandler = typing.Callable[
+    ["WebSocket", Exception], typing.Awaitable[None]
+]
+ExceptionHandler = typing.Union[HTTPExceptionHandler, WebSocketExceptionHandler]

prefect/_vendor/starlette/websockets.py

@@ -0,0 +1,193 @@
+import enum
+import json
+import typing
+
+from prefect._vendor.starlette.requests import HTTPConnection
+from prefect._vendor.starlette.types import Message, Receive, Scope, Send
+
+
+class WebSocketState(enum.Enum):
+    CONNECTING = 0
+    CONNECTED = 1
+    DISCONNECTED = 2
+
+
+class WebSocketDisconnect(Exception):
+    def __init__(self, code: int = 1000, reason: typing.Optional[str] = None) -> None:
+        self.code = code
+        self.reason = reason or ""
+
+
+class WebSocket(HTTPConnection):
+    def __init__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        super().__init__(scope)
+        assert scope["type"] == "websocket"
+        self._receive = receive
+        self._send = send
+        self.client_state = WebSocketState.CONNECTING
+        self.application_state = WebSocketState.CONNECTING
+
+    async def receive(self) -> Message:
+        """
+        Receive ASGI websocket messages, ensuring valid state transitions.
+        """
+        if self.client_state == WebSocketState.CONNECTING:
+            message = await self._receive()
+            message_type = message["type"]
+            if message_type != "websocket.connect":
+                raise RuntimeError(
+                    'Expected ASGI message "websocket.connect", '
+                    f"but got {message_type!r}"
+                )
+            self.client_state = WebSocketState.CONNECTED
+            return message
+        elif self.client_state == WebSocketState.CONNECTED:
+            message = await self._receive()
+            message_type = message["type"]
+            if message_type not in {"websocket.receive", "websocket.disconnect"}:
+                raise RuntimeError(
+                    'Expected ASGI message "websocket.receive" or '
+                    f'"websocket.disconnect", but got {message_type!r}'
+                )
+            if message_type == "websocket.disconnect":
+                self.client_state = WebSocketState.DISCONNECTED
+            return message
+        else:
+            raise RuntimeError(
+                'Cannot call "receive" once a disconnect message has been received.'
+            )
+
+    async def send(self, message: Message) -> None:
+        """
+        Send ASGI websocket messages, ensuring valid state transitions.
+        """
+        if self.application_state == WebSocketState.CONNECTING:
+            message_type = message["type"]
+            if message_type not in {"websocket.accept", "websocket.close"}:
+                raise RuntimeError(
+                    'Expected ASGI message "websocket.accept" or '
+                    f'"websocket.close", but got {message_type!r}'
+                )
+            if message_type == "websocket.close":
+                self.application_state = WebSocketState.DISCONNECTED
+            else:
+                self.application_state = WebSocketState.CONNECTED
+            await self._send(message)
+        elif self.application_state == WebSocketState.CONNECTED:
+            message_type = message["type"]
+            if message_type not in {"websocket.send", "websocket.close"}:
+                raise RuntimeError(
+                    'Expected ASGI message "websocket.send" or "websocket.close", '
+                    f"but got {message_type!r}"
+                )
+            if message_type == "websocket.close":
+                self.application_state = WebSocketState.DISCONNECTED
+            await self._send(message)
+        else:
+            raise RuntimeError('Cannot call "send" once a close message has been sent.')
+
+    async def accept(
+        self,
+        subprotocol: typing.Optional[str] = None,
+        headers: typing.Optional[typing.Iterable[typing.Tuple[bytes, bytes]]] = None,
+    ) -> None:
+        headers = headers or []
+
+        if self.client_state == WebSocketState.CONNECTING:
+            # If we haven't yet seen the 'connect' message, then wait for it first.
+            await self.receive()
+        await self.send(
+            {"type": "websocket.accept", "subprotocol": subprotocol, "headers": headers}
+        )
+
+    def _raise_on_disconnect(self, message: Message) -> None:
+        if message["type"] == "websocket.disconnect":
+            raise WebSocketDisconnect(message["code"], message.get("reason"))
+
+    async def receive_text(self) -> str:
+        if self.application_state != WebSocketState.CONNECTED:
+            raise RuntimeError(
+                'WebSocket is not connected. Need to call "accept" first.'
+            )
+        message = await self.receive()
+        self._raise_on_disconnect(message)
+        return typing.cast(str, message["text"])
+
+    async def receive_bytes(self) -> bytes:
+        if self.application_state != WebSocketState.CONNECTED:
+            raise RuntimeError(
+                'WebSocket is not connected. Need to call "accept" first.'
+            )
+        message = await self.receive()
+        self._raise_on_disconnect(message)
+        return typing.cast(bytes, message["bytes"])
+
+    async def receive_json(self, mode: str = "text") -> typing.Any:
+        if mode not in {"text", "binary"}:
+            raise RuntimeError('The "mode" argument should be "text" or "binary".')
+        if self.application_state != WebSocketState.CONNECTED:
+            raise RuntimeError(
+                'WebSocket is not connected. Need to call "accept" first.'
+            )
+        message = await self.receive()
+        self._raise_on_disconnect(message)
+
+        if mode == "text":
+            text = message["text"]
+        else:
+            text = message["bytes"].decode("utf-8")
+        return json.loads(text)
+
+    async def iter_text(self) -> typing.AsyncIterator[str]:
+        try:
+            while True:
+                yield await self.receive_text()
+        except WebSocketDisconnect:
+            pass
+
+    async def iter_bytes(self) -> typing.AsyncIterator[bytes]:
+        try:
+            while True:
+                yield await self.receive_bytes()
+        except WebSocketDisconnect:
+            pass
+
+    async def iter_json(self) -> typing.AsyncIterator[typing.Any]:
+        try:
+            while True:
+                yield await self.receive_json()
+        except WebSocketDisconnect:
+            pass
+
+    async def send_text(self, data: str) -> None:
+        await self.send({"type": "websocket.send", "text": data})
+
+    async def send_bytes(self, data: bytes) -> None:
+        await self.send({"type": "websocket.send", "bytes": data})
+
+    async def send_json(self, data: typing.Any, mode: str = "text") -> None:
+        if mode not in {"text", "binary"}:
+            raise RuntimeError('The "mode" argument should be "text" or "binary".')
+        text = json.dumps(data, separators=(",", ":"), ensure_ascii=False)
+        if mode == "text":
+            await self.send({"type": "websocket.send", "text": text})
+        else:
+            await self.send({"type": "websocket.send", "bytes": text.encode("utf-8")})
+
+    async def close(
+        self, code: int = 1000, reason: typing.Optional[str] = None
+    ) -> None:
+        await self.send(
+            {"type": "websocket.close", "code": code, "reason": reason or ""}
+        )
+
+
+class WebSocketClose:
+    def __init__(self, code: int = 1000, reason: typing.Optional[str] = None) -> None:
+        self.code = code
+        self.reason = reason or ""
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        await send(
+            {"type": "websocket.close", "code": self.code, "reason": self.reason}
+        )

prefect/blocks/core.py

@@ -257,9 +257,9 @@ class Block(BaseModel, ABC):
                                     type_._to_block_schema_reference_dict(),
                                 ]
                             else:
-                                refs[field.name] = (
-                                    type_._to_block_schema_reference_dict()
-                                )
+                                refs[
+                                    field.name
+                                ] = type_._to_block_schema_reference_dict()
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)

prefect/blocks/notifications.py

@@ -24,14 +24,14 @@ class AbstractAppriseNotificationBlock(NotificationBlock, ABC):
     An abstract class for sending notifications using Apprise.
     """
 
-    notify_type: Literal["prefect_default", "info", "success", "warning", "failure"] = (
-        Field(
-            default=PREFECT_NOTIFY_TYPE_DEFAULT,
-            description=(
-                "The type of notification being performed; the prefect_default "
-                "is a plain notification that does not attach an image."
-            ),
-        )
+    notify_type: Literal[
+        "prefect_default", "info", "success", "warning", "failure"
+    ] = Field(
+        default=PREFECT_NOTIFY_TYPE_DEFAULT,
+        description=(
+            "The type of notification being performed; the prefect_default "
+            "is a plain notification that does not attach an image."
+        ),
     )
 
     def __init__(self, *args, **kwargs):

prefect/client/base.py

@@ -22,7 +22,7 @@ import anyio
 import httpx
 from asgi_lifespan import LifespanManager
 from httpx import HTTPStatusError, Response
-from starlette import status
+from prefect._vendor.starlette import status
 from typing_extensions import Self
 
 from prefect.exceptions import PrefectHTTPStatusError

prefect/client/cloud.py

@@ -11,7 +11,7 @@ if HAS_PYDANTIC_V2:
 else:
     import pydantic
 
-from starlette import status
+from prefect._vendor.starlette import status
 
 import prefect.context
 import prefect.settings

prefect/client/orchestration.py

@@ -26,7 +26,7 @@ else:
     import pydantic
 
 from asgi_lifespan import LifespanManager
-from starlette import status
+from prefect._vendor.starlette import status
 
 import prefect
 import prefect.exceptions

prefect/client/subscriptions.py

@@ -4,7 +4,7 @@ from typing import Generic, List, Type, TypeVar
 import orjson
 import websockets
 import websockets.exceptions
-from starlette.status import WS_1008_POLICY_VIOLATION
+from prefect._vendor.starlette.status import WS_1008_POLICY_VIOLATION
 from typing_extensions import Self
 
 from prefect._internal.schemas.bases import IDBaseModel
@@ -40,11 +40,7 @@ class Subscription(Generic[S]):
                 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
+                await self._websocket.send(orjson.dumps({"type": "ack"}).decode())
 
                 return self.model.parse_raw(message)
             except (

prefect/concurrency/services.py

@@ -7,7 +7,7 @@ from typing import (
 )
 
 import httpx
-from starlette import status
+from prefect._vendor.starlette import status
 
 from prefect import get_client
 from prefect._internal.concurrency import logger

prefect/context.py

@@ -137,9 +137,9 @@ class PrefectObjectRegistry(ContextModel):
     )
 
     # Failures will be a tuple of (exception, instance, args, kwargs)
-    _instance_init_failures: Dict[Type[T], List[Tuple[Exception, T, Tuple, Dict]]] = (
-        PrivateAttr(default_factory=lambda: defaultdict(list))
-    )
+    _instance_init_failures: Dict[
+        Type[T], List[Tuple[Exception, T, Tuple, Dict]]
+    ] = PrivateAttr(default_factory=lambda: defaultdict(list))
 
     block_code_execution: bool = False
     capture_failures: bool = False

prefect/deployments/deployments.py

@@ -93,13 +93,13 @@ async def run_deployment(
             run metadata immediately. Setting `timeout` to None will allow this
             function to poll indefinitely. Defaults to None.
         poll_interval: The number of seconds between polls
-        tags: A list of tags to associate with this flow run; note that tags are used
-            only for organizational purposes.
+        tags: A list of tags to associate with this flow run; tags can be used in
+            automations and for organizational purposes.
         idempotency_key: A unique value to recognize retries of the same run, and
             prevent creating multiple flow runs.
         work_queue_name: The name of a work queue to use for this run. Defaults to
             the default work queue for the deployment.
-        as_subflow: Whether or not to link the flow run as a subflow of the current
+        as_subflow: Whether to link the flow run as a subflow of the current
             flow or task run.
     """
     if timeout is not None and timeout < 0:

prefect/engine.py

@@ -192,6 +192,8 @@ from prefect.states import (
 from prefect.task_runners import (
     CONCURRENCY_MESSAGES,
     BaseTaskRunner,
+    ConcurrentTaskRunner,
+    SequentialTaskRunner,
     TaskConcurrencyType,
 )
 from prefect.tasks import Task
@@ -850,7 +852,11 @@ async def orchestrate_flow_run(
                     not parent_flow_run_context
                     or (
                         parent_flow_run_context
-                        and parent_flow_run_context.flow.isasync == flow.isasync
+                        and
+                        # Unless the parent is async and the child is sync, run the
+                        # child flow in the parent thread; running a sync child in
+                        # an async parent could be bad for async performance.
+                        not (parent_flow_run_context.flow.isasync and not flow.isasync)
                     )
                 ):
                     from_async.call_soon_in_waiting_thread(
@@ -1405,6 +1411,7 @@ def enter_task_run_engine(
         wait_for=wait_for,
         return_type=return_type,
         task_runner=task_runner,
+        user_thread=threading.current_thread(),
     )
 
     if task.isasync and flow_run_context.flow.isasync:
@@ -1421,6 +1428,7 @@ async def begin_task_map(
     wait_for: Optional[Iterable[PrefectFuture]],
     return_type: EngineReturnType,
     task_runner: Optional[BaseTaskRunner],
+    user_thread: threading.Thread,
 ) -> List[Union[PrefectFuture, Awaitable[PrefectFuture]]]:
     """Async entrypoint for task mapping"""
     # We need to resolve some futures to map over their data, collect the upstream
@@ -1498,6 +1506,7 @@ async def begin_task_map(
                 return_type=return_type,
                 task_runner=task_runner,
                 extra_task_inputs=task_inputs,
+                user_thread=user_thread,
             )
         )
 
@@ -1562,6 +1571,7 @@ async def get_task_call_return_value(
     wait_for: Optional[Iterable[PrefectFuture]],
     return_type: EngineReturnType,
     task_runner: Optional[BaseTaskRunner],
+    user_thread: threading.Thread,
     extra_task_inputs: Optional[Dict[str, Set[TaskRunInput]]] = None,
 ):
     extra_task_inputs = extra_task_inputs or {}
@@ -1573,6 +1583,7 @@ async def get_task_call_return_value(
         wait_for=wait_for,
         task_runner=task_runner,
         extra_task_inputs=extra_task_inputs,
+        user_thread=user_thread,
     )
     if return_type == "future":
         return future
@@ -1591,6 +1602,7 @@ async def create_task_run_future(
     wait_for: Optional[Iterable[PrefectFuture]],
     task_runner: Optional[BaseTaskRunner],
     extra_task_inputs: Dict[str, Set[TaskRunInput]],
+    user_thread: threading.Thread,
 ) -> PrefectFuture:
     # Default to the flow run's task runner
     task_runner = task_runner or flow_run_context.task_runner
@@ -1628,6 +1640,7 @@ async def create_task_run_future(
             wait_for=wait_for,
             task_runner=task_runner,
             extra_task_inputs=extra_task_inputs,
+            user_thread=user_thread,
         )
     )
 
@@ -1651,6 +1664,7 @@ async def create_task_run_then_submit(
     wait_for: Optional[Iterable[PrefectFuture]],
     task_runner: BaseTaskRunner,
     extra_task_inputs: Dict[str, Set[TaskRunInput]],
+    user_thread: threading.Thread,
 ) -> None:
     task_run = (
         await create_task_run(
@@ -1677,6 +1691,7 @@ async def create_task_run_then_submit(
         task_run=task_run,
         wait_for=wait_for,
         task_runner=task_runner,
+        user_thread=user_thread,
     )
 
     future._submitted.set()
@@ -1724,6 +1739,7 @@ async def submit_task_run(
     task_run: TaskRun,
     wait_for: Optional[Iterable[PrefectFuture]],
     task_runner: BaseTaskRunner,
+    user_thread: threading.Thread,
 ) -> PrefectFuture:
     logger = get_run_logger(flow_run_context)
 
@@ -1733,6 +1749,10 @@ async def submit_task_run(
     ):
         logger.info(f"Executing {task_run.name!r} immediately...")
 
+    if not isinstance(task_runner, (ConcurrentTaskRunner, SequentialTaskRunner)):
+        # Only pass the user thread to "local" task runners
+        user_thread = None
+
     future = await task_runner.submit(
         key=future.key,
         call=partial(
@@ -1746,6 +1766,8 @@ async def submit_task_run(
             ),
             log_prints=should_log_prints(task),
             settings=prefect.context.SettingsContext.get().copy(),
+            user_thread=user_thread,
+            concurrency_type=task_runner.concurrency_type,
         ),
     )
 
@@ -1766,6 +1788,8 @@ async def begin_task_run(
     result_factory: ResultFactory,
     log_prints: bool,
     settings: prefect.context.SettingsContext,
+    user_thread: Optional[threading.Thread],
+    concurrency_type: TaskConcurrencyType,
 ):
     """
     Entrypoint for task run execution.
@@ -1836,6 +1860,8 @@ async def begin_task_run(
                 log_prints=log_prints,
                 interruptible=interruptible,
                 client=client,
+                user_thread=user_thread,
+                concurrency_type=concurrency_type,
             )
 
             if not maybe_flow_run_context:
@@ -1886,6 +1912,8 @@ async def orchestrate_task_run(
     log_prints: bool,
     interruptible: bool,
     client: PrefectClient,
+    concurrency_type: TaskConcurrencyType,
+    user_thread: Optional[threading.Thread],
 ) -> State:
     """
     Execute a task run
@@ -1917,6 +1945,7 @@ async def orchestrate_task_run(
         flow_run = flow_run_context.flow_run
     else:
         flow_run = await client.read_flow_run(task_run.flow_run_id)
+
     logger = task_run_logger(task_run, task=task, flow_run=flow_run)
 
     partial_task_run_context = PartialModel(
@@ -2115,9 +2144,41 @@ async def orchestrate_task_run(
                         "Beginning execution...", extra={"state_message": True}
                     )
 
-                call = from_async.call_soon_in_new_thread(
-                    create_call(task.fn, *args, **kwargs), timeout=task.timeout_seconds
-                )
+                call = create_call(task.fn, *args, **kwargs)
+
+                if (
+                    flow_run_context
+                    and user_thread
+                    and (
+                        # Async and sync tasks can be executed on synchronous flows
+                        # if the task runner is sequential; if the task is sync and a
+                        # concurrent task runner is used, we must execute it in a worker
+                        # thread instead.
+                        (
+                            concurrency_type == TaskConcurrencyType.SEQUENTIAL
+                            and (
+                                flow_run_context.flow
+                                and not flow_run_context.flow.isasync
+                            )
+                        )
+                        # Async tasks can always be executed on asynchronous flow; if the
+                        # flow is async we do not want to block the event loop with
+                        # synchronous tasks
+                        or (
+                            flow_run_context.flow
+                            and flow_run_context.flow.isasync
+                            and task.isasync
+                        )
+                    )
+                ):
+                    from_async.call_soon_in_waiting_thread(
+                        call, thread=user_thread, timeout=task.timeout_seconds
+                    )
+                else:
+                    from_async.call_soon_in_new_thread(
+                        call, timeout=task.timeout_seconds
+                    )
+
                 result = await call.aresult()
 
             except (CancelledError, asyncio.CancelledError) as exc:
@@ -2446,8 +2507,7 @@ async def resolve_inputs(
             #       incorrectly evaluate to false — to resolve this, we must track all
             #       annotations wrapping the current expression but this is not yet
             #       implemented.
-            isinstance(context.get("annotation"), allow_failure)
-            and state.is_failed()
+            isinstance(context.get("annotation"), allow_failure) and state.is_failed()
         ):
             raise UpstreamTaskError(
                 f"Upstream task run '{state.state_details.task_run_id}' did not reach a"
@@ -2931,10 +2991,10 @@ async def _create_autonomous_task_run(
     task: Task, parameters: Dict[str, Any]
 ) -> TaskRun:
     async with get_client() as client:
-        scheduled = Scheduled()
+        state = Scheduled()
         if parameters:
             parameters_id = uuid4()
-            scheduled.state_details.task_parameters_id = parameters_id
+            state.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.
@@ -2946,7 +3006,7 @@ async def _create_autonomous_task_run(
             task=task,
             flow_run_id=None,
             dynamic_key=f"{task.task_key}-{str(uuid4())[:NUM_CHARS_DYNAMIC_KEY]}",
-            state=scheduled,
+            state=state,
         )
 
         engine_logger.debug(f"Submitted run of task {task.name!r} for execution")

prefect/events/clients.py

@@ -21,7 +21,7 @@ try:
     from cachetools import TTLCache
 except ImportError:
     pass
-from starlette.status import WS_1008_POLICY_VIOLATION
+from prefect._vendor.starlette.status import WS_1008_POLICY_VIOLATION
 from websockets.client import WebSocketClientProtocol, connect
 from websockets.exceptions import (
     ConnectionClosed,

prefect/filesystems.py

@@ -709,13 +709,13 @@ class Azure(WritableFileSystem, WritableDeploymentStorage):
     def filesystem(self) -> RemoteFileSystem:
         settings = {}
         if self.azure_storage_connection_string:
-            settings["connection_string"] = (
-                self.azure_storage_connection_string.get_secret_value()
-            )
+            settings[
+                "connection_string"
+            ] = self.azure_storage_connection_string.get_secret_value()
         if self.azure_storage_account_name:
-            settings["account_name"] = (
-                self.azure_storage_account_name.get_secret_value()
-            )
+            settings[
+                "account_name"
+            ] = self.azure_storage_account_name.get_secret_value()
         if self.azure_storage_account_key:
             settings["account_key"] = self.azure_storage_account_key.get_secret_value()
         if self.azure_storage_tenant_id:
@@ -723,9 +723,9 @@ class Azure(WritableFileSystem, WritableDeploymentStorage):
         if self.azure_storage_client_id:
             settings["client_id"] = self.azure_storage_client_id.get_secret_value()
         if self.azure_storage_client_secret:
-            settings["client_secret"] = (
-                self.azure_storage_client_secret.get_secret_value()
-            )
+            settings[
+                "client_secret"
+            ] = self.azure_storage_client_secret.get_secret_value()
         settings["anon"] = self.azure_storage_anon
         self._remote_file_system = RemoteFileSystem(
             basepath=self.basepath, settings=settings

prefect/flow_runs.py

@@ -7,6 +7,7 @@ from prefect.client.orchestration import PrefectClient
 from prefect.client.schemas import FlowRun
 from prefect.client.utilities import inject_client
 from prefect.exceptions import FlowRunWaitTimeout
+from prefect.logging import get_logger
 
 
 @inject_client
@@ -15,6 +16,7 @@ async def wait_for_flow_run(
     timeout: Optional[int] = 10800,
     poll_interval: int = 5,
     client: Optional[PrefectClient] = None,
+    log_states: bool = False,
 ) -> FlowRun:
     """
     Waits for the prefect flow run to finish and returns the FlowRun
@@ -71,14 +73,16 @@ async def wait_for_flow_run(
             ```
     """
     assert client is not None, "Client injection failed"
+    logger = get_logger()
     with anyio.move_on_after(timeout):
         while True:
             flow_run = await client.read_flow_run(flow_run_id)
             flow_state = flow_run.state
+            if log_states:
+                logger.info(f"Flow run is in state {flow_run.state.name!r}")
             if flow_state and flow_state.is_final():
                 return flow_run
             await anyio.sleep(poll_interval)
-
     raise FlowRunWaitTimeout(
         f"Flow run with ID {flow_run_id} exceeded watch timeout of {timeout} seconds"
     )

prefect/futures.py

@@ -360,7 +360,7 @@ async def resolve_futures_to_data(
 
 
 async def resolve_futures_to_states(
-    expr: Union[PrefectFuture[R, Any], Any]
+    expr: Union[PrefectFuture[R, Any], Any],
 ) -> Union[State[R], Any]:
     """
     Given a Python built-in collection, recursively find `PrefectFutures` and build a