prefect-client 3.1.5__py3-none-any.whl → 3.1.7__py3-none-any.whl

prefect/logging/configuration.py

@@ -58,7 +58,7 @@ def load_logging_config(path: Path) -> dict:
     return flatdict_to_dict(flat_config)
 
 
-def setup_logging(incremental: Optional[bool] = None) -> dict:
+def setup_logging(incremental: Optional[bool] = None) -> dict[str, Any]:
     """
     Sets up logging.
 

prefect/logging/highlighters.py

@@ -45,8 +45,7 @@ class StateHighlighter(RegexHighlighter):
 
     base_style = "state."
     highlights = [
-        rf"(?P<{state.value.lower()}_state>{state.value.title()})"
-        for state in StateType
+        rf"(?P<{state.lower()}_state>{state.title()})" for state in StateType
     ] + [
         r"(?P<cached_state>Cached)(?=\(type=COMPLETED\))"  # Highlight only "Cached"
     ]

prefect/logging/loggers.py

@@ -4,12 +4,11 @@ import sys
 from builtins import print
 from contextlib import contextmanager
 from functools import lru_cache
-from logging import LoggerAdapter, LogRecord
-from typing import TYPE_CHECKING, Dict, List, Optional, Union
+from logging import LogRecord
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 
 from typing_extensions import Self
 
-import prefect
 from prefect.exceptions import MissingContextError
 from prefect.logging.filters import ObfuscateApiKeyFilter
 from prefect.telemetry.logging import add_telemetry_log_handler
@@ -22,8 +21,13 @@ if TYPE_CHECKING:
     from prefect.tasks import Task
     from prefect.workers.base import BaseWorker
 
+if sys.version_info >= (3, 12):
+    LoggingAdapter = logging.LoggerAdapter[logging.Logger]
+else:
+    LoggingAdapter = logging.LoggerAdapter
 
-class PrefectLogAdapter(logging.LoggerAdapter):
+
+class PrefectLogAdapter(LoggingAdapter):
     """
     Adapter that ensures extra kwargs are passed through correctly; without this
     the `extra` fields set on the adapter would overshadow any provided on a
@@ -83,8 +87,8 @@ def get_logger(name: Optional[str] = None) -> logging.Logger:
 
 
 def get_run_logger(
-    context: Optional["RunContext"] = None, **kwargs: str
-) -> Union[logging.Logger, logging.LoggerAdapter]:
+    context: Optional["RunContext"] = None, **kwargs: Any
+) -> Union[logging.Logger, LoggingAdapter]:
     """
     Get a Prefect logger for the current task run or flow run.
 
@@ -103,15 +107,17 @@ def get_run_logger(
     Raises:
         MissingContextError: If no context can be found
     """
+    from prefect.context import FlowRunContext, TaskRunContext
+
     # Check for existing contexts
-    task_run_context = prefect.context.TaskRunContext.get()
-    flow_run_context = prefect.context.FlowRunContext.get()
+    task_run_context = TaskRunContext.get()
+    flow_run_context = FlowRunContext.get()
 
     # Apply the context override
     if context:
-        if isinstance(context, prefect.context.FlowRunContext):
+        if isinstance(context, FlowRunContext):
             flow_run_context = context
-        elif isinstance(context, prefect.context.TaskRunContext):
+        elif isinstance(context, TaskRunContext):
             task_run_context = context
         else:
             raise TypeError(
@@ -130,7 +136,9 @@ def get_run_logger(
         )
     elif flow_run_context:
         logger = flow_run_logger(
-            flow_run=flow_run_context.flow_run, flow=flow_run_context.flow, **kwargs
+            flow_run=flow_run_context.flow_run,  # type: ignore
+            flow=flow_run_context.flow,
+            **kwargs,
         )
     elif (
         get_logger("prefect.flow_run").disabled
@@ -151,9 +159,9 @@ def get_run_logger(
 
 def flow_run_logger(
     flow_run: Union["FlowRun", "ClientFlowRun"],
-    flow: Optional["Flow"] = None,
+    flow: Optional["Flow[Any, Any]"] = None,
     **kwargs: str,
-) -> LoggerAdapter:
+) -> LoggingAdapter:
     """
     Create a flow run logger with the run's metadata attached.
 
@@ -177,10 +185,10 @@ def flow_run_logger(
 
 def task_run_logger(
     task_run: "TaskRun",
-    task: "Task" = None,
-    flow_run: "FlowRun" = None,
-    flow: "Flow" = None,
-    **kwargs: str,
+    task: Optional["Task[Any, Any]"] = None,
+    flow_run: Optional["FlowRun"] = None,
+    flow: Optional["Flow[Any, Any]"] = None,
+    **kwargs: Any,
 ):
     """
     Create a task run logger with the run's metadata attached.
@@ -193,8 +201,10 @@ def task_run_logger(
     If only the flow run context is available, it will be used for default values
     of `flow_run` and `flow`.
     """
+    from prefect.context import FlowRunContext
+
     if not flow_run or not flow:
-        flow_run_context = prefect.context.FlowRunContext.get()
+        flow_run_context = FlowRunContext.get()
         if flow_run_context:
             flow_run = flow_run or flow_run_context.flow_run
             flow = flow or flow_run_context.flow
@@ -269,7 +279,7 @@ def disable_run_logger():
         yield
 
 
-def print_as_log(*args, **kwargs):
+def print_as_log(*args: Any, **kwargs: Any) -> None:
     """
     A patch for `print` to send printed messages to the Prefect run logger.
 
@@ -333,7 +343,7 @@ class LogEavesdropper(logging.Handler):
         # Outputs: "Hello, world!\nAnother one!"
     """
 
-    _target_logger: logging.Logger
+    _target_logger: Optional[logging.Logger]
     _lines: List[str]
 
     def __init__(self, eavesdrop_on: str, level: int = logging.NOTSET):

prefect/main.py

@@ -1,16 +1,18 @@
 # Import user-facing API
+from typing import Any
+
 from prefect.deployments import deploy
 from prefect.states import State
 from prefect.logging import get_run_logger
-from prefect.flows import flow, Flow, serve
+from prefect.flows import flow, Flow, serve, aserve
 from prefect.transactions import Transaction
 from prefect.tasks import task, Task
 from prefect.context import tags
 from prefect.utilities.annotations import unmapped, allow_failure
 from prefect.results import BaseResult, ResultRecordMetadata
 from prefect.flow_runs import pause_flow_run, resume_flow_run, suspend_flow_run
-from prefect.client.orchestration import get_client, PrefectClient
-from prefect.client.cloud import get_cloud_client, CloudClient
+from prefect.client.orchestration import get_client
+from prefect.client.cloud import get_cloud_client
 import prefect.variables
 import prefect.runtime
 
@@ -25,28 +27,17 @@ import prefect.context
 # Perform any forward-ref updates needed for Pydantic models
 import prefect.client.schemas
 
-prefect.context.FlowRunContext.model_rebuild(
-    _types_namespace={
-        "Flow": Flow,
-        "BaseResult": BaseResult,
-        "ResultRecordMetadata": ResultRecordMetadata,
-    }
-)
-prefect.context.TaskRunContext.model_rebuild(
-    _types_namespace={"Task": Task, "BaseResult": BaseResult}
-)
-prefect.client.schemas.State.model_rebuild(
-    _types_namespace={
-        "BaseResult": BaseResult,
-        "ResultRecordMetadata": ResultRecordMetadata,
-    }
-)
-prefect.client.schemas.StateCreate.model_rebuild(
-    _types_namespace={
-        "BaseResult": BaseResult,
-        "ResultRecordMetadata": ResultRecordMetadata,
-    }
+_types: dict[str, Any] = dict(
+    Task=Task,
+    Flow=Flow,
+    BaseResult=BaseResult,
+    ResultRecordMetadata=ResultRecordMetadata,
 )
+prefect.context.FlowRunContext.model_rebuild(_types_namespace=_types)
+prefect.context.TaskRunContext.model_rebuild(_types_namespace=_types)
+prefect.client.schemas.State.model_rebuild(_types_namespace=_types)
+prefect.client.schemas.StateCreate.model_rebuild(_types_namespace=_types)
+prefect.client.schemas.OrchestrationResult.model_rebuild(_types_namespace=_types)
 Transaction.model_rebuild()
 
 # Configure logging
@@ -76,6 +67,7 @@ __all__ = [
     "flow",
     "Flow",
     "get_client",
+    "get_cloud_client",
     "get_run_logger",
     "State",
     "tags",
@@ -84,6 +76,7 @@ __all__ = [
     "Transaction",
     "unmapped",
     "serve",
+    "aserve",
     "deploy",
     "pause_flow_run",
     "resume_flow_run",

prefect/results.py

@@ -35,10 +35,13 @@ from pydantic import (
     model_validator,
 )
 from pydantic_core import PydanticUndefinedType
-from pydantic_extra_types.pendulum_dt import DateTime
 from typing_extensions import ParamSpec, Self
 
 import prefect
+from prefect._experimental.lineage import (
+    emit_result_read_event,
+    emit_result_write_event,
+)
 from prefect._internal.compatibility import deprecated
 from prefect._internal.compatibility.deprecated import deprecated_field
 from prefect.blocks.core import Block
@@ -57,6 +60,7 @@ from prefect.locking.protocol import LockManager
 from prefect.logging import get_logger
 from prefect.serializers import PickleSerializer, Serializer
 from prefect.settings.context import get_current_settings
+from prefect.types import DateTime
 from prefect.utilities.annotations import NotSet
 from prefect.utilities.asyncutils import sync_compatible
 from prefect.utilities.pydantic import get_dispatch_key, lookup_type, register_base_type
@@ -129,7 +133,7 @@ async def resolve_result_storage(
     elif isinstance(result_storage, Path):
         storage_block = LocalFileSystem(basepath=str(result_storage))
     elif isinstance(result_storage, str):
-        storage_block = await Block.load(result_storage, client=client)
+        storage_block = await Block.aload(result_storage, client=client)
         storage_block_id = storage_block._block_document_id
         assert storage_block_id is not None, "Loaded storage blocks must have ids"
     elif isinstance(result_storage, UUID):
@@ -168,7 +172,7 @@ async def get_or_create_default_task_scheduling_storage() -> ResultStorage:
     default_block = settings.tasks.scheduling.default_storage_block
 
     if default_block is not None:
-        return await Block.load(default_block)
+        return await Block.aload(default_block)
 
     # otherwise, use the local file system
     basepath = settings.results.local_storage_path
@@ -232,6 +236,10 @@ def _format_user_supplied_storage_key(key: str) -> str:
 T = TypeVar("T")
 
 
+def default_cache() -> LRUCache[str, "ResultRecord[Any]"]:
+    return LRUCache(maxsize=1000)
+
+
 def result_storage_discriminator(x: Any) -> str:
     if isinstance(x, dict):
         if "block_type_slug" in x:
@@ -284,7 +292,7 @@ class ResultStore(BaseModel):
     cache_result_in_memory: bool = Field(default=True)
     serializer: Serializer = Field(default_factory=get_default_result_serializer)
     storage_key_fn: Callable[[], str] = Field(default=DEFAULT_STORAGE_KEY_FN)
-    cache: LRUCache = Field(default_factory=lambda: LRUCache(maxsize=1000))
+    cache: LRUCache[str, "ResultRecord[Any]"] = Field(default_factory=default_cache)
 
     # Deprecated fields
     persist_result: Optional[bool] = Field(default=None)
@@ -319,7 +327,7 @@ class ResultStore(BaseModel):
         return self.model_copy(update=update)
 
     @sync_compatible
-    async def update_for_task(self: Self, task: "Task") -> Self:
+    async def update_for_task(self: Self, task: "Task[P, R]") -> Self:
         """
         Create a new result store for a task.
 
@@ -446,8 +454,15 @@ class ResultStore(BaseModel):
         """
         return await self._exists(key=key, _sync=False)
 
+    def _resolved_key_path(self, key: str) -> str:
+        if self.result_storage_block_id is None and hasattr(
+            self.result_storage, "_resolve_path"
+        ):
+            return str(self.result_storage._resolve_path(key))
+        return key
+
     @sync_compatible
-    async def _read(self, key: str, holder: str) -> "ResultRecord":
+    async def _read(self, key: str, holder: str) -> "ResultRecord[Any]":
         """
         Read a result record from storage.
 
@@ -465,8 +480,12 @@ class ResultStore(BaseModel):
         if self.lock_manager is not None and not self.is_lock_holder(key, holder):
             await self.await_for_lock(key)
 
-        if key in self.cache:
-            return self.cache[key]
+        resolved_key_path = self._resolved_key_path(key)
+
+        if resolved_key_path in self.cache:
+            cached_result = self.cache[resolved_key_path]
+            await emit_result_read_event(self, resolved_key_path, cached=True)
+            return cached_result
 
         if self.result_storage is None:
             self.result_storage = await get_default_result_storage()
@@ -478,31 +497,28 @@ class ResultStore(BaseModel):
                 metadata.storage_key is not None
             ), "Did not find storage key in metadata"
             result_content = await self.result_storage.read_path(metadata.storage_key)
-            result_record = ResultRecord.deserialize_from_result_and_metadata(
+            result_record: ResultRecord[
+                Any
+            ] = ResultRecord.deserialize_from_result_and_metadata(
                 result=result_content, metadata=metadata_content
             )
+            await emit_result_read_event(self, resolved_key_path)
         else:
             content = await self.result_storage.read_path(key)
-            result_record = ResultRecord.deserialize(
+            result_record: ResultRecord[Any] = ResultRecord.deserialize(
                 content, backup_serializer=self.serializer
             )
+            await emit_result_read_event(self, resolved_key_path)
 
         if self.cache_result_in_memory:
-            if self.result_storage_block_id is None and hasattr(
-                self.result_storage, "_resolve_path"
-            ):
-                cache_key = str(self.result_storage._resolve_path(key))
-            else:
-                cache_key = key
-
-            self.cache[cache_key] = result_record
+            self.cache[resolved_key_path] = result_record
         return result_record
 
     def read(
         self,
         key: str,
         holder: Optional[str] = None,
-    ) -> "ResultRecord":
+    ) -> "ResultRecord[Any]":
         """
         Read a result record from storage.
 
@@ -520,7 +536,7 @@ class ResultStore(BaseModel):
         self,
         key: str,
         holder: Optional[str] = None,
-    ) -> "ResultRecord":
+    ) -> "ResultRecord[Any]":
         """
         Read a result record from storage.
 
@@ -663,12 +679,13 @@ class ResultStore(BaseModel):
                 base_key,
                 content=result_record.serialize_metadata(),
             )
+            await emit_result_write_event(self, result_record.metadata.storage_key)
         # Otherwise, write the result metadata and result together
         else:
             await self.result_storage.write_path(
                 result_record.metadata.storage_key, content=result_record.serialize()
             )
-
+            await emit_result_write_event(self, result_record.metadata.storage_key)
         if self.cache_result_in_memory:
             self.cache[key] = result_record
 
@@ -898,7 +915,11 @@ class ResultStore(BaseModel):
         )
 
     @sync_compatible
-    async def read_parameters(self, identifier: UUID) -> Dict[str, Any]:
+    async def read_parameters(self, identifier: UUID) -> dict[str, Any]:
+        if self.result_storage is None:
+            raise ValueError(
+                "Result store is not configured - must have a result storage block to read parameters"
+            )
         record = ResultRecord.deserialize(
             await self.result_storage.read_path(f"parameters/{identifier}")
         )

prefect/runner/runner.py

@@ -43,7 +43,17 @@ import threading
 from copy import deepcopy
 from functools import partial
 from pathlib import Path
-from typing import TYPE_CHECKING, Callable, Dict, Iterable, List, Optional, Set, Union
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    Iterable,
+    List,
+    Optional,
+    Set,
+    Union,
+)
 from uuid import UUID, uuid4
 
 import anyio
@@ -190,7 +200,7 @@ class Runner:
         self._cancelling_flow_run_ids = set()
         self._scheduled_task_scopes = set()
         self._deployment_ids: Set[UUID] = set()
-        self._flow_run_process_map: Dict[UUID, Dict] = dict()
+        self._flow_run_process_map: dict[UUID, dict[str, Any]] = dict()
 
         self._tmp_dir: Path = (
             Path(tempfile.gettempdir()) / "runner_storage" / str(uuid4())
@@ -432,10 +442,14 @@ class Runner:
                     )
                 )
 
-    def execute_in_background(self, func, *args, **kwargs):
+    def execute_in_background(
+        self, func: Callable[..., Any], *args: Any, **kwargs: Any
+    ):
         """
         Executes a function in the background.
         """
+        if TYPE_CHECKING:
+            assert self._loop is not None
 
         return asyncio.run_coroutine_threadsafe(func(*args, **kwargs), self._loop)
 
@@ -536,7 +550,7 @@ class Runner:
     async def _run_process(
         self,
         flow_run: "FlowRun",
-        task_status: Optional[anyio.abc.TaskStatus] = None,
+        task_status: Optional[anyio.abc.TaskStatus[Any]] = None,
         entrypoint: Optional[str] = None,
     ):
         """
@@ -723,7 +737,9 @@ class Runner:
         return await self._submit_scheduled_flow_runs(flow_run_response=runs_response)
 
     async def _check_for_cancelled_flow_runs(
-        self, should_stop: Callable = lambda: False, on_stop: Callable = lambda: None
+        self,
+        should_stop: Callable[[], bool] = lambda: False,
+        on_stop: Callable[[], None] = lambda: None,
     ):
         """
         Checks for flow runs with CANCELLING a cancelling state and attempts to
@@ -862,31 +878,37 @@ class Runner:
         flow: "Optional[APIFlow]",
         deployment: "Optional[Deployment]",
     ):
-        related = []
-        tags = []
+        related: list[RelatedResource] = []
+        tags: list[str] = []
         if deployment:
             related.append(
-                {
-                    "prefect.resource.id": f"prefect.deployment.{deployment.id}",
-                    "prefect.resource.role": "deployment",
-                    "prefect.resource.name": deployment.name,
-                }
+                RelatedResource(
+                    {
+                        "prefect.resource.id": f"prefect.deployment.{deployment.id}",
+                        "prefect.resource.role": "deployment",
+                        "prefect.resource.name": deployment.name,
+                    }
+                )
             )
             tags.extend(deployment.tags)
         if flow:
             related.append(
+                RelatedResource(
+                    {
+                        "prefect.resource.id": f"prefect.flow.{flow.id}",
+                        "prefect.resource.role": "flow",
+                        "prefect.resource.name": flow.name,
+                    }
+                )
+            )
+        related.append(
+            RelatedResource(
                 {
-                    "prefect.resource.id": f"prefect.flow.{flow.id}",
-                    "prefect.resource.role": "flow",
-                    "prefect.resource.name": flow.name,
+                    "prefect.resource.id": f"prefect.flow-run.{flow_run.id}",
+                    "prefect.resource.role": "flow-run",
+                    "prefect.resource.name": flow_run.name,
                 }
             )
-        related.append(
-            {
-                "prefect.resource.id": f"prefect.flow-run.{flow_run.id}",
-                "prefect.resource.role": "flow-run",
-                "prefect.resource.name": flow_run.name,
-            }
         )
         tags.extend(flow_run.tags)
 

prefect/runner/server.py

@@ -1,5 +1,5 @@
 import uuid
-from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Tuple
+from typing import TYPE_CHECKING, Any, Callable, Coroutine, Hashable, Optional, Tuple
 
 import pendulum
 import uvicorn
@@ -22,7 +22,7 @@ from prefect.settings import (
     PREFECT_RUNNER_SERVER_MISSED_POLLS_TOLERANCE,
     PREFECT_RUNNER_SERVER_PORT,
 )
-from prefect.utilities.asyncutils import sync_compatible
+from prefect.utilities.asyncutils import run_coro_as_sync
 from prefect.utilities.importtools import load_script_as_module
 
 if TYPE_CHECKING:
@@ -38,11 +38,13 @@ RunnableEndpoint = Literal["deployment", "flow", "task"]
 
 class RunnerGenericFlowRunRequest(BaseModel):
     entrypoint: str
-    parameters: Optional[Dict[str, Any]] = None
+    parameters: Optional[dict[str, Any]] = None
     parent_task_run_id: Optional[uuid.UUID] = None
 
 
-def perform_health_check(runner, delay_threshold: Optional[int] = None) -> JSONResponse:
+def perform_health_check(
+    runner: "Runner", delay_threshold: Optional[int] = None
+) -> Callable[..., JSONResponse]:
     if delay_threshold is None:
         delay_threshold = (
             PREFECT_RUNNER_SERVER_MISSED_POLLS_TOLERANCE.value()
@@ -63,15 +65,15 @@ def perform_health_check(runner, delay_threshold: Optional[int] = None) -> JSONR
     return _health_check
 
 
-def run_count(runner) -> int:
-    def _run_count():
-        run_count = len(runner._flow_run_process_map)
+def run_count(runner: "Runner") -> Callable[..., int]:
+    def _run_count() -> int:
+        run_count = len(runner._flow_run_process_map)  # pyright: ignore[reportPrivateUsage]
         return run_count
 
     return _run_count
 
 
-def shutdown(runner) -> int:
+def shutdown(runner: "Runner") -> Callable[..., JSONResponse]:
     def _shutdown():
         runner.stop()
         return JSONResponse(status_code=status.HTTP_200_OK, content={"message": "OK"})
@@ -81,9 +83,9 @@ def shutdown(runner) -> int:
 
 async def _build_endpoint_for_deployment(
     deployment: "DeploymentResponse", runner: "Runner"
-) -> Callable:
+) -> Callable[..., Coroutine[Any, Any, JSONResponse]]:
     async def _create_flow_run_for_deployment(
-        body: Optional[Dict[Any, Any]] = None,
+        body: Optional[dict[Any, Any]] = None,
     ) -> JSONResponse:
         body = body or {}
         if deployment.enforce_parameter_schema and deployment.parameter_openapi_schema:
@@ -116,11 +118,11 @@ async def _build_endpoint_for_deployment(
 
 async def get_deployment_router(
     runner: "Runner",
-) -> Tuple[APIRouter, Dict[str, Dict]]:
+) -> Tuple[APIRouter, dict[Hashable, Any]]:
     router = APIRouter()
-    schemas = {}
+    schemas: dict[Hashable, Any] = {}
     async with get_client() as client:
-        for deployment_id in runner._deployment_ids:
+        for deployment_id in runner._deployment_ids:  # pyright: ignore[reportPrivateUsage]
             deployment = await client.read_deployment(deployment_id)
             router.add_api_route(
                 f"/deployment/{deployment.id}/run",
@@ -142,21 +144,21 @@ async def get_deployment_router(
     return router, schemas
 
 
-async def get_subflow_schemas(runner: "Runner") -> Dict[str, Dict]:
+async def get_subflow_schemas(runner: "Runner") -> dict[str, dict[str, Any]]:
     """
     Load available subflow schemas by filtering for only those subflows in the
     deployment entrypoint's import space.
     """
-    schemas = {}
+    schemas: dict[str, dict[str, Any]] = {}
     async with get_client() as client:
-        for deployment_id in runner._deployment_ids:
+        for deployment_id in runner._deployment_ids:  # pyright: ignore[reportPrivateUsage]
             deployment = await client.read_deployment(deployment_id)
             if deployment.entrypoint is None:
                 continue
 
             script = deployment.entrypoint.split(":")[0]
             module = load_script_as_module(script)
-            subflows = [
+            subflows: list[Flow[Any, Any]] = [
                 obj for obj in module.__dict__.values() if isinstance(obj, Flow)
             ]
             for flow in subflows:
@@ -165,7 +167,7 @@ async def get_subflow_schemas(runner: "Runner") -> Dict[str, Dict]:
     return schemas
 
 
-def _flow_in_schemas(flow: Flow, schemas: Dict[str, Dict]) -> bool:
+def _flow_in_schemas(flow: Flow[Any, Any], schemas: dict[str, dict[str, Any]]) -> bool:
     """
     Check if a flow is in the schemas dict, either by name or by name with
     dashes replaced with underscores.
@@ -174,7 +176,9 @@ def _flow_in_schemas(flow: Flow, schemas: Dict[str, Dict]) -> bool:
     return flow.name in schemas or flow_name_with_dashes in schemas
 
 
-def _flow_schema_changed(flow: Flow, schemas: Dict[str, Dict]) -> bool:
+def _flow_schema_changed(
+    flow: Flow[Any, Any], schemas: dict[str, dict[str, Any]]
+) -> bool:
     """
     Check if a flow's schemas have changed, either by bame of by name with
     dashes replaced with underscores.
@@ -188,8 +192,8 @@ def _flow_schema_changed(flow: Flow, schemas: Dict[str, Dict]) -> bool:
 
 
 def _build_generic_endpoint_for_flows(
-    runner: "Runner", schemas: Dict[str, Dict]
-) -> Callable:
+    runner: "Runner", schemas: dict[str, dict[str, Any]]
+) -> Callable[..., Coroutine[Any, Any, JSONResponse]]:
     async def _create_flow_run_for_flow_from_fqn(
         body: RunnerGenericFlowRunRequest,
     ) -> JSONResponse:
@@ -241,7 +245,6 @@ def _build_generic_endpoint_for_flows(
     return _create_flow_run_for_flow_from_fqn
 
 
-@sync_compatible
 async def build_server(runner: "Runner") -> FastAPI:
     """
     Build a FastAPI server for a runner.
@@ -297,16 +300,11 @@ def start_webserver(runner: "Runner", log_level: Optional[str] = None) -> None:
     host = PREFECT_RUNNER_SERVER_HOST.value()
     port = PREFECT_RUNNER_SERVER_PORT.value()
     log_level = log_level or PREFECT_RUNNER_SERVER_LOG_LEVEL.value()
-    webserver = build_server(runner)
+    webserver = run_coro_as_sync(build_server(runner))
+    if TYPE_CHECKING:
+        assert webserver is not None, "webserver should be built"
+        assert log_level is not None, "log_level should be set"
+
     uvicorn.run(
         webserver, host=host, port=port, log_level=log_level.lower()
     )  # Uvicorn supports only lowercase log_level
-    # From the Uvicorn config file:
-    # LOG_LEVELS: dict[str, int] = {
-    #     "critical": logging.CRITICAL,
-    #     "error": logging.ERROR,
-    #     "warning": logging.WARNING,
-    #     "info": logging.INFO,
-    #     "debug": logging.DEBUG,
-    #     "trace": TRACE_LOG_LEVEL,
-    # }