prefect-client 3.2.13__py3-none-any.whl → 3.2.15__py3-none-any.whl

prefect/logging/handlers.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import inspect
 import json
 import logging
 import sys
@@ -44,10 +45,13 @@ else:
     else:
         StreamHandler = logging.StreamHandler
 
+if TYPE_CHECKING:
+    from prefect.client.schemas.objects import FlowRun, TaskRun
+
 
 class APILogWorker(BatchedQueueService[Dict[str, Any]]):
     @property
-    def _max_batch_size(self) -> int:
+    def max_batch_size(self) -> int:
         return max(
             PREFECT_LOGGING_TO_API_BATCH_SIZE.value()
             - PREFECT_LOGGING_TO_API_MAX_LOG_SIZE.value(),
@@ -55,7 +59,7 @@ class APILogWorker(BatchedQueueService[Dict[str, Any]]):
         )
 
     @property
-    def _min_interval(self) -> float | None:
+    def min_interval(self) -> float | None:
         return PREFECT_LOGGING_TO_API_BATCH_INTERVAL.value()
 
     async def _handle_batch(self, items: list[dict[str, Any]]):
@@ -77,7 +81,7 @@ class APILogWorker(BatchedQueueService[Dict[str, Any]]):
             yield
 
     @classmethod
-    def instance(cls: Type[Self]) -> Self:
+    def instance(cls: Type[Self], *args: Any) -> Self:
         settings = (
             PREFECT_LOGGING_TO_API_BATCH_SIZE.value(),
             PREFECT_API_URL.value(),
@@ -85,7 +89,7 @@ class APILogWorker(BatchedQueueService[Dict[str, Any]]):
         )
 
         # Ensure a unique worker is retrieved per relevant logging settings
-        return super().instance(*settings)
+        return super().instance(*settings, *args)
 
     def _get_size(self, item: Dict[str, Any]) -> int:
         return item.pop("__payload_size__", None) or len(json.dumps(item).encode())
@@ -99,8 +103,7 @@ class APILogHandler(logging.Handler):
     the background.
     """
 
-    @classmethod
-    def flush(cls) -> None:
+    def flush(self) -> None:
         """
         Tell the `APILogWorker` to send any currently enqueued logs and block until
         completion.
@@ -119,22 +122,23 @@ class APILogHandler(logging.Handler):
             # Not ideal, but this method is called by the stdlib and cannot return a
             # coroutine so we just schedule the drain in a new thread and continue
             from_sync.call_soon_in_new_thread(create_call(APILogWorker.drain_all))
-            return None
         else:
             # We set a timeout of 5s because we don't want to block forever if the worker
             # is stuck. This can occur when the handler is being shutdown and the
             # `logging._lock` is held but the worker is attempting to emit logs resulting
             # in a deadlock.
-            return APILogWorker.drain_all(timeout=5)
+            APILogWorker.drain_all(timeout=5)
 
     @classmethod
-    async def aflush(cls) -> bool:
+    async def aflush(cls) -> None:
         """
         Tell the `APILogWorker` to send any currently enqueued logs and block until
         completion.
         """
 
-        return await APILogWorker.drain_all()
+        result = APILogWorker.drain_all()
+        if inspect.isawaitable(result):
+            await result
 
     def emit(self, record: logging.LogRecord) -> None:
         """
@@ -202,11 +206,15 @@ class APILogHandler(logging.Handler):
                     " flow run contexts unless the flow run id is manually provided."
                 ) from None
 
-            if hasattr(context, "flow_run"):
-                flow_run_id = context.flow_run.id
-            elif hasattr(context, "task_run"):
-                flow_run_id = context.task_run.flow_run_id
-                task_run_id = task_run_id or context.task_run.id
+            if flow_run := getattr(context, "flow_run", None):
+                if TYPE_CHECKING:
+                    assert isinstance(flow_run, FlowRun)
+                flow_run_id = flow_run.id
+            elif task_run := getattr(context, "task_run", None):
+                if TYPE_CHECKING:
+                    assert isinstance(task_run, TaskRun)
+                flow_run_id = task_run.flow_run_id
+                task_run_id = task_run_id or task_run.id
             else:
                 raise ValueError(
                     "Encountered malformed run context. Does not contain flow or task "
@@ -216,15 +224,14 @@ class APILogHandler(logging.Handler):
         # Parsing to a `LogCreate` object here gives us nice parsing error messages
         # from the standard lib `handleError` method if something goes wrong and
         # prevents malformed logs from entering the queue
-        try:
-            is_uuid_like = isinstance(flow_run_id, uuid.UUID) or (
-                isinstance(flow_run_id, str) and uuid.UUID(flow_run_id)
-            )
-        except ValueError:
-            is_uuid_like = False
+        if isinstance(flow_run_id, str):
+            try:
+                flow_run_id = uuid.UUID(flow_run_id)
+            except ValueError:
+                flow_run_id = None
 
         log = LogCreate(
-            flow_run_id=flow_run_id if is_uuid_like else None,
+            flow_run_id=flow_run_id,
             task_run_id=task_run_id,
             worker_id=worker_id,
             name=record.name,
@@ -306,15 +313,19 @@ class PrefectConsoleHandler(StreamHandler):
         styled_console = PREFECT_LOGGING_COLORS.value()
         markup_console = PREFECT_LOGGING_MARKUP.value()
         if styled_console:
-            highlighter = highlighter()
+            highlighter_instance = highlighter()
             theme = Theme(styles, inherit=False)
         else:
-            highlighter = NullHighlighter()
+            highlighter_instance = NullHighlighter()
             theme = Theme(inherit=False)
 
-        self.level = level
+        if isinstance(level, str):
+            self.level: int = logging.getLevelNamesMapping()[level]
+        else:
+            self.level: int = level
+
         self.console: Console = Console(
-            highlighter=highlighter,
+            highlighter=highlighter_instance,
             theme=theme,
             file=self.stream,
             markup=markup_console,

prefect/results.py

@@ -552,7 +552,11 @@ class ResultStore(BaseModel):
         if self.result_storage_block_id is None and (
             _resolve_path := getattr(self.result_storage, "_resolve_path", None)
         ):
-            return str(_resolve_path(key))
+            path_key = _resolve_path(key)
+            if path_key is not None:
+                return str(_resolve_path(key))
+            else:
+                return key
         return key
 
     @sync_compatible
@@ -684,7 +688,9 @@ class ResultStore(BaseModel):
 
         if self.result_storage_block_id is None:
             if _resolve_path := getattr(self.result_storage, "_resolve_path", None):
-                key = str(_resolve_path(key))
+                path_key = _resolve_path(key)
+                if path_key is not None:
+                    key = str(_resolve_path(key))
 
         return ResultRecord(
             result=obj,
@@ -773,7 +779,7 @@ class ResultStore(BaseModel):
                 )
                 else Path(".").resolve()
             )
-            base_key = str(Path(key).relative_to(basepath))
+            base_key = key if basepath is None else str(Path(key).relative_to(basepath))
         else:
             base_key = key
         if (

prefect/runner/__init__.py

@@ -1,2 +1,4 @@
 from .runner import Runner
 from .submit import submit_to_runner, wait_for_submitted_runs
+
+__all__ = ["Runner", "submit_to_runner", "wait_for_submitted_runs"]

prefect/runner/runner.py

@@ -1425,7 +1425,7 @@ class Runner:
             )
             status_code = process.returncode
         except Exception as exc:
-            if not task_status._future.done():
+            if not task_status._future.done():  # type: ignore
                 # This flow run was being submitted and did not start successfully
                 run_logger.exception(
                     f"Failed to start process for flow run '{flow_run.id}'."

prefect/runner/server.py

@@ -1,5 +1,7 @@
+from __future__ import annotations
+
 import uuid
-from typing import TYPE_CHECKING, Any, Callable, Coroutine, Hashable, Optional, Tuple
+from typing import TYPE_CHECKING, Any, Callable, Coroutine, Hashable, Optional
 
 import uvicorn
 from fastapi import APIRouter, FastAPI, HTTPException, status
@@ -33,7 +35,7 @@ if TYPE_CHECKING:
 
 from pydantic import BaseModel
 
-logger: "logging.Logger" = get_logger("webserver")
+logger: "logging.Logger" = get_logger("runner.webserver")
 
 RunnableEndpoint = Literal["deployment", "flow", "task"]
 
@@ -45,7 +47,7 @@ class RunnerGenericFlowRunRequest(BaseModel):
 
 
 def perform_health_check(
-    runner: "Runner", delay_threshold: Optional[int] = None
+    runner: "Runner", delay_threshold: int | None = None
 ) -> Callable[..., JSONResponse]:
     if delay_threshold is None:
         delay_threshold = (
@@ -57,6 +59,9 @@ def perform_health_check(
         now = DateTime.now("utc")
         poll_delay = (now - runner.last_polled).total_seconds()
 
+        if TYPE_CHECKING:
+            assert delay_threshold is not None
+
         if poll_delay > delay_threshold:
             return JSONResponse(
                 status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
@@ -120,7 +125,7 @@ async def _build_endpoint_for_deployment(
 
 async def get_deployment_router(
     runner: "Runner",
-) -> Tuple[APIRouter, dict[Hashable, Any]]:
+) -> tuple[APIRouter, dict[Hashable, Any]]:
     router = APIRouter()
     schemas: dict[Hashable, Any] = {}
     async with get_client() as client:
@@ -216,14 +221,14 @@ def _build_generic_endpoint_for_flows(
         # Verify that the flow we're loading is a subflow this runner is
         # managing
         if not _flow_in_schemas(flow, schemas):
-            runner._logger.warning(
+            logger.warning(
                 f"Flow {flow.name} is not directly managed by the runner. Please "
                 "include it in the runner's served flows' import namespace."
             )
         # Verify that the flow we're loading hasn't changed since the webserver
         # was started
         if _flow_schema_changed(flow, schemas):
-            runner._logger.warning(
+            logger.warning(
                 "A change in flow parameters has been detected. Please "
                 "restart the runner."
             )
@@ -291,7 +296,7 @@ async def build_server(runner: "Runner") -> FastAPI:
     return webserver
 
 
-def start_webserver(runner: "Runner", log_level: Optional[str] = None) -> None:
+def start_webserver(runner: "Runner", log_level: str | None = None) -> None:
     """
     Run a FastAPI server for a runner.
 

prefect/runner/storage.py

@@ -6,7 +6,6 @@ from copy import deepcopy
 from pathlib import Path
 from typing import (
     Any,
-    Dict,
     Optional,
     Protocol,
     TypedDict,
@@ -16,7 +15,7 @@ from typing import (
 from urllib.parse import urlparse, urlsplit, urlunparse
 from uuid import uuid4
 
-import fsspec
+import fsspec  # pyright: ignore[reportMissingTypeStubs]
 from anyio import run_process
 from pydantic import SecretStr
 
@@ -79,7 +78,7 @@ class RunnerStorage(Protocol):
 
 class GitCredentials(TypedDict, total=False):
     username: str
-    access_token: Union[str, Secret[str]]
+    access_token: str | Secret[str]
 
 
 class GitRepository:
@@ -117,12 +116,12 @@ class GitRepository:
     def __init__(
         self,
         url: str,
-        credentials: Union[GitCredentials, Block, Dict[str, Any], None] = None,
-        name: Optional[str] = None,
-        branch: Optional[str] = None,
+        credentials: Union[GitCredentials, Block, dict[str, Any], None] = None,
+        name: str | None = None,
+        branch: str | None = None,
         include_submodules: bool = False,
-        pull_interval: Optional[int] = 60,
-        directories: Optional[str] = None,
+        pull_interval: int | None = 60,
+        directories: list[str] | None = None,
     ):
         if credentials is None:
             credentials = {}
@@ -198,7 +197,7 @@ class GitRepository:
     @property
     def _git_config(self) -> list[str]:
         """Build a git configuration to use when running git commands."""
-        config = {}
+        config: dict[str, str] = {}
 
         # Submodules can be private. The url in .gitmodules
         # will not include the credentials, we need to
@@ -220,7 +219,7 @@ class GitRepository:
             result = await run_process(
                 ["git", "config", "--get", "core.sparseCheckout"], cwd=self.destination
             )
-            return result.strip().lower() == "true"
+            return result.stdout.decode().strip().lower() == "true"
         except Exception:
             return False
 
@@ -243,8 +242,7 @@ class GitRepository:
                 cwd=str(self.destination),
             )
             existing_repo_url = None
-            if result.stdout is not None:
-                existing_repo_url = _strip_auth_from_url(result.stdout.decode().strip())
+            existing_repo_url = _strip_auth_from_url(result.stdout.decode().strip())
 
             if existing_repo_url != self._url:
                 raise ValueError(
@@ -255,7 +253,7 @@ class GitRepository:
             # Sparsely checkout the repository if directories are specified and the repo is not in sparse-checkout mode already
             if self._directories and not await self.is_sparsely_checked_out():
                 await run_process(
-                    ["git", "sparse-checkout", "set"] + self._directories,
+                    ["git", "sparse-checkout", "set", *self._directories],
                     cwd=self.destination,
                 )
 
@@ -323,7 +321,7 @@ class GitRepository:
         if self._directories:
             self._logger.debug("Will add %s", self._directories)
             await run_process(
-                ["git", "sparse-checkout", "set"] + self._directories,
+                ["git", "sparse-checkout", "set", *self._directories],
                 cwd=self.destination,
             )
 
@@ -343,7 +341,7 @@ class GitRepository:
         )
 
     def to_pull_step(self) -> dict[str, Any]:
-        pull_step = {
+        pull_step: dict[str, Any] = {
             "prefect.deployments.steps.git_clone": {
                 "repository": self._url,
                 "branch": self._branch,
@@ -357,13 +355,14 @@ class GitRepository:
             pull_step["prefect.deployments.steps.git_clone"]["credentials"] = (
                 f"{{{{ {self._credentials.get_block_placeholder()} }}}}"
             )
-        elif isinstance(self._credentials, dict):
-            if isinstance(self._credentials.get("access_token"), Secret):
+        elif isinstance(self._credentials, dict):  # pyright: ignore[reportUnnecessaryIsInstance]
+            if isinstance(
+                access_token := self._credentials.get("access_token"), Secret
+            ):
                 pull_step["prefect.deployments.steps.git_clone"]["credentials"] = {
                     **self._credentials,
                     "access_token": (
-                        "{{"
-                        f" {self._credentials['access_token'].get_block_placeholder()} }}}}"
+                        f"{{{{ {access_token.get_block_placeholder()} }}}}"
                     ),
                 }
             elif self._credentials.get("access_token") is not None:
@@ -455,10 +454,10 @@ class RemoteStorage:
 
         def replace_blocks_with_values(obj: Any) -> Any:
             if isinstance(obj, Block):
-                if hasattr(obj, "get"):
-                    return obj.get()
+                if get := getattr(obj, "get", None):
+                    return get()
                 if hasattr(obj, "value"):
-                    return obj.value
+                    return getattr(obj, "value")
                 else:
                     return obj.model_dump()
             return obj
@@ -467,7 +466,7 @@ class RemoteStorage:
             self._settings, replace_blocks_with_values, return_data=True
         )
 
-        return fsspec.filesystem(scheme, **settings_with_block_values)
+        return fsspec.filesystem(scheme, **settings_with_block_values)  # pyright: ignore[reportUnknownMemberType] missing type stubs
 
     def set_base_path(self, path: Path) -> None:
         self._storage_base_path = path
@@ -513,7 +512,7 @@ class RemoteStorage:
         try:
             await from_async.wait_for_call_in_new_thread(
                 create_call(
-                    self._filesystem.get,
+                    self._filesystem.get,  # pyright: ignore[reportUnknownArgumentType, reportUnknownMemberType] missing type stubs
                     remote_path,
                     str(self.destination),
                     recursive=True,
@@ -580,18 +579,14 @@ class BlockStorageAdapter:
         self._block = block
         self._pull_interval = pull_interval
         self._storage_base_path = Path.cwd()
-        if not isinstance(block, Block):
+        if not isinstance(block, Block):  # pyright: ignore[reportUnnecessaryIsInstance]
             raise TypeError(
                 f"Expected a block object. Received a {type(block).__name__!r} object."
             )
         if not hasattr(block, "get_directory"):
             raise ValueError("Provided block must have a `get_directory` method.")
 
-        self._name = (
-            f"{block.get_block_type_slug()}-{block._block_document_name}"
-            if block._block_document_name
-            else str(uuid4())
-        )
+        self._name = f"{block.get_block_type_slug()}-{getattr(block, '_block_document_name', uuid4())}"
 
     def set_base_path(self, path: Path) -> None:
         self._storage_base_path = path
@@ -610,11 +605,11 @@ class BlockStorageAdapter:
         await self._block.get_directory(local_path=str(self.destination))
 
     def to_pull_step(self) -> dict[str, Any]:
-        # Give blocks the change to implement their own pull step
+        # Give blocks the chance to implement their own pull step
         if hasattr(self._block, "get_pull_step"):
-            return self._block.get_pull_step()
+            return getattr(self._block, "get_pull_step")()
         else:
-            if not self._block._block_document_name:
+            if getattr(self._block, "_block_document_name", None) is None:
                 raise BlockNotSavedError(
                     "Block must be saved with `.save()` before it can be converted to a"
                     " pull step."
@@ -622,7 +617,7 @@ class BlockStorageAdapter:
             return {
                 "prefect.deployments.steps.pull_with_block": {
                     "block_type_slug": self._block.get_block_type_slug(),
-                    "block_document_name": self._block._block_document_name,
+                    "block_document_name": getattr(self._block, "_block_document_name"),
                 }
             }
 
@@ -723,7 +718,9 @@ def create_storage_from_source(
         return LocalStorage(path=source, pull_interval=pull_interval)
 
 
-def _format_token_from_credentials(netloc: str, credentials: dict) -> str:
+def _format_token_from_credentials(
+    netloc: str, credentials: dict[str, Any] | GitCredentials
+) -> str:
     """
     Formats the credentials block for the git provider.
 
@@ -736,7 +733,10 @@ def _format_token_from_credentials(netloc: str, credentials: dict) -> str:
     token = credentials.get("token") if credentials else None
     access_token = credentials.get("access_token") if credentials else None
 
-    user_provided_token = access_token or token or password
+    user_provided_token: str | Secret[str] | None = access_token or token or password
+
+    if isinstance(user_provided_token, Secret):
+        user_provided_token = user_provided_token.get()
 
     if not user_provided_token:
         raise ValueError(
@@ -787,7 +787,7 @@ def _strip_auth_from_url(url: str) -> str:
 
     # Construct a new netloc without the auth info
     netloc = parsed.hostname
-    if parsed.port:
+    if parsed.port and netloc:
         netloc += f":{parsed.port}"
 
     # Build the sanitized URL

prefect/runner/submit.py

@@ -3,15 +3,19 @@ from __future__ import annotations
 import asyncio
 import inspect
 import uuid
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union, overload
+from typing import TYPE_CHECKING, Any, Union, overload
 
 import anyio
 import httpx
 from typing_extensions import Literal, TypeAlias
 
 from prefect.client.orchestration import get_client
-from prefect.client.schemas.filters import FlowRunFilter, TaskRunFilter
-from prefect.client.schemas.objects import FlowRun
+from prefect.client.schemas.filters import (
+    FlowRunFilter,
+    FlowRunFilterParentFlowRunId,
+    TaskRunFilter,
+)
+from prefect.client.schemas.objects import Constant, FlowRun, Parameter, TaskRunResult
 from prefect.context import FlowRunContext
 from prefect.flows import Flow
 from prefect.logging import get_logger
@@ -60,18 +64,20 @@ async def _submit_flow_to_runner(
 
         parent_flow_run_context = FlowRunContext.get()
 
-        task_inputs = {
-            k: await collect_task_run_inputs(v) for k, v in parameters.items()
+        task_inputs: dict[str, list[TaskRunResult | Parameter | Constant]] = {
+            k: list(await collect_task_run_inputs(v)) for k, v in parameters.items()
         }
         parameters = await resolve_inputs(parameters)
         dummy_task = Task(name=flow.name, fn=flow.fn, version=flow.version)
         parent_task_run = await client.create_task_run(
             task=dummy_task,
             flow_run_id=(
-                parent_flow_run_context.flow_run.id if parent_flow_run_context else None
+                parent_flow_run_context.flow_run.id
+                if parent_flow_run_context and parent_flow_run_context.flow_run
+                else None
             ),
             dynamic_key=(
-                dynamic_key_for_task_run(parent_flow_run_context, dummy_task)
+                str(dynamic_key_for_task_run(parent_flow_run_context, dummy_task))
                 if parent_flow_run_context
                 else str(uuid.uuid4())
             ),
@@ -79,14 +85,15 @@ async def _submit_flow_to_runner(
             state=Pending(),
         )
 
-        response = await client._client.post(
+        httpx_client = getattr(client, "_client")
+        response = await httpx_client.post(
             (
                 f"http://{PREFECT_RUNNER_SERVER_HOST.value()}"
                 f":{PREFECT_RUNNER_SERVER_PORT.value()}"
                 "/flow/run"
             ),
             json={
-                "entrypoint": flow._entrypoint,
+                "entrypoint": getattr(flow, "_entrypoint"),
                 "parameters": flow.serialize_parameters(parameters),
                 "parent_task_run_id": str(parent_task_run.id),
             },
@@ -98,15 +105,15 @@ async def _submit_flow_to_runner(
 
 @overload
 def submit_to_runner(
-    prefect_callable: Union[Flow[Any, Any], Task[Any, Any]],
-    parameters: Dict[str, Any],
+    prefect_callable: Flow[Any, Any] | Task[Any, Any],
+    parameters: dict[str, Any],
     retry_failed_submissions: bool = True,
 ) -> FlowRun: ...
 
 
 @overload
 def submit_to_runner(
-    prefect_callable: Union[Flow[Any, Any], Task[Any, Any]],
+    prefect_callable: Flow[Any, Any] | Task[Any, Any],
     parameters: list[dict[str, Any]],
     retry_failed_submissions: bool = True,
 ) -> list[FlowRun]: ...
@@ -114,10 +121,10 @@ def submit_to_runner(
 
 @sync_compatible
 async def submit_to_runner(
-    prefect_callable: FlowOrTask,
-    parameters: Optional[Union[dict[str, Any], list[dict[str, Any]]]] = None,
+    prefect_callable: Flow[Any, Any],
+    parameters: dict[str, Any] | list[dict[str, Any]] | None = None,
     retry_failed_submissions: bool = True,
-) -> Union[FlowRun, list[FlowRun]]:
+) -> FlowRun | list[FlowRun]:
     """
     Submit a callable in the background via the runner webserver one or more times.
 
@@ -127,22 +134,22 @@ async def submit_to_runner(
             each dictionary represents a discrete invocation of the callable
         retry_failed_submissions: Whether to retry failed submissions to the runner webserver.
     """
-    if not isinstance(prefect_callable, (Flow, Task)):
+    if not isinstance(prefect_callable, Flow):  # pyright: ignore[reportUnnecessaryIsInstance]
         raise TypeError(
             "The `submit_to_runner` utility only supports submitting flows and tasks."
         )
 
     parameters = parameters or {}
-    if isinstance(parameters, List):
+    if isinstance(parameters, list):
         return_single = False
-    elif isinstance(parameters, dict):
+    elif isinstance(parameters, dict):  # pyright: ignore[reportUnnecessaryIsInstance]
         parameters = [parameters]
         return_single = True
     else:
         raise TypeError("Parameters must be a dictionary or a list of dictionaries.")
 
-    submitted_runs = []
-    unsubmitted_parameters = []
+    submitted_runs: list[FlowRun] = []
+    unsubmitted_parameters: list[dict[str, Any]] = []
 
     for p in parameters:
         try:
@@ -181,9 +188,9 @@ async def submit_to_runner(
 
 @sync_compatible
 async def wait_for_submitted_runs(
-    flow_run_filter: Optional[FlowRunFilter] = None,
-    task_run_filter: Optional[TaskRunFilter] = None,
-    timeout: Optional[float] = None,
+    flow_run_filter: FlowRunFilter | None = None,
+    task_run_filter: TaskRunFilter | None = None,
+    timeout: float | None = None,
     poll_interval: float = 3.0,
 ):
     """
@@ -197,7 +204,9 @@ async def wait_for_submitted_runs(
         poll_interval: How long to wait between polling each run's state (seconds).
     """
 
-    parent_flow_run_id = ctx.flow_run.id if (ctx := FlowRunContext.get()) else None
+    parent_flow_run_id = (
+        ctx.flow_run.id if ((ctx := FlowRunContext.get()) and ctx.flow_run) else None
+    )
 
     if task_run_filter:
         raise NotImplementedError("Waiting for task runs is not yet supported.")
@@ -223,7 +232,9 @@ async def wait_for_submitted_runs(
             if parent_flow_run_id is not None:
                 subflow_runs = await client.read_flow_runs(
                     flow_run_filter=FlowRunFilter(
-                        parent_flow_run_id=dict(any_=[parent_flow_run_id])
+                        parent_flow_run_id=FlowRunFilterParentFlowRunId(
+                            any_=[parent_flow_run_id]
+                        )
                     )
                 )